@1delta/bridge-configs 0.1.0

package/dist/configs/cowswap/swap/quote.js

@@ -0,0 +1,28 @@
+import { CurrencyHandler, NATIVE_PLACEHOLDER } from '@1delta/lib-utils';
+import { OrderBookApi, OrderQuoteSideKindSell } from '@cowprotocol/cow-sdk';
+import { zeroAddress } from 'viem';
+import { toSupportedChainId } from '../utils/toSupportedChainId';
+export async function getCowSwapReadonlyQuote(fromChainId, fromTokenAddress, toTokenAddress, amountIn) {
+    const chainId = toSupportedChainId(fromChainId);
+    if (!chainId)
+        return undefined;
+    const orderBookApi = new OrderBookApi({
+        chainId,
+    });
+    const sellToken = CurrencyHandler.addressToWrappedAddress(fromTokenAddress === NATIVE_PLACEHOLDER ? zeroAddress : fromTokenAddress, fromChainId);
+    const buyToken = CurrencyHandler.addressToWrappedAddress(toTokenAddress === NATIVE_PLACEHOLDER ? zeroAddress : toTokenAddress, fromChainId);
+    if (!buyToken || !sellToken)
+        return undefined;
+    const quote = await orderBookApi.getQuote({
+        kind: OrderQuoteSideKindSell.SELL,
+        sellAmountBeforeFee: amountIn,
+        sellToken,
+        buyToken,
+        receiver: zeroAddress,
+        from: zeroAddress,
+    });
+    return {
+        quote,
+        contractAddress: undefined,
+    };
+}

package/dist/configs/cowswap/swap/route.d.ts

@@ -0,0 +1,5 @@
+export declare function getCowSwapQuote(fromChainId: string, fromTokenAddress: string, fromTokenDecimals: number, toTokenAddress: string, toTokenDecimals: number, amountIn: string, fromAddress: string, toAddress: string, slippage: number): Promise<{
+    quote: import("@cowprotocol/cow-sdk").QuoteAndPost;
+    contractAddress: string;
+} | undefined>;
+//# sourceMappingURL=route.d.ts.map

package/dist/configs/cowswap/swap/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../../../src/configs/cowswap/swap/route.ts"],"names":[],"mappings":"AAiDA,wBAAsB,eAAe,CACnC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,iBAAiB,EAAE,MAAM,EACzB,cAAc,EAAE,MAAM,EACtB,eAAe,EAAE,MAAM,EACvB,QAAQ,EAAE,MAAM,EAChB,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM;;;eAwDjB"}

package/dist/configs/cowswap/swap/route.js

@@ -0,0 +1,61 @@
+import { getViemProvider } from '@1delta/lib-utils';
+import { COW_PROTOCOL_VAULT_RELAYER_ADDRESS, OrderKind, setGlobalAdapter, TradingSdk, } from '@cowprotocol/cow-sdk';
+import { ViemAdapter } from '@cowprotocol/sdk-viem-adapter';
+import { getWalletClient } from '../../../walletClient';
+import { toSupportedChainId } from '../utils/toSupportedChainId';
+async function setupSdk(chainId) {
+    const cowChainId = toSupportedChainId(chainId);
+    if (!cowChainId)
+        throw new Error(`ChainId ${chainId} not supported by CoW Swap.`);
+    const walletClient = getWalletClient();
+    if (!walletClient)
+        throw new Error('Wallet client not initialized');
+    const provider = getViemProvider({ chainId });
+    const adapter = new ViemAdapter({
+        provider,
+        walletClient,
+    });
+    setGlobalAdapter(adapter);
+    const options = undefined;
+    const tradingSdk = new TradingSdk({
+        chainId: cowChainId,
+        appCode: '1delta',
+    }, options, undefined);
+    return tradingSdk;
+}
+export async function getCowSwapQuote(fromChainId, fromTokenAddress, fromTokenDecimals, toTokenAddress, toTokenDecimals, amountIn, fromAddress, toAddress, slippage) {
+    const chainId = toSupportedChainId(fromChainId);
+    if (!chainId)
+        return undefined;
+    const tradingSdk = await setupSdk(fromChainId);
+    const contractAddress = COW_PROTOCOL_VAULT_RELAYER_ADDRESS[chainId];
+    if (!contractAddress)
+        return undefined;
+    const quote = await tradingSdk.getQuote({
+        chainId,
+        kind: OrderKind.SELL,
+        owner: fromAddress,
+        amount: amountIn,
+        sellToken: fromTokenAddress,
+        sellTokenDecimals: fromTokenDecimals,
+        buyToken: toTokenAddress,
+        buyTokenDecimals: toTokenDecimals,
+        slippageBps: slippage * 100,
+        receiver: toAddress,
+    }, {});
+    const originalPostSwapOrderFromQuote = quote.postSwapOrderFromQuote.bind(quote);
+    quote.postSwapOrderFromQuote = async (advancedSettings, signingStepManager) => {
+        const walletClient = getWalletClient();
+        const provider = getViemProvider({ chainId: fromChainId });
+        const adapter = new ViemAdapter({
+            provider,
+            walletClient,
+        });
+        setGlobalAdapter(adapter);
+        return await originalPostSwapOrderFromQuote(advancedSettings, signingStepManager);
+    };
+    return {
+        quote,
+        contractAddress,
+    };
+}

