@gibs/bridge-sdk 1.9.1 → 1.12.0

package/dist/src/chain-info.js

@@ -1,350 +0,0 @@
-import { encodeFunctionData, getContract, multicall3Abi, zeroAddress } from "viem";
-import { nativeAssetOut, pathway, toChain, uniV2Routers } from "./config.js";
-import _ from "lodash";
-import { chainsMetadata } from "./chains.js";
-import * as abis from "./abis.js";
-import { multicallRead } from "@gibs/common/multicall";
-/**
- * Returns the bridged token address and native token address
- * @param chainId - the chain id being targeted
- * @param target - the target
- * @param address - the address
- * @param client - the client
- * @returns the bridged token address and native token address
- */
-export const links = _.memoize(async ({ chainId, target, address, client }) => {
-    return multicallRead({
-        client,
-        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, }) => {
-    const bridgePathway = pathway(bridgeKey, isProd, assetIn?.address);
-    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,
-            client: toChainClient,
-        }),
-        links({
-            chainId: Number(fromChain),
-            target: bridgePathway.from,
-            address: assetInAddress,
-            client: fromChainClient,
-        }),
-    ]);
-    const [toBridged, toNative] = toMappings;
-    if (toBridged !== zeroAddress) {
-        return {
-            originationChainId: fromChain,
-            assetInAddress: assetInAddress,
-            assetOutAddress: toBridged,
-            toHome: {
-                home: toBridged,
-                foreign: assetInAddress,
-            },
-        };
-    }
-    if (toNative !== zeroAddress) {
-        return {
-            originationChainId: toChain,
-            assetInAddress: assetInAddress,
-            assetOutAddress: toNative,
-            toForeign: {
-                home: toNative,
-                foreign: assetInAddress,
-            },
-        };
-    }
-    const [fromBridged, fromNative] = fromMappings;
-    if (fromNative !== zeroAddress) {
-        return {
-            originationChainId: toChain,
-            assetInAddress: assetInAddress,
-            assetOutAddress: fromNative,
-            toHome: {
-                home: assetInAddress,
-                foreign: fromNative,
-            },
-        };
-    }
-    if (fromBridged !== zeroAddress) {
-        return {
-            originationChainId: fromChain,
-            assetInAddress: assetInAddress,
-            assetOutAddress: fromBridged,
-            toForeign: {
-                foreign: fromBridged,
-                home: assetInAddress,
-            },
-        };
-    }
-    // the token has not been bridged yet
-    return {
-        originationChainId: toChain,
-        assetInAddress: assetInAddress,
-        assetOutAddress: null,
-        ...(bridgePathway.toHome
-            ? {
-                toHome: {
-                    foreign: assetInAddress,
-                    home: null,
-                },
-            }
-            : {
-                toForeign: {
-                    foreign: null,
-                    home: assetInAddress,
-                },
-            }),
-    };
-};
-/**
- * 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, }) => {
-    return multicallRead({
-        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, }) => {
-    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, }) => {
-            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, measurementToken]],
-                    // only the direct route is available.
-                    // might be able to create a whitelist for this at some point
-                }),
-            ]);
-        },
-        reduceResults: ({ results, oneToken, }) => {
-            const outputFromRouter = (result) => {
-                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) => {
-                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, }) => {
-    const publicClient = pathway?.feeManager === 'from' ? fromPublicClient : toPublicClient;
-    return publicClient.readContract({
-        abi: abis.inputBridge,
-        functionName: 'minPerTx',
-        args: [assetIn.address],
-        address: pathway[pathway.feeManager],
-    });
-};
-/** get the symbol of the native asset, unwrap it if it needs to be */
-export const nativeSymbol = (asset, unwrap = false) => {
-    return asset ? (unwrap && asset.address === nativeAssetOut[toChain(asset.chainId)] ? asset.symbol.slice(1) : asset.symbol) : '';
-};
-/**
- * Returns the chain multicall for the given client
- * @param client - the client
- * @returns the chain multicall
- */
-export const chainMulticall = (client) => {
-    const chainId = client.chain.id;
-    const metadata = chainsMetadata[toChain(chainId)];
-    return getContract({
-        abi: multicall3Abi,
-        client: client,
-        address: metadata.contracts.multicall3.address,
-    });
-};
-/**
- * Load the bridge fees for the given pathway, from chain client, and to chain client
- * @param pathway - the pathway
- * @param fromChainClient - the from chain client
- * @param toChainClient - the to chain client
- * @returns the bridge fees
- */
-export const loadBridgeFees = async ({ pathway, fromChainClient, toChainClient }) => {
-    const multicall = pathway.feeManager === 'from'
-        ? chainMulticall(fromChainClient)
-        : 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)}`);
-    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),
-    };
-    return setting;
-};

package/dist/src/chains.d.ts

@@ -1,6 +0,0 @@
-import type { ChainsMetadata } from '@gibs/bridge-sdk/types';
-/**
- * all of the chains that are enabled in this dapp
- * and their corresponding useful metadata
- */
-export declare const chainsMetadata: ChainsMetadata;

package/dist/src/chains.js

@@ -1,86 +0,0 @@
-import { mainnet, pulsechain, bsc, sepolia, pulsechainV4 } from '@reown/appkit/networks';
-import { Chains } from '@gibs/bridge-sdk/config';
-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-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',
-            },
-        },
-    },
-};

package/dist/src/config.d.ts

@@ -1,136 +0,0 @@
-import { type Hex } from "viem";
-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 declare enum Chains {
-    PLS = "0x171",
-    ETH = "0x1",
-    BNB = "0x38",
-    SEP = "0xaa36a7",
-    V4PLS = "0x3af"
-}
-/** The key of a chain - human readable for query params */
-export type ChainKey = keyof typeof Chains;
-/** A map of chain ids to chain keys */
-export declare const chainIdToKey: Map<Chains, "ETH" | "PLS" | "BNB" | "SEP" | "V4PLS">;
-/**
- * Converts a chain id to a chain key
- * @param chainId - the chain id
- * @returns the chain key
- */
-export declare const toChain: (chainId: number | string) => Chains;
-/**
- * Converts a chain id to a chain key
- * @param chainId - the chain id
- * @returns the chain key
- */
-export declare const toChainKey: (chainId: number | string) => "ETH" | "PLS" | "BNB" | "SEP" | "V4PLS" | undefined;
-export declare const Providers: {
-    readonly PULSECHAIN: "pulsechain";
-    readonly TOKENSEX: "tokensex";
-};
-export type Provider = typeof Providers[keyof typeof Providers];
-/** A map of chains to native asset out addresses */
-export declare const nativeAssetOut: Record<Chains, Hex>;
-/** A map of chains to deprecated native asset out addresses */
-export declare const deprecatedNativeAssetOut: Partial<Record<Chains, Set<Hex>>>;
-/** A map of chains to uni v2 router addresses */
-export declare const uniV2Routers: Record<Chains, Hex[]>;
-/** A map of chains to native token symbols */
-export declare const nativeTokenSymbol: Record<Chains, string>;
-/** A map of chains to native token names */
-export declare const nativeTokenName: Record<Chains, string>;
-/** The pathway of a bridge */
-export type Pathway = {
-    from: Hex;
-    to: Hex;
-    destinationRouter: Hex | null;
-    nativeRouter: Hex;
-    validator: Hex;
-    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>>>>>;
-export declare const pathways: DeepPathwayConfig;
-export declare const testnetPathways: DeepPathwayConfig;
-/** Returns the valid bridge keys for the given is prod */
-export declare const validBridgeKeys: (isProd: boolean) => BridgeKey[];
-/**
- * Infers the bridge key from the current key, provider, from chain, and to chain
- * @param currentKey - the current bridge key
- * @param provider - the provider
- * @param fromChain - the from chain
- * @param toChain - the to chain
- * @returns the inferred bridge key
- */
-export declare const inferBridgeKey: ({ currentKey, provider, fromChain, toChain, }: {
-    currentKey: BridgeKey;
-    provider: Provider;
-    fromChain?: Chains;
-    toChain?: Chains;
-}) => BridgeKey;
-/**
- * Returns the pathway for the given bridge key, is prod, and asset in address
- * @param bridgeKey - the bridge key
- * @param isProd - whether to use the production pathway
- * @param assetInAddress - the asset in address
- * @returns the pathway
- */
-export declare const pathway: (bridgeKey: BridgeKey | null, isProd: boolean, assetInAddress?: string | Hex | null | undefined) => Pathway | undefined;
-/**
- * Returns the default asset in for the given bridge key and is prod
- * @param bridgeKey - the bridge key
- * @param isProd - whether to use the production pathway
- * @returns the default asset in
- */
-export declare const defaultAssetIn: ($bridgeKey: BridgeKey | null, isProd: boolean) => `0x${string}` | null | undefined;
-/**
- * Returns whether the given asset is the native asset for the given bridge key
- * @param asset - the asset
- * @param bridgeKey - the bridge key
- * @returns whether the given asset is the native asset for the given bridge key
- */
-export declare const isNative: (asset: Token | TokenOut | null, bridgeKey: BridgeKey | null) => boolean;
-/**
- * Returns whether the given asset is unwrappable for the given bridge key
- * @param bridgeKey - the bridge key
- * @param assetIn - the asset in
- * @returns whether the given asset is unwrappable for the given bridge key
- */
-export declare const isUnwrappable: (bridgeKey: BridgeKey | null, assetIn: Pick<Token, "address"> | null) => boolean;
-/**
- * Returns whether the given asset can be unwrapped for the given bridge key
- * @param bridgeKey - the bridge key
- * @param assetIn - the asset in
- * @returns boolean
- */
-export declare const canChangeUnwrap: (bridgeKey: BridgeKey, assetIn: Token | null) => boolean;
-export declare const chains: {
-    readonly ethereum: 1;
-    readonly bsc: 56;
-    readonly pulsechain: 369;
-    readonly pulsechainV4: 943;
-    readonly sepolia: 11155111;
-};
-export declare const chainIds: (1 | 56 | 369 | 943 | 11155111)[];
-export type ChainId = (typeof chainIds)[number];
-export type Side = 'home' | 'foreign';
-export type MinimalKey = `${ChainId}-${Hex}`;
-export type PathwayInfo = {
-    pair: string;
-    key: string;
-    home: Hex;
-    foreign: Hex;
-};
-export type ProviderHomeChainEntry = Partial<Record<ChainId, PathwayInfo[]>>;
-export type ProviderEntries = Partial<Record<ChainId, ProviderHomeChainEntry>>;
-export type BridgeConfig = Record<Provider, ProviderEntries>;
-export declare const bridgeConfigs: BridgeConfig;
-export declare const HOME_TO_FOREIGN_FEE: `0x${string}`;
-export declare const FOREIGN_TO_HOME_FEE: `0x${string}`;