@gibs/bridge-sdk 1.7.1 → 1.7.3

package/dist/src/image-links.d.ts

@@ -1,12 +1,41 @@
+/**
+ * Sets the image root for the bridge
+ * @param root - the root
+ */
 export declare const setImageRoot: (root: string) => void;
+/**
+ * Returns the image root for the bridge
+ * @returns the image root
+ */
 export declare const getImageRoot: () => string;
+/** The minimal token info */
 interface MinimalTokenInfo {
     chainId: number;
     address: string;
     logoURI?: string | null;
 }
+/**
+ * Returns the list image for the given path
+ * @param path - the path
+ * @returns the list image
+ */
 export declare const list: (path: string) => string;
+/**
+ * Returns the network image for the given chain id
+ * @param chainId - the chain id
+ * @returns the network image
+ */
 export declare const network: (chainId: number) => string;
+/**
+ * Returns the image url for the given token info
+ * @param t - the token info
+ * @returns the image url
+ */
 export declare const image: (t: MinimalTokenInfo) => string;
+/**
+ * Returns a url that will lookup all sources for the given array
+ * @param sources - the sources
+ * @returns the images
+ */
 export declare const images: (sources: string[]) => string;
 export {};

package/dist/src/image-links.js

@@ -1,17 +1,45 @@
 import { getAddress } from 'viem';
 let imageRoot = 'https://gib.show';
+/**
+ * Sets the image root for the bridge
+ * @param root - the root
+ */
 export const setImageRoot = (root) => {
     imageRoot = root;
 };
+/**
+ * Returns the image root for the bridge
+ * @returns the image root
+ */
 export const getImageRoot = () => imageRoot;
+/**
+ * Returns the list image for the given path
+ * @param path - the path
+ * @returns the list image
+ */
 export const list = (path) => {
     return `${imageRoot}/list${path}`;
 };
+/**
+ * Returns the network image for the given chain id
+ * @param chainId - the chain id
+ * @returns the network image
+ */
 export const network = (chainId) => {
     if (!chainId) {
         console.trace('network image');
     }
     return `${imageRoot}/image/${Number(chainId)}`;
 };
+/**
+ * Returns the image url for the given token info
+ * @param t - the token info
+ * @returns the image url
+ */
 export const image = (t) => t.logoURI || `${network(t.chainId)}/${getAddress(t.address)}`;
+/**
+ * Returns a url that will lookup all sources for the given array
+ * @param sources - the sources
+ * @returns the images
+ */
 export const images = (sources) => `${imageRoot}/image/?${sources.map((s) => `i=${s}`).join('&')}`;

package/dist/src/index.d.ts

@@ -5,3 +5,4 @@ export * from './chains.js';
 export * from './types.js';
 export * from './image-links.js';
 export * from './fee-type.js';
+export * from './settings.js';

package/dist/src/index.js

@@ -5,3 +5,4 @@ export * from './chains.js';
 export * from './types.js';
 export * from './image-links.js';
 export * from './fee-type.js';
+export * from './settings.js';

package/dist/src/settings.d.ts