package/dist/configs/cowswap/track/index.d.ts

@@ -0,0 +1,6 @@
+import { OrderStatus } from '@cowprotocol/cow-sdk';
+export declare function getOrderStatus(fromChainId: string, orderId: string): Promise<{
+    status: OrderStatus | undefined;
+    hash: string | undefined;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/configs/cowswap/track/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/cowswap/track/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAIhE,wBAAsB,cAAc,CAClC,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,MAAM,EAAE,WAAW,GAAG,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC,CA2BxE"}

package/dist/configs/cowswap/track/index.js

@@ -0,0 +1,27 @@
+import { OrderBookApi, OrderStatus } from '@cowprotocol/cow-sdk';
+import { toSupportedChainId } from '../utils/toSupportedChainId';
+export async function getOrderStatus(fromChainId, orderId) {
+    const chainId = toSupportedChainId(fromChainId);
+    if (!chainId)
+        return { status: undefined, hash: undefined };
+    try {
+        const orderBookApi = new OrderBookApi({
+            chainId,
+        });
+        const order = await orderBookApi.getOrder(orderId);
+        if (order.status === OrderStatus.FULFILLED) {
+            const trades = await orderBookApi.getTrades({ orderUid: order.uid });
+            return {
+                status: order.status,
+                hash: trades[0].txHash ?? undefined,
+            };
+        }
+        return {
+            status: order.status,
+            hash: undefined,
+        };
+    }
+    catch (e) {
+        return { status: undefined, hash: undefined };
+    }
+}

package/dist/configs/cowswap/utils/getCowSwapSlippage.d.ts

@@ -0,0 +1,4 @@
+import { RawCurrency } from '@1delta/lib-utils';
+export declare const getCowSwapSlippage: (fromCurrency: RawCurrency, defaultSlippage: number) => number;
+export declare const getCowSwapSlippageForNative: (chainId: string) => number;
+//# sourceMappingURL=getCowSwapSlippage.d.ts.map

package/dist/configs/cowswap/utils/getCowSwapSlippage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getCowSwapSlippage.d.ts","sourceRoot":"","sources":["../../../../src/configs/cowswap/utils/getCowSwapSlippage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,WAAW,EAEZ,MAAM,mBAAmB,CAAA;AAE1B,eAAO,MAAM,kBAAkB,GAC7B,cAAc,WAAW,EACzB,iBAAiB,MAAM,KACtB,MAIF,CAAA;AAWD,eAAO,MAAM,2BAA2B,GAAI,SAAS,MAAM,KAAG,MAI7D,CAAA"}

package/dist/configs/cowswap/utils/getCowSwapSlippage.js

@@ -0,0 +1,16 @@
+import { CurrencyHandler, SupportedChainId, } from '@1delta/lib-utils';
+export const getCowSwapSlippage = (fromCurrency, defaultSlippage) => {
+    const cowSlippage = tryGetCowSwapSlippageForNative(fromCurrency) ?? 0;
+    return defaultSlippage > cowSlippage ? defaultSlippage : cowSlippage;
+};
+const tryGetCowSwapSlippageForNative = (fromCurrency) => {
+    if (CurrencyHandler.isNative(fromCurrency)) {
+        return getCowSwapSlippageForNative(fromCurrency.chainId);
+    }
+    return null;
+};
+export const getCowSwapSlippageForNative = (chainId) => {
+    if (chainId === SupportedChainId.ETHEREUM_MAINNET)
+        return 2; // 2%
+    return 0.5; // 0.5%
+};

package/dist/configs/cowswap/utils/toSupportedChainId.d.ts

@@ -0,0 +1,3 @@
+import { SupportedChainId } from '@cowprotocol/cow-sdk';
+export declare function toSupportedChainId(chainId: string): SupportedChainId | undefined;
+//# sourceMappingURL=toSupportedChainId.d.ts.map

package/dist/configs/cowswap/utils/toSupportedChainId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toSupportedChainId.d.ts","sourceRoot":"","sources":["../../../../src/configs/cowswap/utils/toSupportedChainId.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAEvD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,MAAM,GACd,gBAAgB,GAAG,SAAS,CAY9B"}

package/dist/configs/cowswap/utils/toSupportedChainId.js

@@ -0,0 +1,11 @@
+import { SupportedChainId } from '@cowprotocol/cow-sdk';
+export function toSupportedChainId(chainId) {
+    const numericChainId = parseInt(chainId, 10);
+    if (isNaN(numericChainId)) {
+        return undefined;
+    }
+    if (SupportedChainId[numericChainId]) {
+        return numericChainId;
+    }
+    return undefined;
+}

package/dist/configs/crosscurve/config.d.ts

@@ -0,0 +1,4 @@
+import { CrossChainConfig } from '@1delta/bridge-core';
+export declare const crosscurveConfig: CrossChainConfig;
+export default crosscurveConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/configs/crosscurve/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/configs/crosscurve/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,gBAAgB,EAEjB,MAAM,qBAAqB,CAAA;AA2C5B,eAAO,MAAM,gBAAgB,EAAE,gBAgK9B,CAAA;AAED,eAAe,gBAAgB,CAAA"}

package/dist/configs/crosscurve/config.js

@@ -0,0 +1,185 @@
+import { buildTransactionData, CrossChainBusinessException, } from '@1delta/bridge-core';
+import { SupportedChainId } from '@1delta/lib-utils';
+import axios from 'axios';
+import { Bridge } from '../../types';
+import { NATIVE_PLACEHOLDER } from '../stargate/common';
+import { bridgeIcon } from '../utils';
+const CROSSCURVE_API_HOST = 'https://api.crosscurve.fi';
+const nativeCoinAddress = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+const tokenAddressMapping = {
+    '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE': '0x0000000000000000000000000000000000000000',
+};
+const MIN_AMOUNT = {
+    [nativeCoinAddress]: {
+        [SupportedChainId.BASE]: 10n ** 15n,
+        [SupportedChainId.BLAST]: 10n ** 15n,
+        [SupportedChainId.ARBITRUM_ONE]: 10n ** 15n,
+        [SupportedChainId.OP_MAINNET]: 10n ** 15n,
+        [SupportedChainId.ETHEREUM_MAINNET]: 10n ** 15n,
+    },
+};
+const ERROR_CODES = {
+    ERROR: { code: 'ERROR', message: 'Unknown error occurred' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'Operation not supported' },
+    NOT_FOUND: { code: 'NOT_FOUND', message: 'transaction not found' },
+};
+const NAME = Bridge.CROSSCURVE;
+var Status;
+(function (Status) {
+    Status["SUCCESS"] = "completed";
+    Status["FAILED"] = "failed";
+    Status["IN_PROGRESS"] = "in progress";
+    Status["REVERTED"] = "reverted";
+    Status["CANCELED"] = "canceled";
+})(Status || (Status = {}));
+export const crosscurveConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${CROSSCURVE_API_HOST}/routing/scan`,
+            method: 'post',
+            before: async (params) => {
+                if (BigInt(params.fromAmount) <
+                    MIN_AMOUNT[params.fromTokenAddress]?.[params.fromChainId]) {
+                    throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+                }
+            },
+            requestMapping: {
+                params: {
+                    format: (params) => {
+                        return {
+                            chainIdOut: Number(params.toChainId),
+                            tokenOut: params.toTokenAddress == nativeCoinAddress
+                                ? tokenAddressMapping[nativeCoinAddress]
+                                : params.toTokenAddress,
+                            chainIdIn: Number(params.fromChainId),
+                            amountIn: params.fromAmount,
+                            tokenIn: params.fromTokenAddress == nativeCoinAddress
+                                ? tokenAddressMapping[nativeCoinAddress]
+                                : params.fromTokenAddress,
+                        };
+                    },
+                },
+                slippage: 'slippage',
+            },
+            requestAfter: async (res, headers, params) => {
+                if (!res || !res[0]) {
+                    throw new CrossChainBusinessException(ERROR_CODES.ERROR);
+                }
+                // Call buildTransactionData to get the transaction data since the response from the route is not complete
+                const route = res[0];
+                const tx = await buildTransactionData(NAME, params, route);
+                route.data = tx?.data;
+                route.value = tx?.value;
+                route.to = tx?.to;
+                return route;
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'to',
+                toAmount: 'amountOut',
+                fee: {
+                    destinationGasFee: {
+                        format: (route, { crossChainParamsData }) => {
+                            const isNatveIn = crossChainParamsData.fromTokenAddress === NATIVE_PLACEHOLDER;
+                            return isNatveIn ? route.value - route.amountIn : route.value;
+                        },
+                    },
+                },
+                estimatedDuration: '300', // route does not provide Estimation Duration
+                interfaceParamData: {
+                    format: (route) => {
+                        return route;
+                    },
+                },
+                transactionData: {
+                    data: 'data',
+                    value: 'value',
+                    to: 'to',
+                },
+            },
+        },
+        buildTransactionData: {
+            url: `${CROSSCURVE_API_HOST}/tx/create`,
+            method: 'post',
+            before: async (params, interfaceParamData) => {
+                const estimate = await axios.post(`${CROSSCURVE_API_HOST}/estimate`, interfaceParamData);
+                return estimate?.data;
+            },
+            requestMapping: {
+                from: 'fromAddress',
+                recipient: 'toAddress',
+                routing: {
+                    format: (params, { interfaceParamData }) => {
+                        return interfaceParamData;
+                    },
+                },
+                estimate: {
+                    format: (params, { beforeResult }) => {
+                        return beforeResult;
+                    },
+                },
+                buildCalldata: true,
+            },
+            requestAfter: (res) => {
+                if (!res) {
+                    throw new CrossChainBusinessException(ERROR_CODES.ERROR);
+                }
+                return res;
+            },
+            responseMapping: {
+                data: 'data',
+                value: 'value',
+                to: 'to',
+            },
+        },
+        status: {
+            url: `${CROSSCURVE_API_HOST}/search`,
+            method: 'get',
+            requestMapping: {
+                search: 'fromHash',
+            },
+            requestAfter: (res) => {
+                if (!res?.result || !res?.result[0]) {
+                    throw new CrossChainBusinessException(ERROR_CODES.ERROR);
+                }
+                return res?.result[0];
+            },
+            responseMapping: {
+                toHash: 'destination.transactionHash',
+                statusInfo: {
+                    format: (result) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: result.status,
+                        };
+                        switch (result.status) {
+                            case Status.SUCCESS:
+                                data.status = 'DONE';
+                                break;
+                            case Status.FAILED:
+                                data.status = 'FAILED';
+                                data.message = result.failureReason || 'Transaction failed';
+                                break;
+                            case Status.IN_PROGRESS:
+                                data.status = 'PENDING';
+                                break;
+                            case Status.REVERTED:
+                                data.status = 'TRANSFER_REFUNDED';
+                                break;
+                            case Status.CANCELED:
+                                data.status = 'FAILED';
+                                break;
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+};
+export default crosscurveConfig;

package/dist/configs/gas-zip/chains/fetch.d.ts

@@ -0,0 +1,10 @@
+import { GasZipChain } from './types';
+/**
+ * Fetches chain data from the Gas.zip API.
+ *
+ * @returns A Promise that resolves to a Map where the key is the chain ID (number)
+ *          and the value is the complete Chain object.
+ * @throws Will throw an error if the network request fails.
+ */
+export declare function getGasZipChains(): Promise<Map<string, GasZipChain>>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/configs/gas-zip/chains/fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../../src/configs/gas-zip/chains/fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAA2B,MAAM,SAAS,CAAA;AAM9D;;;;;;GAMG;AACH,wBAAsB,eAAe,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAuBzE"}

package/dist/configs/gas-zip/chains/fetch.js

@@ -0,0 +1,29 @@
+const chainsCache = new Map();
+const API_URL = 'https://backend.gas.zip/v2/chains';
+/**
+ * Fetches chain data from the Gas.zip API.
+ *
+ * @returns A Promise that resolves to a Map where the key is the chain ID (number)
+ *          and the value is the complete Chain object.
+ * @throws Will throw an error if the network request fails.
+ */
+export async function getGasZipChains() {
+    if (chainsCache.size > 0) {
+        return chainsCache;
+    }
+    try {
+        const response = await fetch(API_URL);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch chains: ${response.statusText}`);
+        }
+        const data = await response.json();
+        for (const chain of data.chains) {
+            chainsCache.set(chain.chain.toString(), chain);
+        }
+        return chainsCache;
+    }
+    catch (error) {
+        console.error('An error occurred while fetching GasZip chain data:', error);
+        throw error;
+    }
+}

