@1delta/bridge-configs 0.1.0

package/dist/configs/stargate/common/constants.d.ts

@@ -0,0 +1,5 @@
+import { TransportType } from '../types';
+export declare const NATIVE_PLACEHOLDER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+export declare const SERVER_HOST = "https://mainnet.stargate-api.com/v1";
+export declare const ESTIMATED_DURATION_BY_TRANSPORT: Record<TransportType, number>;
+//# sourceMappingURL=constants.d.ts.map

package/dist/configs/stargate/common/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/configs/stargate/common/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAExC,eAAO,MAAM,kBAAkB,+CAA+C,CAAA;AAE9E,eAAO,MAAM,WAAW,wCAAwC,CAAA;AAEhE,eAAO,MAAM,+BAA+B,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAGzE,CAAA"}

package/dist/configs/stargate/common/constants.js

@@ -0,0 +1,7 @@
+import { TransportType } from '../types';
+export const NATIVE_PLACEHOLDER = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+export const SERVER_HOST = 'https://mainnet.stargate-api.com/v1';
+export const ESTIMATED_DURATION_BY_TRANSPORT = {
+    [TransportType.Bus]: 600, // up to 10min
+    [TransportType.Taxi]: 60, // around 1min
+};

package/dist/configs/stargate/common/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/stargate/common/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,aAAa,CAAA"}

package/dist/configs/stargate/common/index.js

@@ -0,0 +1,2 @@
+export * from './config';
+export * from './constants';

package/dist/configs/stargate/configs/bus/config.d.ts

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

package/dist/configs/stargate/configs/bus/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../src/configs/stargate/configs/bus/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAc,MAAM,qBAAqB,CAAA;AAKlE,eAAO,MAAM,iBAAiB,EAAE,gBAyC/B,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/configs/stargate/configs/bus/config.js

