@1delta/bridge-configs 0.1.0

package/dist/configs/axelar/errors.d.ts

@@ -0,0 +1,15 @@
+export declare const ERROR_CODES: {
+    ERROR: {
+        code: string;
+        message: string;
+    };
+    NOT_SUPPORT: {
+        code: string;
+        message: string;
+    };
+    DEPOSIT_NOT_FOUND: {
+        code: string;
+        message: string;
+    };
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/configs/axelar/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/configs/axelar/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAOvB,CAAA"}

package/dist/configs/axelar/errors.js

@@ -0,0 +1,8 @@
+export const ERROR_CODES = {
+    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',
+    },
+};

package/dist/configs/axelar/gasEstimation/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Fetches Axelar gas estimation.
+ * Docs: https://docs.axelarscan.io/gmp#estimateGasFee
+ * @returns {Promise<object|undefined>} A promise that resolves to the configuration object, or undefined on error.
+ */
+export declare function fetchAxelarGasEstimation(params: AxelarGasEstimationParams): Promise<AxelarGasEstimation | undefined>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/axelar/gasEstimation/index.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,mBAAmB,GAAG,SAAS,CAAC,CAoC1C"}

package/dist/configs/axelar/gasEstimation/index.js

@@ -0,0 +1,38 @@
+const AXELAR_GAS_API = 'https://api.axelarscan.io/gmp/estimateGasFee';
+/**
+ * Fetches Axelar gas estimation.
+ * Docs: https://docs.axelarscan.io/gmp#estimateGasFee
+ * @returns {Promise<object|undefined>} A promise that resolves to the configuration object, or undefined on error.
+ */
+export async function fetchAxelarGasEstimation(params) {
+    try {
+        const requestData = {
+            sourceChain: params.sourceChain,
+            destinationChain: params.destinationChain,
+            gasMultiplier: params.gasMultiplier,
+            gasLimit: params.gasLimit.toString(),
+            sourceAddress: params.sourceAddress,
+            destinationContractAddress: params.destinationContractAddress,
+            amountInUnits: params.amountInUnits.toString(),
+            symbol: params.symbol,
+            sourceTokenAddress: '0x0000000000000000000000000000000000000000',
+            showDetailedFees: 'true',
+        };
+        const response = await fetch(AXELAR_GAS_API, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(requestData),
+        });
+        if (!response.ok) {
+            throw new Error(`fetchAxelarGasEstimation: Network response was not ok. Status: ${response.status}`);
+        }
+        const data = (await response.json());
+        return data;
+    }
+    catch (error) {
+        console.error('Failed to fetch Axelar gas estimation:', error);
+        return undefined;
+    }
+}

package/dist/configs/axelar/gasEstimation/types.d.ts