@@ -0,0 +1,341 @@
+import { type Hex } from "viem";
+import { Chains, type Pathway } from "./config.js";
+import { FeeType } from "./fee-type.js";
+import type { BridgeKey, Token } from "./types.js";
+import type { TokenBridgeInfo } from "./chain-info.js";
+export declare const oneEther: bigint;
+export declare const basisPoints = 10000n;
+/**
+ * Returns the bridge pathway (configuration) for a given bridge key, asset in, and whether to use the production pathway
+ * @param bridgeKey - the bridge key to use
+ * @param isProd - whether to use the production pathway
+ * @param assetIn - the asset in to bridge
+ * @returns the bridge pathway
+ */
+export declare const bridgePathway: ({ bridgeKey, isProd, assetIn, }: {
+    bridgeKey: BridgeKey;
+    isProd: boolean;
+    assetIn: Token | null;
+}) => Pathway | null;
+/**
+ * Retrieves the amount to bridge from the amount and asset in. If either of them is nil, returns 0n
+ * @param amountIn - the amount to bridge
+ * @param assetIn - the asset in to bridge
+ * @returns the amount to bridge
+ */
+export declare const amountToBridge: ({ amountIn, assetIn, }: {
+    amountIn: bigint | null;
+    assetIn: Token | null;
+}) => bigint;
+/**
+ * Calculates the bridge cost from the amount to bridge and bridge fee
+ * @param amountToBridge - the amount to bridge
+ * @param bridgeFee - the bridge fee
+ * @returns the bridge cost
+ */
+export declare const bridgeCost: ({ amountToBridge, bridgeFee, }: {
+    amountToBridge: bigint;
+    bridgeFee: bigint | null;
+}) => bigint | null;
+/**
+ * Calculates the amount after bridge fee from the amount to bridge and bridge cost
+ * @param amountToBridge - the amount to bridge
+ * @param bridgeCost - the bridge cost
+ * @returns the amount after bridge fee
+ */
+export declare const amountAfterBridgeFee: ({ amountToBridge, bridgeCost, }: {
+    amountToBridge: bigint;
+    bridgeCost: bigint | null;
+}) => bigint | null;
+/**
+ * Calculates the estimated amount out from the amount after bridge fee and fee
+ * @param amountAfterBridgeFee - the amount after bridge fee
+ * @param fee - the fee
+ * @returns the estimated amount out
+ */
+export declare const estimatedAmountOut: ({ amountAfterBridgeFee, fee, }: {
+    amountAfterBridgeFee: bigint | null;
+    fee: bigint | null;
+}) => bigint | null;
+/**
+ * Calculates the estimated fee from the amount after bridge fee, fee, percent fee, fee type, limit, and whether to deliver the costs
+ * @param amountAfterBridgeFee - the amount after bridge fee
+ * @param fee - the fee
+ * @param percentFee - the percent fee
+ * @param feeType - the fee type
+ * @param limit - the limit
+ * @param costsToDeliver - whether to deliver the costs
+ * @returns the estimated fee
+ */
+export declare const estimatedFee: ({ amountAfterBridgeFee, fee, percentFee, feeType, limit, costsToDeliver, }: {
+    amountAfterBridgeFee: bigint | null;
+    fee: bigint;
+    percentFee: bigint;
+    feeType: FeeType;
+    limit: bigint | null;
+    costsToDeliver: boolean;
+}) => bigint | null;
+/**
+ * Calculates the estimated native network cost from the estimated gas and latest base fee per gas
+ * @param estimatedGas - the estimated gas
+ * @param latestBaseFeePerGas - the latest base fee per gas
+ * @param requiresDelivery - whether to deliver the costs
+ * @returns the estimated native network cost
+ */
+export declare const estimatedNativeNetworkCost: ({ estimatedGas, latestBaseFeePerGas, requiresDelivery, }: {
+    estimatedGas: bigint | null;
+    latestBaseFeePerGas: bigint | null;
+    requiresDelivery: boolean;
+}) => bigint | null;
+/**
+ * Calculates the estimated token network cost from the estimated native
+ * network cost, price corrective, decimals, and one token int
+ * @param estimatedNativeNetworkCost - the estimated native network cost
+ * @param priceCorrective - the price corrective
+ * @param decimals - the decimals
+ * @param oneTokenInt - the one token int
+ * @returns the estimated token network cost
+ */
+export declare const estimatedTokenNetworkCost: ({ estimatedNativeNetworkCost, priceCorrective, decimals, oneTokenInt, }: {
+    estimatedNativeNetworkCost: bigint | null;
+    priceCorrective: bigint | null;
+    decimals: number | null;
+    oneTokenInt: bigint | null;
+}) => bigint | null;
+/**
+ * Calculates one token of the asset in as an int
+ * @param assetIn - the asset in to bridge
+ * @returns the one token int
+ */
+export declare const oneTokenInt: ({ assetIn, }: {
+    assetIn: Token | null;
+}) => bigint;
+/**
+ * Returns the limit as a bigint. Nil uses 0n
+ * @param lim - the limit
+ * @returns the limit
+ */
+export declare const limit: (lim: bigint | null) => bigint;
+/**
+ * Returns the network switch asset out address from the asset out, unwrap, and to chain
+ * @param assetOut - the asset out
+ * @param unwrap - whether to unwrap
+ * @param toChain - the chain to switch to
+ * @returns the network switch asset out address
+ */
+export declare const networkSwitchAssetOutAddress: ({ assetOut, unwrap, toChain, }: {
+    assetOut: Token | null;
+    unwrap: boolean;
+    toChain: Chains;
+}) => string | null;
+/**
+ * Calculates the desired excess compensation basis points from the path, asset in, asset out, bridge key, fee type, list, and asset out address
+ * @param path - the path
+ * @param assetIn - the asset in to bridge
+ * @param assetOut - the asset out
+ * @param bridgeKey - the bridge key
+ * @param feeType - the fee type
+ * @param list - the list
+ * @param assetOutAddress - the asset out address
+ * @returns the desired excess compensation basis points
+ */
+export declare const desiredExcessCompensationBasisPoints: ({ path, assetIn, assetOut, bridgeKey, feeType, list, assetOutAddress, }: {
+    path: Pathway | null;
+    assetIn: Token | null;
+    assetOut: Token | null;
+    bridgeKey: BridgeKey;
+    feeType: FeeType;
+    list: Set<string>;
+    assetOutAddress: string | null;
+}) => 0n | 10000n | 1000n | 5000n;
+/**
+ * Calculates the estimated cost from the should deliver, amount after bridge fee, percent fee,
+ * estimated token network cost, reasonable percent on top of gas fee, and fee type
+ * @param shouldDeliver - whether to deliver the costs
+ * @param amountAfterBridgeFee - the amount after bridge fee
+ * @param percentFee - the percent fee
+ * @param estimatedTokenNetworkCost - the estimated token network cost
+ * @param reasonablePercentOnTopOfGasFee - the reasonable percent on top of gas fee
+ * @param feeType - the fee type
+ * @returns the estimated cost
+ */
+export declare const estimatedCost: ({ shouldDeliver, amountAfterBridgeFee, percentFee, estimatedTokenNetworkCost, reasonablePercentOnTopOfGasFee, feeType, }: {
+    shouldDeliver: boolean;
+    amountAfterBridgeFee: bigint | null;
+    percentFee: bigint | null;
+    estimatedTokenNetworkCost: bigint | null;
+    reasonablePercentOnTopOfGasFee: bigint | null;
+    feeType: FeeType;
+}) => bigint | null;
+/**
+ * Calculates the reasonable fixed fee from the estimated token network cost and desired excess compensation basis points
+ * @param estimatedTokenNetworkCost - the estimated token network cost
+ * @param desiredExcessCompensationBasisPoints - the desired excess compensation basis points
+ * @returns the reasonable fixed fee
+ */
+export declare const reasonableFixedFee: ({ estimatedTokenNetworkCost, desiredExcessCompensationBasisPoints, }: {
+    estimatedTokenNetworkCost: bigint | null;
+    desiredExcessCompensationBasisPoints: bigint;
+}) => bigint | null;
+/**
+ * Calculates the reasonable percent on gas limit from the gas tip fee and estimated token network cost
+ * @param gasTipFee - the gas tip fee
+ * @param estimatedTokenNetworkCost - the estimated token network cost
+ * @returns the reasonable percent on gas limit
+ */
+export declare const reasonablePercentOnGasLimit: ({ gasTipFee, estimatedTokenNetworkCost, }: {
+    gasTipFee: bigint | null;
+    estimatedTokenNetworkCost: bigint | null;
+}) => bigint;
+/**
+ * Calculates the reasonable percent fee from the reasonable fixed fee and amount after bridge fee
+ * @param reasonableFixedFee - the reasonable fixed fee
+ * @param amountAfterBridgeFee - the amount after bridge fee
+ * @returns the reasonable percent fee
+ */
+export declare const reasonablePercentFee: ({ reasonableFixedFee, amountAfterBridgeFee, }: {
+    reasonableFixedFee: bigint | null;
+    amountAfterBridgeFee: bigint | null;
+}) => bigint | null;
+/**
+ * Returns whether the asset in address is interacting with a bridge token
+ * @param assetLink - the asset link
+ * @param assetInAddress - the asset in address
+ * @returns whether the asset in address is interacting with a bridge token
+ */
+export declare const interactingWithBridgeToken: ({ assetLink, assetInAddress, }: {
+    assetLink: TokenBridgeInfo | null;
+    assetInAddress: string | null;
+}) => boolean;
+/**
+ * Calculates the fee director struct encoded from the recipient, bridge pathway, fee type, price corrective, gas tip fee, percent fee, fee type settings, limit, and asset out
+ * @param recipient - the recipient
+ * @param bridgePathway - the bridge pathway
+ * @param feeType - the fee type
+ * @param priceCorrective - the price corrective
+ * @param gasTipFee - the gas tip fee
+ * @param percentFee - the percent fee
+ * @param feeTypeSettings - the fee type settings
+ * @param limit - the limit
+ * @param assetOut - the asset out
+ * @returns the fee director struct encoded
+ */
+export declare const feeDirectorStructEncoded: ({ recipient, bridgePathway, feeType, priceCorrective, gasTipFee, percentFee, feeTypeSettings, limit, assetOut, }: {
+    recipient: Hex | null;
+    feeType: FeeType;
+    priceCorrective: bigint | null;
+    gasTipFee: bigint | null;
+    percentFee: bigint | null;
+    feeTypeSettings: bigint;
+    limit: bigint;
+    bridgePathway: Pathway | null;
+    assetOut: Token | null;
+}) => `0x${string}` | null;
+/**
+ * Calculates the destination data param from the recipient, bridge pathway, asset in, destination router, fee director struct encoded, asset link, should deliver, and unwrap
+ * @param recipient - the recipient
+ * @param bridgePathway - the bridge pathway
+ * @param assetIn - the asset in to bridge
+ * @param destinationRouter - the destination router
+ * @param feeDirectorStructEncoded - the fee director struct encoded
+ * @param assetLink - the asset link
+ * @param shouldDeliver - whether to deliver the costs
+ * @param unwrap - whether to unwrap
+ * @returns the destination data param
+ */
+export declare const destinationDataParam: ({ recipient, bridgePathway, assetIn, destinationRouter, feeDirectorStructEncoded, assetLink, shouldDeliver, unwrap, }: {
+    recipient: Hex | null;
+    bridgePathway: Pathway | null;
+    assetIn: Token | null;
+    destinationRouter: Hex | null;
+    feeDirectorStructEncoded: Hex | null;
+    assetLink: TokenBridgeInfo | null;
+    shouldDeliver: boolean;
+    unwrap: boolean;
+}) => `0x${string}` | null;
+/**
+ * Converts a desired excess compensation basis point value into a percentage as an integer, with the denominator assumed to be 1e18
+ * @param desiredExcessCompensationBasisPoints - the desired excess compensation basis points
+ * @returns the reasonable percent on top of gas fee
+ */
+export declare const reasonablePercentOnTopOfGasFee: ({ desiredExcessCompensationBasisPoints, }: {
+    desiredExcessCompensationBasisPoints: bigint;
+}) => bigint;
+/**
+ * Calculates the desired compensation ratio from the desired excess compensation basis points
+ * @param desiredExcessCompensationBasisPoints - the desired excess compensation basis points
+ * @returns the desired compensation ratio
+ */
+export declare const desiredCompensationRatio: ({ desiredExcessCompensationBasisPoints, }: {
+    desiredExcessCompensationBasisPoints: bigint;
+}) => bigint;
+/**
+ * Calculates the available compensation maximum from the amount after bridge fee, percent fee, fee type, fixed fee, and limit
+ * @param amountAfterBridgeFee - the amount after bridge fee
+ * @param percentFee - the percent fee
+ * @param feeType - the fee type
+ * @param fixedFee - the fixed fee
+ * @param limit - the limit
+ * @returns the available compensation maximum
+ */
+export declare const availableCompensationMaximum: ({ amountAfterBridgeFee, percentFee, feeType, fixedFee, limit, }: {
+    amountAfterBridgeFee: bigint | null;
+    percentFee: bigint | null;
+    feeType: FeeType;
+    fixedFee: bigint | null;
+    limit: bigint;
+}) => bigint | null;
+/**
+ * Calculates the transaction inputs from the bridge pathway, asset in, recipient, account, asset link, destination data param, amount to bridge, fee director struct encoded, and should deliver
+ * @param bridgePathway - the bridge pathway to use
+ * @param assetIn - the asset in to bridge
+ * @param recipient - the recipient of the bridge
+ * @param account - the account to bridge from
+ * @param assetLink - the asset link to use
+ * @param destinationDataParam - the destination data param to use
+ * @param amountToBridge - the amount to bridge
+ * @param feeDirectorStructEncoded - the fee director struct encoded to use
+ * @param shouldDeliver - whether to deliver the tokens to the recipient
+ * @returns the transaction inputs
+ */
+export declare const transactionInputs: ({ bridgePathway, assetIn, recipient, account, assetLink, destinationDataParam, amountToBridge, feeDirectorStructEncoded, shouldDeliver, }: {
+    bridgePathway: Pathway | null;
+    assetIn: Token | null;
+    recipient: Hex | null;
+    account: Hex | null;
+    assetLink: TokenBridgeInfo | null;
+    destinationDataParam: Hex | null;
+    amountToBridge: bigint;
+    feeDirectorStructEncoded: Hex | null;
+    shouldDeliver: boolean;
+}) => {
+    to: `0x${string}`;
+    value: bigint;
+    data: `0x${string}`;
+} | null;
+/**
+ * Calculates the asset out key from the bridge key path, asset in address, and unwrap
+ * @param bridgeKeyPath - the bridge key path
+ * @param assetInAddress - the asset in address
+ * @param unwrap - whether to unwrap
+ * @returns the asset out key
+ */
+export declare const assetOutKey: ({ bridgeKeyPath, assetInAddress, unwrap, }: {
+    bridgeKeyPath: string;
+    assetInAddress?: Hex | null;
+    unwrap: boolean;
+}) => string | null;
+/**
+ * Returns the asset out from the asset in address, assets out, bridge key path, and unwrap
+ * @param assetInAddress - the asset in address
+ * @param assetsOut - the assets out
+ * @param bridgeKeyPath - the bridge key path
+ * @param unwrap - whether to unwrap
+ * @returns the asset out
+ */
+export declare const assetOut: ({ assetInAddress, assetsOut, bridgeKeyPath, unwrap, }: {
+    assetInAddress: Hex | null;
+    assetsOut: Map<string, Token>;
+    bridgeKeyPath: string;
+    unwrap: boolean;
+}) => Token | null;