@1delta/bridge-configs 0.1.0

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

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

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

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

package/dist/configs/layerswap/config.js

@@ -0,0 +1,285 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { SupportedChainId } from '@1delta/lib-utils';
+import { formatUnits } from 'viem';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+import LayerswapNetworks from './LayerswapNetworks.json';
+const LAYERSWAP_API_HOST = 'https://api.layerswap.io/api/v2';
+/** This Api key is for tracking only, not critical if public */
+const LAYERSWAP_API_KEY = 'Sj8Y78lM7l8djQPLddouApubaYormq24SKjsHZ7ZP8KbBoXsnqLDMpddmz/a5twzPUZR1TQ1OynHEJ+ABz55wA';
+const NATIVE_COIN_ADDRESS = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+const LAYERSWAP_CHAIN_IDS = {
+    [SupportedChainId.FUEL]: '9889', // Fuel chain ID
+};
+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.LAYERSWAP;
+const findChainByChainId = (chainId) => {
+    return LayerswapNetworks.data.find((c) => c.chain_id === chainId.toString() ||
+        c.chain_id ===
+            LAYERSWAP_CHAIN_IDS[chainId]);
+};
+const findTokenInChain = (chain, tokenAddress) => {
+    return chain?.tokens.find((t) => t.contract?.toLowerCase() === tokenAddress?.toLowerCase() ||
+        (t.contract == null && tokenAddress === NATIVE_COIN_ADDRESS));
+};
+var Status;
+(function (Status) {
+    Status["SUCCESS"] = "completed";
+})(Status || (Status = {}));
+export const layerswapConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        quote: {
+            url: `${LAYERSWAP_API_HOST}/quote`,
+            method: 'get',
+            headers: {
+                'X-LS-APIKEY': LAYERSWAP_API_KEY,
+                accept: 'application/json',
+            },
+            requestMapping: {
+                source_network: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.fromChainId);
+                        return chain?.name || '';
+                    },
+                },
+                source_token: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.fromChainId);
+                        const token = chain && findTokenInChain(chain, params.fromTokenAddress);
+                        return token?.symbol || '';
+                    },
+                },
+                destination_network: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.toChainId);
+                        return chain?.name || '';
+                    },
+                },
+                destination_token: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.toChainId);
+                        const token = chain && findTokenInChain(chain, params.toTokenAddress);
+                        return token?.symbol || '';
+                    },
+                },
+                amount: {
+                    format: (params) => formatUnits(params.fromAmount, params.fromTokenDecimals),
+                },
+            },
+            requestAfter: async (res) => {
+                if (!res?.data?.quote) {
+                    throw new CrossChainBusinessException(ERROR_CODES.ERROR);
+                }
+                return res.data;
+            },
+            responseMapping: {
+                name: NAME,
+                toAmount: {
+                    format: (route, { crossChainParamsData }) => {
+                        return Math.floor(Number(route.quote.receive_amount) *
+                            10 ** Number(crossChainParamsData.toTokenDecimals));
+                    },
+                },
+                fee: {},
+                estimatedDuration: {
+                    format: (route) => {
+                        const [hours, minutes, seconds] = route.quote.avg_completion_time.split(':');
+                        const [secondsPart, _] = seconds.split('.');
+                        return (parseInt(hours) * 3600 +
+                            parseInt(minutes) * 60 +
+                            parseInt(secondsPart));
+                    },
+                },
+            },
+        },
+        route: {
+            url: `${LAYERSWAP_API_HOST}/swaps`,
+            method: 'post',
+            headers: {
+                'X-LS-APIKEY': LAYERSWAP_API_KEY,
+                accept: 'application/json',
+            },
+            requestMapping: {
+                destination_address: 'toAddress',
+                source_address: 'fromAddress',
+                source_network: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.fromChainId);
+                        return chain?.name || '';
+                    },
+                },
+                source_token: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.fromChainId);
+                        const token = chain && findTokenInChain(chain, params.fromTokenAddress);
+                        return token?.symbol || '';
+                    },
+                },
+                destination_network: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.toChainId);
+                        return chain?.name || '';
+                    },
+                },
+                destination_token: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.toChainId);
+                        const token = chain && findTokenInChain(chain, params.toTokenAddress);
+                        return token?.symbol || '';
+                    },
+                },
+                amount: {
+                    format: (params) => formatUnits(params.fromAmount, params.fromTokenDecimals),
+                },
+            },
+            requestAfter: async (res, headers, crossChainParamsData) => {
+                if (!res.data.deposit_actions[0]) {
+                    throw new CrossChainBusinessException(ERROR_CODES.ERROR);
+                }
+                return res.data;
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'deposit_actions[0].to_address',
+                toAmount: {
+                    format: (route, { crossChainParamsData }) => {
+                        return Math.floor(Number(route.quote.receive_amount) *
+                            10 ** Number(crossChainParamsData.toTokenDecimals));
+                    },
+                },
+                fee: {},
+                estimatedDuration: {
+                    format: (route, params) => {
+                        const [hours, minutes, seconds] = route.quote.avg_completion_time.split(':');
+                        const [secondsPart, _] = seconds.split('.');
+                        return (parseInt(hours) * 3600 +
+                            parseInt(minutes) * 60 +
+                            parseInt(secondsPart));
+                    },
+                },
+                interfaceParamData: {
+                    format: (route, { crossChainParamsData }) => {
+                        return route;
+                    },
+                },
+                transactionData: {
+                    data: 'deposit_actions[0].call_data',
+                    value: 'deposit_actions[0].amount_in_base_units',
+                    to: 'deposit_actions[0].to_address',
+                },
+            },
+        },
+        status: {
+            url: `${LAYERSWAP_API_HOST}/internal/swaps`,
+            method: 'get',
+            headers: {
+                'X-LS-APIKEY': LAYERSWAP_API_KEY,
+                accept: 'application/json',
+            },
+            after: (err, res) => {
+                if (!err) {
+                    return res;
+                }
+                throw err;
+            },
+            requestAfter: (res, headers, crossChainParamsData) => {
+                const swap = res.data.find((s) => s.swap.transactions.length > 0 &&
+                    s.swap.transactions.find((t) => t.type == 'input' &&
+                        t.transaction_hash == crossChainParamsData.fromHash));
+                if (!swap)
+                    throw new CrossChainBusinessException(ERROR_CODES.NOT_FOUND);
+                return swap;
+            },
+            requestMapping: {
+                addresses: {
+                    format: (params) => {
+                        return params.fromAddress;
+                    },
+                },
+            },
+            responseMapping: {
+                toHash: {
+                    format: (result) => {
+                        const output_transaction = result.swap.transactions.find((t) => t.type == 'output' && t.transaction_hash);
+                        return output_transaction?.transaction_hash;
+                    },
+                },
+                statusInfo: {
+                    format: (result) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: result.swap.status,
+                        };
+                        if (result.swap.status == Status.SUCCESS) {
+                            data.status = 'DONE';
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+        buildTransactionData: {
+            url: `${LAYERSWAP_API_HOST}/swaps`,
+            method: 'post',
+            headers: {
+                'X-LS-APIKEY': LAYERSWAP_API_KEY,
+                accept: 'application/json',
+            },
+            requestMapping: {
+                destination_address: 'toAddress',
+                source_address: 'fromAddress',
+                source_network: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.fromChainId);
+                        return chain?.name || '';
+                    },
+                },
+                source_token: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.fromChainId);
+                        const token = chain && findTokenInChain(chain, params.fromTokenAddress);
+                        return token?.symbol || '';
+                    },
+                },
+                destination_network: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.toChainId);
+                        return chain?.name || '';
+                    },
+                },
+                destination_token: {
+                    format: (params) => {
+                        const chain = findChainByChainId(params.toChainId);
+                        const token = chain && findTokenInChain(chain, params.toTokenAddress);
+                        return token?.symbol || '';
+                    },
+                },
+                amount: {
+                    format: (params) => formatUnits(params.fromAmount, params.fromTokenDecimals),
+                },
+            },
+            requestAfter: async (res, headers, crossChainParamsData) => {
+                if (!res.data.deposit_actions[0]) {
+                    throw new CrossChainBusinessException(ERROR_CODES.ERROR);
+                }
+                return res.data.deposit_actions[0];
+            },
+            responseMapping: {
+                data: 'call_data',
+                value: 'amount_in_base_units',
+                to: 'to_address',
+            },
+        },
+    },
+    errorCodes: ERROR_CODES,
+};
+export default layerswapConfig;

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

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

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

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