@@ -0,0 +1,23 @@
+interface AxelarGasEstimation {
+    totalFee: bigint;
+    isExpressSupported: boolean;
+    baseFee: bigint;
+    expressFee: bigint;
+    executionFee: bigint;
+    executionFeeWithMultiplier: bigint;
+    gasLimit: bigint;
+    gasLimitWithL1Fee: bigint;
+    gasMultiplier: number;
+    minGasPrice: bigint;
+}
+interface AxelarGasEstimationParams {
+    sourceChain: string;
+    destinationChain: string;
+    gasMultiplier: number | 'auto';
+    gasLimit: bigint;
+    symbol: string;
+    amountInUnits: bigint;
+    sourceAddress: string;
+    destinationContractAddress: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/configs/axelar/gasEstimation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/configs/axelar/gasEstimation/types.ts"],"names":[],"mappings":"AAAA,UAAU,mBAAmB;IAC3B,QAAQ,EAAE,MAAM,CAAA;IAChB,kBAAkB,EAAE,OAAO,CAAA;IAC3B,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,0BAA0B,EAAE,MAAM,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,iBAAiB,EAAE,MAAM,CAAA;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,UAAU,yBAAyB;IACjC,WAAW,EAAE,MAAM,CAAA;IACnB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,GAAG,MAAM,CAAA;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,0BAA0B,EAAE,MAAM,CAAA;CACnC"}

package/dist/configs/axelar/gasEstimation/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/configs/axelar/route/fetchAxelarRoute.d.ts

@@ -0,0 +1,3 @@
+import { AxelarRouteData } from '../calldata/types';
+export declare function fetchAxelarRoute(fromChainId: string, fromTokenAddress: string, toChainId: string, toTokenAddress: string, amountIn: bigint, gasLimit?: bigint): Promise<AxelarRouteData>;
+//# sourceMappingURL=fetchAxelarRoute.d.ts.map

package/dist/configs/axelar/route/fetchAxelarRoute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchAxelarRoute.d.ts","sourceRoot":"","sources":["../../../../src/configs/axelar/route/fetchAxelarRoute.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAiBnD,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,SAAS,EAAE,MAAM,EACjB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,EAChB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,eAAe,CAAC,CAoD1B"}

package/dist/configs/axelar/route/fetchAxelarRoute.js

@@ -0,0 +1,50 @@
+import { CrossChainBusinessException } from '@1delta/bridge-core';
+import { getCachedAxelarConfig } from '../data/axelarConfig';
+import { getSquidRouter } from '../data/squidChains';
+import { ERROR_CODES } from '../errors';
+import { fetchAxelarGasEstimation } from '../gasEstimation';
+import { getAxelarTokenIdentifier } from './tokenIdentifier';
+function isValidPath(fromAxlToken, toAxlToken) {
+    if (fromAxlToken.axlChainName === toAxlToken.axlChainName)
+        return false;
+    if (fromAxlToken.axlTokenSymbol !== toAxlToken.axlTokenSymbol)
+        return false;
+    return true;
+}
+export async function fetchAxelarRoute(fromChainId, fromTokenAddress, toChainId, toTokenAddress, amountIn, gasLimit) {
+    const promiseArray = [
+        getSquidRouter(fromChainId),
+        getSquidRouter(toChainId),
+        getCachedAxelarConfig(),
+    ];
+    const [sourceAddress, destinationContractAddress, axelarConfig] = await Promise.all(promiseArray);
+    if (!sourceAddress || !destinationContractAddress) {
+        throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+    }
+    const fromAxlToken = getAxelarTokenIdentifier(axelarConfig, fromChainId, fromTokenAddress);
+    const toAxlToken = getAxelarTokenIdentifier(axelarConfig, toChainId, toTokenAddress);
+    const isValidPair = isValidPath(fromAxlToken, toAxlToken);
+    if (!isValidPair)
+        throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+    const fees = await fetchAxelarGasEstimation({
+        sourceChain: fromAxlToken.axlChainName,
+        destinationChain: toAxlToken.axlChainName,
+        symbol: fromAxlToken.axlTokenSymbol,
+        amountInUnits: amountIn,
+        sourceAddress,
+        destinationContractAddress,
+        gasLimit: gasLimit ?? 200000n,
+        gasMultiplier: 'auto',
+    });
+    if (!fees)
+        throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+    return {
+        contractAddress: sourceAddress,
+        isExpressSupported: fees.isExpressSupported,
+        amount: amountIn,
+        totalFeeInNative: fees.totalFee,
+        bridgeTokenSymbol: fromAxlToken.axlTokenSymbol,
+        destinationChain: toAxlToken.axlChainName,
+        destinationAddress: destinationContractAddress,
+    };
+}

package/dist/configs/axelar/route/index.d.ts

@@ -0,0 +1,3 @@
+export * from './fetchAxelarRoute';
+export * from './tokenIdentifier';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/axelar/route/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA"}

package/dist/configs/axelar/route/index.js

@@ -0,0 +1,2 @@
+export * from './fetchAxelarRoute';
+export * from './tokenIdentifier';

package/dist/configs/axelar/route/tokenIdentifier.d.ts

@@ -0,0 +1,5 @@
+import { AxelarConfig } from '../data/axelarConfig/types';
+import { AxelarTokenIdentifier } from './types';
+export declare function getAxelarTokenIdentifier(axelarConfig: AxelarConfig, chainId: string, tokenAddress: string): AxelarTokenIdentifier;
+export declare function getAxelarTokenAddress(axelarConfig: AxelarConfig, chainId: string, axelarSymbol: string): string;
+//# sourceMappingURL=tokenIdentifier.d.ts.map

package/dist/configs/axelar/route/tokenIdentifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokenIdentifier.d.ts","sourceRoot":"","sources":["../../../../src/configs/axelar/route/tokenIdentifier.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAA;AACzD,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAE/C,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GACnB,qBAAqB,CA6BvB;AAED,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,MAAM,EACf,YAAY,EAAE,MAAM,GACnB,MAAM,CAoBR"}

package/dist/configs/axelar/route/tokenIdentifier.js

@@ -0,0 +1,32 @@
+export function getAxelarTokenIdentifier(axelarConfig, chainId, tokenAddress) {
+    const { chains, assets } = axelarConfig;
+    const chain = Object.values(chains).find((chain) => chain.externalChainId === chainId);
+    if (!chain)
+        throw new Error('Unsupported chain');
+    const axlChainName = chain.id.toLowerCase();
+    const assetId = Object.entries(chain.assets).find(([_, _tokenAddress]) => _tokenAddress.toLowerCase() === tokenAddress.toLowerCase())?.[0];
+    if (!assetId)
+        throw new Error('Unsupported asset');
+    const assetObj = assets[assetId];
+    if (assetObj.type !== 'gateway')
+        throw new Error('Only gateway assets supported');
+    const axlTokenSymbol = assetObj.chains[axlChainName].symbol;
+    return {
+        axlChainName,
+        axlTokenSymbol,
+    };
+}
+export function getAxelarTokenAddress(axelarConfig, chainId, axelarSymbol) {
+    const { chains, assets } = axelarConfig;
+    const chain = Object.values(chains).find((chain) => chain.externalChainId === chainId);
+    if (!chain)
+        throw new Error('Unsupported chain');
+    const axlChainName = chain.id.toLowerCase();
+    const assetObj = assets[axelarSymbol];
+    if (!assetObj)
+        throw new Error('Unsupported asset');
+    if (assetObj.type !== 'gateway')
+        throw new Error('Only gateway assets supported');
+    const axlTokenSymbol = assetObj.chains[axlChainName].tokenAddress;
+    return axlTokenSymbol;
+}

package/dist/configs/axelar/route/types.d.ts

@@ -0,0 +1,5 @@
+export interface AxelarTokenIdentifier {
+    axlChainName: string;
+    axlTokenSymbol: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/configs/axelar/route/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/configs/axelar/route/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,MAAM,CAAA;CACvB"}

package/dist/configs/axelar/route/types.js

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

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

@@ -0,0 +1,9 @@
+import { CrossChainConfig } from '@1delta/bridge-core';
+/**
+ * curl -X 'GET' \
+  'https://bs-router-v3.chainservice.io/routeAndSwap?fromChainId=56&toChainId=22776&amount=1&tokenInAddress=0x55d398326f99059fF775485246999027B3197955&tokenOutAddress=0x0000000000000000000000000000000000000000&type=exactIn&slippage=100&entrance=Butter%2B&from=0x2D4C407BBe49438ED859fe965b140dcF1aaB71a9&receiver=0x2D4C407BBe49438ED859fe965b140dcF1aaB71a9' \
+  -H 'accept: application/json'
+ */
+export declare const butterConfig: CrossChainConfig;
+export default butterConfig;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/configs/butter/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAGjB,MAAM,qBAAqB,CAAA;AAoE5B;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,gBAyJ1B,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/configs/butter/config.js

@@ -0,0 +1,207 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import axios from 'axios';
+import { ceil, flatten } from 'lodash';
+import { parseUnits } from 'viem';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+const serverHost = 'https://bs-router-v3.chainservice.io';
+const tokenServerHost = 'https://bs-tokens-api.chainservice.io';
+const bridgeServerHost = 'https://bs-app-api.chainservice.io';
+const NAME = Bridge.BUTTER;
+const dodoNativeAddress = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+const butterNativeAddress = '0x0000000000000000000000000000000000000000';
+const MIN_SLIPPAGE = 1.5;
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+    NOT_ROUTE: { code: 'NOT_ROUTE', message: 'NOT ROUTE' },
+};
+async function getTokenList(network, page, size) {
+    const res = await axios.get(`${tokenServerHost}/api/queryTokenList`, {
+        params: { network, page, size },
+        headers: { 'Content-Type': 'application/json' },
+    });
+    if (res.status !== 200 || res.data.code !== 200) {
+        throw new CrossChainBusinessException(errorCodes.ERROR);
+    }
+    return res.data.data;
+}
+async function getTokenListAll(network) {
+    const size = 1000;
+    const tokens = [];
+    const tokenlistResult = await getTokenList(network, 1, size);
+    const tasks = [];
+    const count = ceil(tokenlistResult.count / size);
+    for (let i = 2; i <= count; i++) {
+        tasks.push(getTokenList(network, i, size));
+    }
+    const tokenlistResults = await Promise.all(tasks);
+    for (const tokenlists of [tokenlistResult, ...tokenlistResults]) {
+        for (const item of tokenlists.results) {
+            tokens.push({
+                chainId: item.chainId,
+                address: item.address.toLowerCase() ===
+                    '0x0000000000000000000000000000000000000000'
+                    ? dodoNativeAddress
+                    : item.address,
+                name: item.name,
+                symbol: item.symbol,
+                decimals: item.decimals,
+                logoImg: item.image,
+            });
+        }
+    }
+    return tokens;
+}
+/**
+ * curl -X 'GET' \
+  'https://bs-router-v3.chainservice.io/routeAndSwap?fromChainId=56&toChainId=22776&amount=1&tokenInAddress=0x55d398326f99059fF775485246999027B3197955&tokenOutAddress=0x0000000000000000000000000000000000000000&type=exactIn&slippage=100&entrance=Butter%2B&from=0x2D4C407BBe49438ED859fe965b140dcF1aaB71a9&receiver=0x2D4C407BBe49438ED859fe965b140dcF1aaB71a9' \
+  -H 'accept: application/json'
+ */
+export const butterConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/route`,
+            method: 'get',
+            requestAfter: (res) => {
+                if (res.errno !== 0)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                if (res.data.length < 1)
+                    throw new CrossChainBusinessException(errorCodes.NOT_ROUTE);
+                return res.data[0];
+            },
+            requestMapping: {
+                fromChainId: 'fromChainId',
+                tokenInAddress: {
+                    format: (route) => {
+                        return route.fromTokenAddress === dodoNativeAddress
+                            ? butterNativeAddress
+                            : route.fromTokenAddress;
+                    },
+                },
+                amount: {
+                    format: (params) => (BigInt(params.fromAmount) /
+                        10n ** BigInt(params.fromTokenDecimals)).toString(),
+                },
+                toChainId: 'toChainId',
+                tokenOutAddress: {
+                    format: (route) => {
+                        return route.toTokenAddress === dodoNativeAddress
+                            ? butterNativeAddress
+                            : route.toTokenAddress;
+                    },
+                },
+                type: 'exactIn', //exactIn, exactOut
+                slippage: {
+                    format: (params) => params.slippage < MIN_SLIPPAGE
+                        ? MIN_SLIPPAGE * 1000
+                        : params.slippage * 1000,
+                },
+                entrance: 'Butter+', //eg: Butter+
+            },
+            responseMapping: {
+                name: NAME,
+                // Call the swap API to exchange and cross assets and retrieve the deposit contract information
+                depositContract: 'contract',
+                toAmount: {
+                    format: (route, { crossChainParamsData }) => parseUnits(route.dstChain.totalAmountOut, crossChainParamsData.toTokenDecimals),
+                },
+                // fees are already included in the quote
+                fee: {},
+                estimatedDuration: 'timeEstimated',
+                interfaceParamData: {
+                    hash: 'hash',
+                },
+            },
+        },
+        buildTransactionData: {
+            requestMapping: {
+                hash: {
+                    format: (_, { interfaceParamData }) => interfaceParamData.hash,
+                }, // interfaceParamData.hash
+                slippage: { format: (params) => params.slippage * 10000 },
+                from: 'fromAddress', // 源链上的发送者地址
+                receiver: 'toAddress', // 目标链上的接收者地址
+            },
+            url: `${serverHost}/swap`,
+            method: 'get',
+            requestAfter: (res) => {
+                if (res.errno !== 0 || res.data.length < 1)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                return res.data[0];
+            },
+            responseMapping: {
+                data: 'data',
+                value: 'value',
+                to: 'to',
+            },
+        },
+        status: {
+            url: `${bridgeServerHost}/api/queryBridgeInfoBySourceHash`,
+            method: 'get',
+            requestMapping: {
+                hash: 'fromHash',
+            },
+            responseMapping: {
+                toHash: 'info.toHash',
+                statusInfo: {
+                    format: (resResult) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: resResult,
+                        };
+                        if (resResult.info.state === 1) {
+                            data.status = 'DONE';
+                        }
+                        else if (resResult.info.state === 0) {
+                            data.status = 'PENDING';
+                        }
+                        return data;
+                    },
+                },
+            }, // 0: crossing, 1: completed
+            requestAfter: (res) => {
+                // sometimes butter returns empty info and just a message, if it is success, return pending
+                if (!res?.data?.info && res?.message === 'success')
+                    return { info: { state: 0 } };
+                return res.data;
+            },
+        },
+        tokenList: {
+            url: `${tokenServerHost}/api/queryChainList`,
+            method: 'get',
+            requestMapping: {},
+            requestAfter: async (res) => {
+                if (res.code !== 200)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                const tasks = [];
+                for (const item of res.data.chains) {
+                    tasks.push(getTokenListAll(item.key));
+                }
+                const tokenAlls = await Promise.all(tasks);
+                return flatten(tokenAlls);
+            },
+            responseMapping: {
+                tokens: {
+                    format: (res) => {
+                        return res.map((item) => ({
+                            chainId: item.chainId,
+                            address: item.address,
+                            decimals: item.decimals,
+                            logoImg: item.logoImg,
+                            name: item.name,
+                            symbol: item.symbol,
+                        }));
+                    },
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+export default butterConfig;

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/configs/cowswap/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAGjB,MAAM,qBAAqB,CAAA;AAc5B,eAAO,MAAM,aAAa,EAAE,gBA0I3B,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/configs/cowswap/config.js

@@ -0,0 +1,106 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { NATIVE_PLACEHOLDER } from '@1delta/lib-utils';
+import { OrderStatus } from '@cowprotocol/cow-sdk';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+import { ERROR_CODES } from './errors';
+import { getCowSwapReadonlyQuote } from './swap/quote';
+import { getCowSwapQuote } from './swap/route';
+import { getOrderStatus } from './track';
+import { getCowSwapSlippageForNative } from './utils/getCowSwapSlippage';
+const NAME = Bridge.Cowswap;
+export const cowswapConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        quote: {
+            execute: async (crossChainParamsData) => {
+                const { fromTokenAddress, fromChainId, toTokenAddress, toChainId, fromAmount, } = crossChainParamsData;
+                if (fromChainId === toChainId) {
+                    const quoteAndContractAddress = await getCowSwapReadonlyQuote(fromChainId, fromTokenAddress, toTokenAddress, fromAmount);
+                    if (!quoteAndContractAddress)
+                        throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+                    const { quote, contractAddress } = quoteAndContractAddress;
+                    return { ...quote, contractAddress, estimatedDuration: 0 };
+                }
+                else {
+                    throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+                }
+            },
+            responseMapping: {
+                name: 'aggregator',
+                toAmount: 'quote.buyAmount',
+                fee: {},
+                estimatedDuration: 'estimatedDuration',
+            },
+        },
+        route: {
+            execute: async (crossChainParamsData) => {
+                const { fromTokenAddress, fromChainId, fromTokenDecimals, toTokenAddress, toChainId, toTokenDecimals, fromAmount, fromAddress, toAddress, slippage, } = crossChainParamsData;
+                if (fromChainId === toChainId) {
+                    const quoteAndContractAddress = await getCowSwapQuote(fromChainId, fromTokenAddress, fromTokenDecimals, toTokenAddress, toTokenDecimals, fromAmount, fromAddress, toAddress, slippage);
+                    if (!quoteAndContractAddress)
+                        throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+                    // Check for min slippage if native input
+                    if (fromTokenAddress === NATIVE_PLACEHOLDER) {
+                        const minSlippageForNative = getCowSwapSlippageForNative(fromChainId);
+                        if (minSlippageForNative > slippage)
+                            throw new CrossChainBusinessException(ERROR_CODES.SLIPPAGE_TOO_LOW);
+                    }
+                    const { quote, contractAddress } = quoteAndContractAddress;
+                    return { ...quote, contractAddress, estimatedDuration: 0 };
+                }
+                else {
+                    throw new CrossChainBusinessException(ERROR_CODES.NOT_SUPPORT);
+                }
+            },
+            responseMapping: {
+                name: 'aggregator',
+                depositContract: 'contractAddress',
+                toAmount: 'quoteResults.amountsAndCosts.beforeNetworkCosts.buyAmount',
+                fee: {},
+                estimatedDuration: 'estimatedDuration',
+                orderData: {
+                    broadcastIntent: {
+                        format: (result) => result?.postSwapOrderFromQuote,
+                    },
+                },
+            },
+        },
+        status: {
+            execute: async (crossChainParamsData) => {
+                const { fromChainId, orderId } = crossChainParamsData;
+                const status = await getOrderStatus(fromChainId, orderId);
+                return { ...status };
+            },
+            responseMapping: {
+                fromHash: 'hash',
+                statusInfo: {
+                    format: (resResult) => {
+                        const status = resResult.status;
+                        const data = {
+                            status: 'PENDING',
+                            message: 'Pending',
+                            bridgeResponseResult: resResult,
+                        };
+                        if (status === OrderStatus.FULFILLED) {
+                            data.status = 'DONE';
+                            data.message = 'Executed successfully';
+                        }
+                        else if (status === OrderStatus.EXPIRED ||
+                            status === OrderStatus.CANCELLED) {
+                            data.status = 'FAILED';
+                            data.message = 'Transaction failed';
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+    errorCodes: ERROR_CODES,
+};
+export default cowswapConfig;

package/dist/configs/cowswap/errors.d.ts

@@ -0,0 +1,19 @@
+export declare const ERROR_CODES: {
+    ERROR: {
+        code: string;
+        message: string;
+    };
+    NOT_SUPPORT: {
+        code: string;
+        message: string;
+    };
+    DEPOSIT_NOT_FOUND: {
+        code: string;
+        message: string;
+    };
+    SLIPPAGE_TOO_LOW: {
+        code: string;
+        message: string;
+    };
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/configs/cowswap/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/configs/cowswap/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;CAWvB,CAAA"}

package/dist/configs/cowswap/errors.js

@@ -0,0 +1,12 @@
+export const ERROR_CODES = {
+    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',
+    },
+    SLIPPAGE_TOO_LOW: {
+        code: 'SLIPPAGE_TOO_LOW',
+        message: 'slippage too low',
+    },
+};

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

@@ -0,0 +1,5 @@
+export declare function getCowSwapReadonlyQuote(fromChainId: string, fromTokenAddress: string, toTokenAddress: string, amountIn: string): Promise<{
+    quote: import("@cowprotocol/cow-sdk").OrderQuoteResponse;
+    contractAddress: undefined;
+} | undefined>;
+//# sourceMappingURL=quote.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quote.d.ts","sourceRoot":"","sources":["../../../../src/configs/cowswap/swap/quote.ts"],"names":[],"mappings":"AAMA,wBAAsB,uBAAuB,CAC3C,WAAW,EAAE,MAAM,EACnB,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM;;;eAkCjB"}