@@ -0,0 +1,41 @@
+import { Bridge } from '../../../../types';
+import { SERVER_HOST, stargateConfig } from '../../common';
+export const stargateBusConfig = {
+    ...stargateConfig,
+    name: Bridge.STARGATE_BUS,
+    apiInterface: {
+        ...stargateConfig.apiInterface,
+        status: {
+            url: `${SERVER_HOST}/buses/bus-queue/:hash`,
+            pathParams: {
+                hash: 'fromHash',
+            },
+            method: 'get',
+            requestMapping: {},
+            requestAfter: (res, _, crossChainParamsData) => {
+                const { fromHash } = crossChainParamsData;
+                const hashExists = res.some((entry) => entry?.inQueue === false);
+                return {
+                    hashExists,
+                    fromHash,
+                };
+            },
+            responseMapping: {
+                toHash: '',
+                statusInfo: {
+                    format: (res) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: res,
+                        };
+                        if (res.hashExists) {
+                            data.status = 'DONE';
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+};
+export default stargateBusConfig;

package/dist/configs/stargate/configs/taxi/config.d.ts

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

package/dist/configs/stargate/configs/taxi/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../src/configs/stargate/configs/taxi/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAc,MAAM,qBAAqB,CAAA;AASlE,eAAO,MAAM,kBAAkB,EAAE,gBAyDhC,CAAA;AAED,eAAe,kBAAkB,CAAA"}

package/dist/configs/stargate/configs/taxi/config.js

@@ -0,0 +1,58 @@
+import { Bridge } from '../../../../types';
+import { getStargateContract, STARGATE_CHAIN_NAME, } from '../../calldata/constants';
+import { SERVER_HOST, stargateConfig } from '../../common';
+export const stargateTaxiConfig = {
+    ...stargateConfig,
+    name: Bridge.STARGATE_TAXI,
+    apiInterface: {
+        ...stargateConfig.apiInterface,
+        status: {
+            url: `${SERVER_HOST}/overview/transfers`,
+            method: 'get',
+            before: async (params) => {
+                const { fromTokenAddress, fromChainId, toTokenAddress, toChainId } = params;
+                params.srcPool = getStargateContract(fromChainId, fromTokenAddress);
+                params.dstPool = getStargateContract(toChainId, toTokenAddress);
+                params.srcChainKey = STARGATE_CHAIN_NAME[fromChainId];
+                params.dstChainKey = STARGATE_CHAIN_NAME[toChainId];
+            },
+            requestMapping: {
+                srcPool: 'srcPool',
+                dstPool: 'dstPool',
+                srcChainKey: 'srcChainKey',
+                dstChainKey: 'dstChainKey',
+                version: {
+                    format: () => 'v2',
+                },
+                sort: {
+                    format: () => 'desc',
+                },
+            },
+            requestAfter: (res, _, crossChainParamsData) => {
+                const fromHash = crossChainParamsData.fromHash;
+                const data = res.data;
+                const hashExists = data.some((entry) => entry.srcTxHash === fromHash);
+                return {
+                    hashExists,
+                    fromHash,
+                };
+            },
+            responseMapping: {
+                toHash: '',
+                statusInfo: {
+                    format: (res) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: res,
+                        };
+                        if (res.hashExists) {
+                            data.status = 'DONE';
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+};
+export default stargateTaxiConfig;

package/dist/configs/stargate/types/index.d.ts

@@ -0,0 +1,12 @@
+export declare enum TransportType {
+    Taxi = "taxi",
+    Bus = "bus"
+}
+export declare enum StargateAssetIds {
+    USDC = 1,
+    USDT = 2,
+    ETH = 13,
+    METIS = 17,
+    mETH = 22
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/stargate/types/index.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IAEvB,IAAI,SAAS;IAEb,GAAG,QAAQ;CACZ;AAED,oBAAY,gBAAgB;IAC1B,IAAI,IAAI;IACR,IAAI,IAAI;IACR,GAAG,KAAK;IACR,KAAK,KAAK;IACV,IAAI,KAAK;CACV"}

package/dist/configs/stargate/types/index.js

@@ -0,0 +1,15 @@
+export var TransportType;
+(function (TransportType) {
+    // Taxi is nearly instant (sub 1min) and composable but costs more
+    TransportType["Taxi"] = "taxi";
+    // Bus is slower (5-10min) but cheaper and not composable
+    TransportType["Bus"] = "bus";
+})(TransportType || (TransportType = {}));
+export var StargateAssetIds;
+(function (StargateAssetIds) {
+    StargateAssetIds[StargateAssetIds["USDC"] = 1] = "USDC";
+    StargateAssetIds[StargateAssetIds["USDT"] = 2] = "USDT";
+    StargateAssetIds[StargateAssetIds["ETH"] = 13] = "ETH";
+    StargateAssetIds[StargateAssetIds["METIS"] = 17] = "METIS";
+    StargateAssetIds[StargateAssetIds["mETH"] = 22] = "mETH";
+})(StargateAssetIds || (StargateAssetIds = {}));

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

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

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

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

package/dist/configs/symbiosis/config.js

@@ -0,0 +1,119 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+const serverHost = 'https://api.symbiosis.finance/crosschain';
+const NAME = Bridge.SYMBIOSIS;
+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[Status["DONE"] = 0] = "DONE";
+    Status[Status["PROCESSING"] = 1] = "PROCESSING";
+    Status[Status["NOT_FOUND"] = -1] = "NOT_FOUND";
+    Status[Status["STUCKED"] = 2] = "STUCKED";
+    Status[Status["REVERTED"] = 3] = "REVERTED";
+})(Status || (Status = {}));
+export const symbiosisConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/v1/swap`,
+            method: 'post',
+            requestMapping: {
+                tokenAmountIn: {
+                    format: (params) => {
+                        return {
+                            address: params.fromTokenAddress,
+                            amount: params.fromAmount,
+                            chainId: Number(params.fromChainId),
+                            decimals: params.fromTokenDecimals,
+                        };
+                    },
+                },
+                tokenOut: {
+                    format: (params) => {
+                        return {
+                            address: params.toTokenAddress,
+                            chainId: Number(params.toChainId),
+                            decimals: params.toTokenDecimals,
+                        };
+                    },
+                },
+                selectMode: 'best_return',
+                from: 'fromAddress',
+                to: 'toAddress',
+                slippage: {
+                    format: (params) => {
+                        return Number(params.slippage * 100);
+                    },
+                },
+            },
+            requestAfter: (data) => {
+                if (!data)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                return data;
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'approveTo',
+                toAmount: 'tokenAmountOut.amount',
+                fee: {},
+                estimatedDuration: 'estimatedTime',
+                transactionData: {
+                    data: 'tx.data',
+                    value: 'tx.value',
+                    to: 'tx.to',
+                },
+            },
+        },
+        status: {
+            url: `${serverHost}/v1/tx/:chainId/:transactionHash`,
+            method: 'get',
+            pathParams: {
+                chainId: 'fromChainId',
+                transactionHash: 'fromHash',
+            },
+            requestMapping: {},
+            requestAfter: (res) => {
+                return res;
+            },
+            responseMapping: {
+                toHash: 'tx.Hash',
+                statusInfo: {
+                    format: (res) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: res.status.text,
+                        };
+                        if (res?.status?.code === Status.DONE) {
+                            data.status = 'DONE';
+                        }
+                        else if (res?.status?.code === Status.PROCESSING) {
+                            data.status = 'PENDING';
+                        }
+                        else if (res?.status?.code === Status.NOT_FOUND) {
+                            data.status = 'NOT_FOUND';
+                        }
+                        else if (res?.status?.code === Status.STUCKED) {
+                            data.status = 'FAILED';
+                            data.message = `failed: ${res.msg}`;
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+export default symbiosisConfig;

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

@@ -0,0 +1,2 @@
+export declare function bridgeIcon(aggregator: string): string;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/configs/utils/index.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,UAAU,EAAE,MAAM,UAE5C"}

package/dist/configs/utils/index.js

@@ -0,0 +1,3 @@
+export function bridgeIcon(aggregator) {
+    return `https://raw.githubusercontent.com/1delta-DAO/protocol-icons/main/bridge/${aggregator.toLowerCase()}.webp`;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/configs/xy/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EAEjB,MAAM,qBAAqB,CAAA;AA0B5B,eAAO,MAAM,QAAQ,EAAE,gBAmItB,CAAA;AAsBD,eAAe,QAAQ,CAAA"}

package/dist/configs/xy/config.js

@@ -0,0 +1,176 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+const serverHost = 'https://aggregator-api.xy.finance/v1';
+const NAME = Bridge.XY;
+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["DONE"] = "Done";
+    Status["PROCESSING"] = "Processing";
+    Status["NOT_FOUND"] = "Not found";
+    Status["REFUNDED"] = "Refunded";
+    Status["PENDING_REFUND"] = "Pending refund";
+    Status["FAILED"] = "FAILED";
+})(Status || (Status = {}));
+export const xyConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/quote`,
+            method: 'get',
+            headers: {},
+            requestMapping: {
+                srcChainId: 'fromChainId',
+                dstChainId: 'toChainId',
+                srcQuoteTokenAddress: 'fromTokenAddress',
+                srcQuoteTokenAmount: 'fromAmount',
+                dstQuoteTokenAddress: 'toTokenAddress',
+                slippage: 'slippage',
+            },
+            requestAfter: (data) => {
+                if (!data.routes)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                const bestRoute = getBestRoute(data.routes);
+                return bestRoute;
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'contractAddress',
+                toAmount: 'dstQuoteTokenAmount',
+                fee: {
+                    destinationGasFee: 'withholdingFeeAmount',
+                },
+                estimatedDuration: 'estimatedTransferTime',
+                interfaceParamData: {
+                    srcSwapDescription: 'srcSwapDescription',
+                    bridgeDescription: 'bridgeDescription',
+                    dstSwapDescription: 'dstSwapDescription',
+                },
+            },
+        },
+        status: {
+            url: `${serverHost}/crossChainStatus`,
+            method: 'get',
+            requestMapping: {
+                srcChainId: 'fromChainId',
+                srcTxHash: 'fromHash',
+            },
+            requestAfter: (res, _, crossChainParamsData) => {
+                return res;
+            },
+            responseMapping: {
+                toHash: 'tx',
+                statusInfo: {
+                    format: (res) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: res.msg,
+                        };
+                        if (res.status === Status.DONE) {
+                            data.status = 'DONE';
+                        }
+                        else if (res.status === Status.PROCESSING ||
+                            res.status === Status.PENDING_REFUND) {
+                            data.status = 'PENDING';
+                        }
+                        else if (res.status === Status.NOT_FOUND) {
+                            data.status = 'NOT_FOUND';
+                        }
+                        else if (res.status === Status.REFUNDED) {
+                            data.status = 'TRANSFER_REFUNDED';
+                        }
+                        else if (res.status === Status.FAILED) {
+                            data.status = 'FAILED';
+                            data.message = `failed: ${res.msg}`;
+                        }
+                        else if (res.status) {
+                            data.status = 'PARTIAL_SUCCESS';
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+        buildTransactionData: {
+            url: `${serverHost}/buildTx`,
+            method: 'get',
+            headers: {},
+            requestMapping: {
+                srcChainId: 'fromChainId',
+                dstChainId: 'toChainId',
+                srcQuoteTokenAddress: 'fromTokenAddress',
+                srcQuoteTokenAmount: 'fromAmount',
+                dstQuoteTokenAddress: 'toTokenAddress',
+                slippage: 'slippage',
+                receiver: 'toAddress',
+                srcSwapProvider: {
+                    format: (_, { interfaceParamData }) => {
+                        return interfaceParamData.srcSwapDescription?.provider;
+                    },
+                },
+                dstSwapProvider: {
+                    format: (_, { interfaceParamData }) => {
+                        return interfaceParamData.dstSwapDescription?.provider;
+                    },
+                },
+                bridgeProvider: {
+                    format: (_, { interfaceParamData }) => {
+                        return interfaceParamData.bridgeDescription?.provider;
+                    },
+                },
+                srcBridgeTokenAddress: {
+                    format: (_, { interfaceParamData }) => {
+                        return interfaceParamData.bridgeDescription?.srcBridgeTokenAddress;
+                    },
+                },
+                dstBridgeTokenAddress: {
+                    format: (_, { interfaceParamData }) => {
+                        return interfaceParamData.bridgeDescription?.dstBridgeTokenAddress;
+                    },
+                },
+            },
+            requestAfter: (res) => {
+                if (res.success !== true)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                return res;
+            },
+            responseMapping: {
+                data: 'tx.data',
+                value: 'tx.value',
+                to: 'tx.to',
+            },
+        },
+    },
+    errorCodes,
+};
+const getBestRoute = (routes) => {
+    if (!routes || routes.length === 0) {
+        return null;
+    }
+    // Return route with greatest usd output
+    const bestRoute = routes.reduce((bestRoute, currentRoute) => {
+        // Convert values to numbers and handle potential null/undefined
+        const bestTotalOutput = Number(bestRoute?.dstQuoteTokenUsdValue || 0);
+        const currentTotalOutput = Number(currentRoute?.dstQuoteTokenUsdValue || 0);
+        // Handle NaN cases
+        if (isNaN(currentTotalOutput))
+            return bestRoute;
+        if (isNaN(bestTotalOutput))
+            return currentRoute;
+        return currentTotalOutput > bestTotalOutput ? currentRoute : bestRoute;
+    });
+    return bestRoute;
+};
+export default xyConfig;

package/dist/configs/zenlink/calldata/aggregationRouterV2ABI.d.ts

@@ -0,0 +1,49 @@
+export declare const aggregationRouterV2ABI: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "contract IAggregationExecutor";
+        readonly name: "executor";
+        readonly type: "address";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "Currency";
+            readonly name: "srcToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "Currency";
+            readonly name: "dstToken";
+            readonly type: "address";
+        }, {
+            readonly internalType: "address";
+            readonly name: "dstReceiver";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "amount";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "minReturnAmount";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct AggregationRouter.SwapDescription";
+        readonly name: "desc";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "route";
+        readonly type: "bytes";
+    }];
+    readonly name: "swap";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "returnAmount";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "spentAmount";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=aggregationRouterV2ABI.d.ts.map

package/dist/configs/zenlink/calldata/aggregationRouterV2ABI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregationRouterV2ABI.d.ts","sourceRoot":"","sources":["../../../../src/configs/zenlink/calldata/aggregationRouterV2ABI.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8DzB,CAAA"}

package/dist/configs/zenlink/calldata/aggregationRouterV2ABI.js

@@ -0,0 +1,63 @@
+export const aggregationRouterV2ABI = [
+    {
+        inputs: [
+            {
+                internalType: 'contract IAggregationExecutor',
+                name: 'executor',
+                type: 'address',
+            },
+            {
+                components: [
+                    {
+                        internalType: 'Currency',
+                        name: 'srcToken',
+                        type: 'address',
+                    },
+                    {
+                        internalType: 'Currency',
+                        name: 'dstToken',
+                        type: 'address',
+                    },
+                    {
+                        internalType: 'address',
+                        name: 'dstReceiver',
+                        type: 'address',
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'amount',
+                        type: 'uint256',
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'minReturnAmount',
+                        type: 'uint256',
+                    },
+                ],
+                internalType: 'struct AggregationRouter.SwapDescription',
+                name: 'desc',
+                type: 'tuple',
+            },
+            {
+                internalType: 'bytes',
+                name: 'route',
+                type: 'bytes',
+            },
+        ],
+        name: 'swap',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: 'returnAmount',
+                type: 'uint256',
+            },
+            {
+                internalType: 'uint256',
+                name: 'spentAmount',
+                type: 'uint256',
+            },
+        ],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+];

package/dist/configs/zenlink/calldata/index.d.ts

@@ -0,0 +1,18 @@
+import { Address, Hex } from 'viem';
+export interface CreateZenlinkCalldataParams {
+    routerAddress: string;
+    executorAddress: string;
+    tokenIn: string;
+    tokenOut: string;
+    amount: string;
+    to: string;
+    amountOutMin: string;
+    routeCode: string;
+    value: string;
+}
+export declare function createZenlinkCalldata({ routerAddress, executorAddress, tokenIn, tokenOut, amount, to, amountOutMin, routeCode, value, }: CreateZenlinkCalldataParams): Promise<{
+    to: Address;
+    data: Hex;
+    value: string;
+}>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/zenlink/calldata/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAsB,GAAG,EAAE,MAAM,MAAM,CAAA;AAIvD,MAAM,WAAW,2BAA2B;IAC1C,aAAa,EAAE,MAAM,CAAA;IACrB,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,EAAE,EAAE,MAAM,CAAA;IACV,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;CACd;AAED,wBAAsB,qBAAqB,CAAC,EAC1C,aAAa,EACb,eAAe,EACf,OAAO,EACP,QAAQ,EACR,MAAM,EACN,EAAE,EACF,YAAY,EACZ,SAAS,EACT,KAAK,GACN,EAAE,2BAA2B,GAAG,OAAO,CAAC;IACvC,EAAE,EAAE,OAAO,CAAA;IACX,IAAI,EAAE,GAAG,CAAA;IACT,KAAK,EAAE,MAAM,CAAA;CACd,CAAC,CAqCD"}