@gibs/bridge-sdk 1.6.36 → 1.7.2

package/dist/src/abis.d.ts

@@ -1,4 +1,4 @@
-/** the abi for the bridge */
+/** the abi for the input bridge */
 export declare const inputBridge: readonly [{
     readonly name: "minPerTx";
     readonly type: "function";
@@ -96,6 +96,7 @@ export declare const inputBridge: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi for the input bridge with extra input for the sender origin (tokensex) */
 export declare const inputBridgeExtraInput: readonly [{
     readonly name: "relayTokensAndCall";
     readonly type: "function";
@@ -136,6 +137,7 @@ export declare const inputBridgeExtraInput: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi for erc677 tokens */
 export declare const erc677: readonly [{
     readonly name: "transferAndCall";
     readonly type: "function";
@@ -149,6 +151,7 @@ export declare const erc677: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi for erc677 tokens bridge with extra input for the sender origin (tokensex) */
 export declare const erc677ExtraInput: readonly [{
     readonly name: "transferAndCall";
     readonly type: "function";
@@ -165,6 +168,7 @@ export declare const erc677ExtraInput: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi to read data from the output router */
 export declare const outputRouter: readonly [{
     readonly name: "onTokenBridged";
     readonly type: "function";
@@ -197,6 +201,7 @@ export declare const outputRouter: readonly [{
         readonly type: "address";
     }];
 }];
+/** the abi for the output bridge */
 export declare const outputBridge: readonly [{
     readonly name: "bridgeContract";
     readonly type: "function";
@@ -206,6 +211,7 @@ export declare const outputBridge: readonly [{
         readonly type: "address";
     }];
 }];
+/** the abi for the fee manager */
 export declare const feeManager: readonly [{
     readonly name: "HOME_TO_FOREIGN_FEE";
     readonly type: "function";
@@ -235,6 +241,7 @@ export declare const feeManager: readonly [{
         readonly type: "uint256";
     }];
 }];
+/** the abi for the native router */
 export declare const nativeRouter: readonly [{
     readonly name: "wrapAndRelayTokens";
     readonly type: "function";
@@ -257,6 +264,7 @@ export declare const nativeRouter: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi for the native router with extra input for the sender origin (tokensex) */
 export declare const nativeRouterExtraInput: readonly [{
     readonly name: "wrapAndRelayTokens";
     readonly type: "function";
@@ -285,6 +293,7 @@ export declare const nativeRouterExtraInput: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi for the univ2 router */
 export declare const univ2Router: readonly [{
     readonly name: "getAmountsOut";
     readonly type: "function";
@@ -300,6 +309,7 @@ export declare const univ2Router: readonly [{
         readonly type: "uint256[]";
     }];
 }];
+/** the abi for the fee delivery struct */
 export declare const feeDeliveryStruct: readonly [{
     readonly type: "tuple";
     readonly components: readonly [{
@@ -312,6 +322,7 @@ export declare const feeDeliveryStruct: readonly [{
         readonly type: "uint256";
     }];
 }];
+/** the abi for the relay tokens direct */
 export declare const relayTokensDirect: readonly [{
     readonly name: "safeExecuteSignaturesWithAutoGasLimit";
     readonly type: "function";
@@ -325,6 +336,7 @@ export declare const relayTokensDirect: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi for the home amb */
 export declare const homeAmb: readonly [{
     readonly name: "submitSignature";
     readonly type: "function";
@@ -338,6 +350,7 @@ export declare const homeAmb: readonly [{
     }];
     readonly outputs: readonly [];
 }];
+/** the abi for the univ2 pair */
 export declare const pair: readonly [{
     readonly name: "getReserves";
     readonly type: "function";

package/dist/src/abis.js

@@ -1,5 +1,5 @@
 import { parseAbi, parseAbiParameters } from 'viem';
-/** the abi for the bridge */
+/** the abi for the input bridge */
 export const inputBridge = parseAbi([
     'function minPerTx(address token) external view returns(uint256)',
     'function foreignTokenAddress(address token) external view returns(address)',
@@ -10,45 +10,58 @@ export const inputBridge = parseAbi([
     'function relayTokensAndCall(address token, address _receiver, uint256 _value, bytes memory _data) external',
     'function relayTokens(address token, address _receiver, uint256 _value) external',
 ]);
+/** the abi for the input bridge with extra input for the sender origin (tokensex) */
 export const inputBridgeExtraInput = parseAbi([
     'function relayTokensAndCall(address token, address _receiver, uint256 _value, bytes memory _data, address _senderOrigin) external',
     'function relayTokens(address token, address _receiver, uint256 _value, address _senderOrigin) external',
 ]);
+/** the abi for erc677 tokens */
 export const erc677 = parseAbi([
     'function transferAndCall(address, uint256, bytes calldata) external',
 ]);
+/** the abi for erc677 tokens bridge with extra input for the sender origin (tokensex) */
 export const erc677ExtraInput = parseAbi([
     'function transferAndCall(address, uint256, bytes calldata, address sender) external',
 ]);
+/** the abi to read data from the output router */
 export const outputRouter = parseAbi([
     'function onTokenBridged(address _token, uint256 _value, bytes memory _data) external payable',
     'function WETH() external view returns(address)',
     'function bridge() external view returns(address)',
 ]);
+/** the abi for the output bridge */
 export const outputBridge = parseAbi(['function bridgeContract() external view returns(address)']);
+/** the abi for the fee manager */
 export const feeManager = parseAbi([
     'function HOME_TO_FOREIGN_FEE() public view returns(bytes32)',
     'function FOREIGN_TO_HOME_FEE() public view returns(bytes32)',
     'function getFee(bytes32, address) public view returns(uint256)',
 ]);
+/** the abi for the native router */
 export const nativeRouter = parseAbi([
     'function wrapAndRelayTokens(address receiver) external payable',
     'function relayTokensAndCall(address receiver, bytes calldata data) external payable',
 ]);
+/** the abi for the native router with extra input for the sender origin (tokensex) */
 export const nativeRouterExtraInput = parseAbi([
     'function wrapAndRelayTokens(address receiver, address sender) external payable',
     'function relayTokensAndCall(address receiver, bytes calldata data, address sender) external payable',
 ]);
+/** the abi for the univ2 router */
 export const univ2Router = parseAbi([
     'function getAmountsOut(uint256 amountIn, address[] calldata path) external view returns(uint256[] memory)',
 ]);
+/** the abi for the fee delivery struct */
 export const feeDeliveryStruct = parseAbiParameters('(address, uint256, uint256, uint256)');
+/** the abi for the relay tokens direct */
 export const relayTokensDirect = parseAbi([
     'function safeExecuteSignaturesWithAutoGasLimit(bytes calldata data, bytes calldata signatures) external',
 ]);
+/** the abi for the home amb */
 export const homeAmb = parseAbi([
     'function submitSignature(bytes message, bytes signature) external',
 ]);
+/** the abi for the univ2 pair */
 export const pair = parseAbi([
     'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
 ]);

package/dist/src/chain-info.d.ts

@@ -15,12 +15,29 @@ export type TokenBridgeInfo = {
         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 declare const links: (({ chainId, target, address, client }: {
     chainId: number;
     target: Hex;
     address: Hex;
     client: PublicClient;
 }) => Promise<`0x${string}`[]>) & _.MemoizedFunction;
+/**
+ * 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 declare const tokenBridgeInfo: ({ bridgeKey, assetIn, isProd, fromChainClient, toChainClient, }: {
     bridgeKey: BridgeKey;
     assetIn: Token | null;
@@ -28,7 +45,20 @@ export declare const tokenBridgeInfo: ({ bridgeKey, assetIn, isProd, fromChainCl
     fromChainClient: PublicClient;
     toChainClient: PublicClient;
 }) => Promise<null | TokenBridgeInfo>;
+/** The result of reading the amount out from a router */
 export type FetchResult = bigint[] | Hex;
+/**
+ * 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 declare const fetchPriceCorrective: ({ bridgeKeyPartner, assetOut, measurementToken, fromChainClient, toChainClient, assetLink, amountIn, isProd, }: {
     bridgeKey: BridgeKey;
     bridgeKeyPartner: BridgeKey;
@@ -52,6 +82,14 @@ export declare const fetchPriceCorrective: ({ bridgeKeyPartner, assetOut, measur
         oneToken: bigint;
     }) => bigint;
 };
+/**
+ * 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 declare const minBridgeAmountIn: ({ assetIn, pathway, fromPublicClient, toPublicClient, }: {
     assetIn: Token;
     pathway: Pathway;
@@ -60,19 +98,33 @@ export declare const minBridgeAmountIn: ({ assetIn, pathway, fromPublicClient, t
 }) => Promise<bigint>;
 /** get the symbol of the native asset, unwrap it if it needs to be */
 export declare const nativeSymbol: (asset: {
-    address: Hex;
+    address: string;
     symbol: string;
     chainId: number;
 } | null, unwrap?: boolean) => string;
+/** 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 declare const chainMulticall: (client: PublicClient) => 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 declare const loadBridgeFees: ({ pathway, fromChainClient, toChainClient }: InputLoadFeeFor) => Promise<PathwayExtendableConfig>;

package/dist/src/chain-info.js

@@ -4,6 +4,14 @@ 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,
@@ -16,8 +24,17 @@ export const links = _.memoize(async ({ chainId, target, address, client }) => {
         ],
     });
 }, ({ 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);
+    const bridgePathway = pathway(bridgeKey, isProd, assetIn?.address);
     if (!assetIn || !bridgePathway) {
         console.log('missing asset in or bridge pathway');
         return null;
@@ -39,28 +56,23 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
         }),
     ]);
     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,
+            toHome: {
+                home: toBridged,
+                foreign: assetInAddress,
             },
         };
     }
     if (toNative !== zeroAddress) {
-        // if (notGas) console.log('toNative')
         return {
             originationChainId: toChain,
             assetInAddress: assetInAddress,
             assetOutAddress: toNative,
-            toHome: {
+            toForeign: {
                 home: toNative,
                 foreign: assetInAddress,
             },
@@ -68,7 +80,6 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
     }
     const [fromBridged, fromNative] = fromMappings;
     if (fromNative !== zeroAddress) {
-        // if (notGas) console.log('fromNative')
         return {
             originationChainId: toChain,
             assetInAddress: assetInAddress,
@@ -80,7 +91,6 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
         };
     }
     if (fromBridged !== zeroAddress) {
-        // if (notGas) console.log('fromBridged')
         return {
             originationChainId: fromChain,
             assetInAddress: assetInAddress,
@@ -112,7 +122,7 @@ export const tokenBridgeInfo = async ({ bridgeKey, assetIn, isProd, fromChainCli
     };
 };
 /**
- * check the prices that each router offers for the given paths
+ * 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
@@ -135,11 +145,19 @@ const readAmountOut = ({ amountIn, chain, paths, client, uniV2Router, }) => {
         }))),
     });
 };
-export const fetchPriceCorrective = ({ 
-// bridgeKey,
-// assetIn,
-// isProd,
-bridgeKeyPartner, assetOut, measurementToken, fromChainClient, toChainClient, assetLink, amountIn, isProd, }) => {
+/**
+ * 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
@@ -213,6 +231,14 @@ bridgeKeyPartner, assetOut, measurementToken, fromChainClient, toChainClient, as
         }
     };
 };
+/**
+ * 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({
@@ -226,6 +252,11 @@ export const minBridgeAmountIn = async ({ assetIn, pathway, fromPublicClient, to
 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)];
@@ -235,6 +266,13 @@ export const chainMulticall = (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)

package/dist/src/config.d.ts

@@ -10,42 +10,104 @@ export declare enum Chains {
     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;
+/** The provider of an omnibridge */
 export declare enum Provider {
     PULSECHAIN = "pulsechain",
     TOKENSEX = "tokensex"
 }
+/** 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;
-    defaultAssetIn: Token;
     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;
-export declare const pathway: (bridgeKey: BridgeKey | null, isProd: boolean) => Pathway | undefined;
-export declare const defaultAssetIn: ($bridgeKey: BridgeKey | null, isProd: boolean) => Token | undefined;
+/**
+ * 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;
-export declare const isUnwrappable: (asset: Pick<Token, "extensions"> | 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;