package/dist/configs/lifi/config.js

@@ -0,0 +1,104 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+const serverHost = 'https://li.quest/v1';
+const NAME = Bridge.LIFI;
+const INTEGRATOR_NAME = '1Delta';
+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"] = "PENDING";
+    Status["NOT_FOUND"] = "NOT_FOUND";
+    Status["FAILED"] = "FAILED";
+})(Status || (Status = {}));
+export const lifiConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/quote`,
+            method: 'get',
+            headers: {},
+            requestMapping: {
+                fromChain: 'fromChainId',
+                toChain: 'toChainId',
+                fromToken: 'fromTokenAddress',
+                toToken: 'toTokenAddress',
+                fromAmount: 'fromAmount',
+                fromAddress: 'fromAddress',
+                toAddress: 'toAddress',
+                slippage: 'slippage',
+                integrator: INTEGRATOR_NAME,
+                order: 'order',
+            },
+            requestAfter: (data) => {
+                if (!data)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                return data;
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'transactionRequest.to',
+                toAmount: 'estimate.toAmount',
+                fee: {
+                    destinationGasFee: 'estimate.gasCosts.amount',
+                },
+                estimatedDuration: 'estimate.executionDuration',
+                transactionData: {
+                    data: 'transactionRequest.data',
+                    value: 'transactionRequest.value',
+                    to: 'transactionRequest.to',
+                },
+            },
+        },
+        status: {
+            url: `${serverHost}/status`,
+            method: 'get',
+            requestMapping: {
+                fromChain: 'fromChainId',
+                txHash: 'fromHash',
+            },
+            requestAfter: (res, _, crossChainParamsData) => {
+                return res;
+            },
+            responseMapping: {
+                toHash: 'receiving.txHash',
+                statusInfo: {
+                    format: (res) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: res.substatusMessage,
+                        };
+                        if (res.status === Status.DONE) {
+                            data.status = 'DONE';
+                        }
+                        else if (res.status === Status.PROCESSING) {
+                            data.status = 'PENDING';
+                        }
+                        else if (res.status === Status.NOT_FOUND) {
+                            data.status = 'NOT_FOUND';
+                        }
+                        else if (res.status === Status.FAILED) {
+                            data.status = 'FAILED';
+                            data.message = `failed: ${res.msg}`;
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+export default lifiConfig;

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

@@ -0,0 +1,14 @@
+import { Erc20Permit, Quote, ReferrerAddresses } from '@mayanfinance/swap-sdk';
+export declare namespace MayanBridge {
+    function createEVMTransaction(quote: Quote, swapperAddress: string, signerChainId: string, destinationAddress: string, referrerAddresses?: ReferrerAddresses | null | undefined, permit?: Erc20Permit | null | undefined): {
+        data: string;
+        value: string;
+        to: string;
+    };
+    function createEVMIntent(quote: Quote, swapperAddress: string, signerChainId: string, destinationAddress: string, referrerAddresses?: ReferrerAddresses | null | undefined, permit?: Erc20Permit | null | undefined): {
+        orderId: string;
+        typedData: any;
+        broadcastIntent: (signature: string, permit: Erc20Permit) => Promise<void>;
+    };
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/mayan/calldata/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EAIX,KAAK,EACL,iBAAiB,EAElB,MAAM,wBAAwB,CAAA;AAE/B,yBAAiB,WAAW,CAAC;IAC3B,SAAgB,oBAAoB,CAClC,KAAK,EAAE,KAAK,EACZ,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAC1B,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EACxD,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACtC;QACD,IAAI,EAAE,MAAM,CAAA;QACZ,KAAK,EAAE,MAAM,CAAA;QACb,EAAE,EAAE,MAAM,CAAA;KACX,CAyBA;IAED,SAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,EACZ,cAAc,EAAE,MAAM,EACtB,aAAa,EAAE,MAAM,EACrB,kBAAkB,EAAE,MAAM,EAC1B,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,IAAI,GAAG,SAAS,EACxD,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GACtC;QACD,OAAO,EAAE,MAAM,CAAA;QACf,SAAS,EAAE,GAAG,CAAA;QACd,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KAC3E,CA+BA;CACF"}

package/dist/configs/mayan/calldata/index.js

@@ -0,0 +1,41 @@
+import { getQuoteSuitableReferrerAddress, getSwapFromEvmTxPayload, getSwiftFromEvmGasLessParams, submitSwiftEvmSwap, } from '@mayanfinance/swap-sdk';
+export var MayanBridge;
+(function (MayanBridge) {
+    function createEVMTransaction(quote, swapperAddress, signerChainId, destinationAddress, referrerAddresses, permit) {
+        const transactionRequest = getSwapFromEvmTxPayload(quote, swapperAddress, destinationAddress, referrerAddresses, swapperAddress, signerChainId, null, permit);
+        if (!transactionRequest.data ||
+            !transactionRequest.value ||
+            !transactionRequest.to) {
+            throw new Error('MayanBridge: transactionRequest is undefined or null');
+        }
+        return {
+            data: transactionRequest.data,
+            value: transactionRequest.value.toString(),
+            to: transactionRequest.to.toString(),
+        };
+    }
+    MayanBridge.createEVMTransaction = createEVMTransaction;
+    function createEVMIntent(quote, swapperAddress, signerChainId, destinationAddress, referrerAddresses, permit) {
+        const referrerAddress = getQuoteSuitableReferrerAddress(quote, referrerAddresses);
+        const gasLessParams = getSwiftFromEvmGasLessParams(quote, swapperAddress, destinationAddress, referrerAddress, signerChainId, permit ?? null);
+        const typedData = {
+            primaryType: 'CreateOrder',
+            domain: gasLessParams.orderTypedData.domain,
+            types: gasLessParams.orderTypedData.types,
+            message: gasLessParams.orderTypedData.value,
+        };
+        const broadcastIntent = async (signature, permit) => {
+            gasLessParams.permitParams = permit;
+            await submitSwiftEvmSwap(gasLessParams, signature);
+        };
+        return {
+            orderId: gasLessParams.orderHash,
+            typedData,
+            broadcastIntent,
+        };
+    }
+    MayanBridge.createEVMIntent = createEVMIntent;
+})(MayanBridge || (MayanBridge = {}));
+// api call body for swift
+// {"permitParams":{ "value": "1000000", "deadline":1735302078, "v":28n, "r":"0xe37a73dd09eaa2a70ed2b453c7a47c1f96b308e4a4d9bf2bd06e52264f0c0124", "s":"0x76498fdbfe73fb099db86af615ebc3510a3a1967e8e7501d27a0af00b45b4f79"}
+// ,"orderParams":{"trader":"0x000000000000000000000000334d52e24d452fa20489f07bd943b7cf943cb881","tokenOut":"0x0000000000000000000000000b2c639c533813f4aa9d7837caf62653d097ff85","minAmountOut":"947915","gasDrop":"0","cancelFee":"814","refundFee":"9247","deadline":"1735224713","destAddr":"0x000000000000000000000000334d52e24d452fa20489f07bd943b7cf943cb881","destChainId":24,"referrerAddr":"0x0000000000000000000000000000000000000000000000000000000000000000","referrerBps":0,"auctionMode":2,"random":"0xf5d892322e80ad158b6d6b0ceff4e8e385f68f94bacc6d42f86b4581c965ee54","sourceChainId":23,"amountIn":"1000000","tokenIn":"0xaf88d065e77c8cc2239327c5edb3a432268e5831","submissionFee":"36986"},"orderHash":"0x45de718e6082ac28a2b928d6de0dec68abda36bf1c0f16d16de150aa99a1b138","orderTypedData":{"domain":{"name":"Mayan Swift","chainId":42161,"verifyingContract":"0xC38e4e6A15593f908255214653d3D947CA1c2338"},"types":{"CreateOrder":[{"name":"OrderId","type":"bytes32"},{"name":"InputAmount","type":"uint256"},{"name":"SubmissionFee","type":"uint256"}]},"value":{"OrderId":"0x45de718e6082ac28a2b928d6de0dec68abda36bf1c0f16d16de150aa99a1b138","InputAmount":"963014","SubmissionFee":"36986"}},"signature":"0x6d8d6ad9ada0223bb68c97c8103824210ade76544a173d76045241c2560ec2df725a46acdec9ee43a74d8b68c33b67e6dbc916c73840f416955e4f19006d2ec81c"}

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

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

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

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