@gibs/bridge-sdk 1.6.27 → 1.6.34

package/dist/src/chain-info.js

@@ -0,0 +1,312 @@
+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";
+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());
+export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainClient, toChainClient, }) => {
+    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,
+            client: toChainClient,
+        }),
+        links({
+            chainId: Number(fromChain),
+            target: bridgePathway.from,
+            address: assetInAddress,
+            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,
+            assetOutAddress: toBridged,
+            toForeign: {
+                foreign: toBridged,
+                home: assetInAddress,
+            },
+        };
+    }
+    if (toNative !== zeroAddress) {
+        // if (notGas) console.log('toNative')
+        return {
+            originationChainId: toChain,
+            assetInAddress: assetInAddress,
+            assetOutAddress: toNative,
+            toHome: {
+                home: toNative,
+                foreign: assetInAddress,
+            },
+        };
+    }
+    const [fromBridged, fromNative] = fromMappings;
+    if (fromNative !== zeroAddress) {
+        // if (notGas) console.log('fromNative')
+        return {
+            originationChainId: toChain,
+            assetInAddress: assetInAddress,
+            assetOutAddress: fromNative,
+            toHome: {
+                home: assetInAddress,
+                foreign: fromNative,
+            },
+        };
+    }
+    if (fromBridged !== zeroAddress) {
+        // if (notGas) console.log('fromBridged')
+        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,
+        }))),
+    });
+};
+export const fetchPriceCorrective = ({ 
+// bridgeKey,
+// assetIn,
+// isProd,
+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;
+        }
+    };
+};
+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) : '';
+};
+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,
+    });
+};
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,86 @@
+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-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',
+            },
+        },
+    },
+};

package/dist/src/config.d.ts

@@ -0,0 +1,51 @@
+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"
+}
+export type ChainKey = keyof typeof Chains;
+export declare const chainIdToKey: Map<Chains, "ETH" | "PLS" | "BNB" | "SEP" | "V4PLS">;
+export declare const toChain: (chainId: number | string) => Chains;
+export declare const toChainKey: (chainId: number | string) => "ETH" | "PLS" | "BNB" | "SEP" | "V4PLS" | undefined;
+export declare enum Provider {
+    PULSECHAIN = "pulsechain",
+    TOKENSEX = "tokensex"
+}
+export declare const nativeAssetOut: Record<Chains, Hex>;
+export declare const uniV2Routers: Record<Chains, Hex[]>;
+export declare const nativeTokenSymbol: Record<Chains, string>;
+export declare const nativeTokenName: 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 declare const pathways: DeepPathwayConfig;
+export declare const testnetPathways: DeepPathwayConfig;
+export declare const validBridgeKeys: (isProd: boolean) => BridgeKey[];
+export declare const inferBridgeKey: ({ currentKey, provider, fromChain, toChain, }: {
+    currentKey: BridgeKey;
+    provider: Provider;
+    fromChain?: Chains;
+    toChain?: Chains;
+}) => BridgeKey;
+export declare const pathway: (bridgeKey: BridgeKey | null, isProd: boolean) => Pathway | undefined;
+export declare const defaultAssetIn: ($bridgeKey: BridgeKey | null, isProd: boolean) => Token | undefined;
+export declare const isNative: (asset: Token | TokenOut | null, bridgeKey: BridgeKey | null) => boolean;
+export declare const isUnwrappable: (asset: Pick<Token, "extensions"> | null, bridgeKey: BridgeKey | null) => boolean;
+export declare const canChangeUnwrap: (bridgeKey: BridgeKey, assetIn: Token | null) => boolean;