package/dist/configs/gas-zip/chains/types.d.ts

@@ -0,0 +1,25 @@
+export interface GasZipChain {
+    bal: string;
+    chain: number;
+    decimals: number;
+    explorer: string;
+    gas: string;
+    gwei: string;
+    inbound: boolean;
+    mainnet: boolean;
+    maxInbound: number;
+    maxInboundNative: string | number;
+    maxOutbound: number;
+    maxOutboundNative: string | number;
+    minOutbound: number;
+    minOutboundNative: string | number;
+    name: string;
+    price: number;
+    rpcs: string[];
+    short: number;
+    symbol: string;
+}
+export interface GasZipChainsApiResponse {
+    chains: GasZipChain[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/configs/gas-zip/chains/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/configs/gas-zip/chains/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,OAAO,CAAA;IAChB,UAAU,EAAE,MAAM,CAAA;IAElB,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAAA;IACjC,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAAA;IAClC,WAAW,EAAE,MAAM,CAAA;IACnB,iBAAiB,EAAE,MAAM,GAAG,MAAM,CAAA;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,WAAW,EAAE,CAAA;CACtB"}

package/dist/configs/gas-zip/chains/types.js

@@ -0,0 +1 @@
+export {};

package/dist/configs/gas-zip/config.d.ts

@@ -0,0 +1,4 @@
+import { CrossChainConfig } from '@1delta/bridge-core';
+export declare const gasZipConfig: CrossChainConfig;
+export default gasZipConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/configs/gas-zip/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/configs/gas-zip/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAEjB,MAAM,qBAAqB,CAAA;AA6B5B,eAAO,MAAM,YAAY,EAAE,gBAkG1B,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/configs/gas-zip/config.js

@@ -0,0 +1,121 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+import { getGasZipChains } from './chains/fetch';
+const serverHost = 'https://backend.gas.zip/v2';
+const serverHostStatus = 'https://backend.gas.zip/v2/search';
+const NAME = Bridge.GASZIP;
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+    DEPOSIT_NOT_FOUND: {
+        code: 'DEPOSIT_NOT_FOUND',
+        message: 'deposit not found',
+    },
+};
+var Status;
+(function (Status) {
+    Status["CONFIRMED"] = "CONFIRMED";
+    Status["PENDING"] = "PENDING";
+    Status["NOT_FOUND"] = "NOT_FOUND";
+    Status["CANCELLED"] = "CANCELLED";
+})(Status || (Status = {}));
+const native = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+export const gasZipConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/quotes/:fromChainId/:amount/:chains`,
+            method: 'get',
+            headers: {},
+            pathParams: {
+                fromChainId: 'fromChainId',
+                chains: 'toChainId',
+                amount: 'fromAmount',
+            },
+            requestMapping: {
+                from: 'fromAddress',
+                to: 'toAddress',
+                slippage: 'slippage',
+            },
+            before: async (params) => {
+                if (params.toTokenAddress !== native ||
+                    params.fromTokenAddress !== native)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                const chains = await getGasZipChains();
+                const gasZipSrcChainId = chains.get(params.fromChainId)?.short;
+                const gasZipDestChainId = chains.get(params.toChainId)?.short;
+                if (!gasZipSrcChainId || !gasZipDestChainId)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                params.gasZipDestChainId = gasZipDestChainId;
+            },
+            requestAfter: (data, _, crossChainParams) => {
+                if (!data || !crossChainParams.gasZipDestChainId)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                return {
+                    ...data,
+                    gasZipDestChainId: crossChainParams.gasZipDestChainId,
+                };
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'contractDepositTxn.to',
+                toAmount: 'quotes[0].expected',
+                fee: {},
+                estimatedDuration: 'quotes[0].speed',
+                transactionData: {
+                    data: 'contractDepositTxn.data',
+                    value: 'contractDepositTxn.value',
+                    to: 'contractDepositTxn.to',
+                },
+                interfaceParamData: {
+                    contractAddress: 'contractDepositTxn.to',
+                    gasZipDestChainId: 'gasZipDestChainId',
+                },
+            },
+        },
+        status: {
+            url: `${serverHostStatus}/:txHash`,
+            method: 'get',
+            pathParams: {
+                txHash: 'fromHash',
+            },
+            requestMapping: {},
+            requestAfter: (res, _, crossChainParamsData) => {
+                return res;
+            },
+            responseMapping: {
+                toHash: 'txs[0].hash',
+                statusInfo: {
+                    format: (res) => {
+                        const status = res.txs?.[0]?.status;
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: status,
+                        };
+                        if (status === Status.CONFIRMED) {
+                            data.status = 'DONE';
+                        }
+                        else if (status === Status.PENDING) {
+                            data.status = 'PENDING';
+                        }
+                        else if (status === Status.NOT_FOUND) {
+                            data.status = 'NOT_FOUND';
+                        }
+                        else if (status === Status.CANCELLED) {
+                            data.status = 'FAILED';
+                            data.message = `failed: ${res.msg}`;
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+export default gasZipConfig;

package/dist/configs/index.d.ts

@@ -0,0 +1,2 @@
+export declare const getAllBridgeConfigs: () => import("../../../bridge-core/src/types").CrossChainConfig[];
+//# sourceMappingURL=index.d.ts.map

package/dist/configs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/configs/index.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,mBAAmB,mEAE/B,CAAA"}

package/dist/configs/index.js

@@ -0,0 +1,41 @@
+import { acrossConfig } from './across/config';
+import { axelarConfig } from './axelar/config';
+import { butterConfig } from './butter/config';
+import { cowswapConfig } from './cowswap/config';
+import { crosscurveConfig } from './crosscurve/config';
+import { gasZipConfig } from './gas-zip/config';
+import { layerswapConfig } from './layerswap/config';
+import { lifiConfig } from './lifi/config';
+import { mayanConfig } from './mayan/config';
+import { orbiterConfig } from './orbiter/config';
+import { routerConfig } from './router/config';
+import { squidv1Config } from './squid-v1/config';
+import { squidv2Config } from './squid-v2/config';
+import { stargateBusConfig } from './stargate/configs/bus/config';
+import { stargateTaxiConfig } from './stargate/configs/taxi/config';
+import { symbiosisConfig } from './symbiosis/config';
+import { xyConfig } from './xy/config';
+import { zenlinkConfig } from './zenlink/config';
+const configs = {
+    [acrossConfig.name]: acrossConfig,
+    [butterConfig.name]: butterConfig,
+    [squidv1Config.name]: squidv1Config,
+    [squidv2Config.name]: squidv2Config,
+    [orbiterConfig.name]: orbiterConfig,
+    [routerConfig.name]: routerConfig,
+    [mayanConfig.name]: mayanConfig,
+    [xyConfig.name]: xyConfig,
+    [layerswapConfig.name]: layerswapConfig,
+    [crosscurveConfig.name]: crosscurveConfig,
+    [lifiConfig.name]: lifiConfig,
+    [stargateBusConfig.name]: stargateBusConfig,
+    [stargateTaxiConfig.name]: stargateTaxiConfig,
+    [symbiosisConfig.name]: symbiosisConfig,
+    [gasZipConfig.name]: gasZipConfig,
+    [axelarConfig.name]: axelarConfig,
+    [cowswapConfig.name]: cowswapConfig,
+    [zenlinkConfig.name]: zenlinkConfig,
+};
+export const getAllBridgeConfigs = () => {
+    return Object.values(configs);
+};