@1delta/bridge-configs 0.1.0

package/dist/configs/router/config.js

@@ -0,0 +1,125 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { AxiosError } from 'axios';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+const serverHost = 'https://api.pay.routerprotocol.com';
+const NAME = Bridge.ROUTER;
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+};
+var Status;
+(function (Status) {
+    Status["SUCCESS"] = "SUCCESS";
+    Status["FAILED"] = "FAILED";
+})(Status || (Status = {}));
+export const routerConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/swap-on-nitro`,
+            method: 'get',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            requestMapping: {
+                partnerId: 0,
+                slippageTolerance: 'slippage',
+                amount: 'fromAmount',
+                destFuel: 0,
+                fromTokenAddress: 'fromTokenAddress',
+                fromTokenChainId: 'fromChainId',
+                refundAddress: 'toAddress',
+                toTokenAddress: 'toTokenAddress',
+                toTokenChainId: 'toChainId',
+            },
+            requestAfter: async (res) => {
+                return res;
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'depositInfo.depositAddress',
+                toAmount: 'bestRoute.destination.tokenAmount',
+                otherPayOut: {},
+                fee: {
+                    swapFee: 'bestRoute.bridgeFee',
+                    destinationGasFee: '0',
+                },
+                estimatedDuration: 'spentTime',
+                transactionData: {
+                    data: 'bestRoute.txn.data',
+                    value: 'bestRoute.txn.value',
+                    to: 'bestRoute.txn.to',
+                },
+                interfaceParamData: {
+                    depositAddress: 'depositInfo.depositAddress',
+                    uid: 'depositInfo.uid',
+                    allowanceTo: 'bestRoute.allowanceTo',
+                },
+            },
+            after: (err, res) => {
+                if (!err) {
+                    return res;
+                }
+                if (err instanceof AxiosError && err.response?.status === 500)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                throw err;
+            },
+        },
+        status: {
+            url: `${serverHost}/get-status-by-deposit-address`,
+            method: 'get',
+            headers: {},
+            requestMapping: {
+                depositAddress: 'interfaceParamData.depositAddress',
+                chainId: 'fromChainId',
+            },
+            requestAfter: (res) => {
+                if (Array.isArray(res.results) && res.results.length > 0) {
+                    return res.results[0];
+                }
+                throw new CrossChainBusinessException(errorCodes.ERROR);
+            },
+            responseMapping: {
+                toHash: 'relayTxn',
+                statusInfo: {
+                    format: (result) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: result,
+                        };
+                        if (result.status == Status.SUCCESS)
+                            data.status = 'DONE';
+                        else if (result.status == Status.FAILED)
+                            data.status = 'FAILED';
+                        return data;
+                    },
+                },
+            },
+            after: (err, res) => {
+                if (!err) {
+                    return res;
+                }
+                if (err instanceof AxiosError) {
+                    if (err.response?.status === 404) {
+                        return {
+                            toHash: '',
+                            statusInfo: {
+                                status: 'NOT_FOUND',
+                                message: 'NOT_FOUND',
+                                bridgeResponseResult: {},
+                            },
+                        };
+                    }
+                }
+                throw err;
+            },
+        },
+    },
+    errorCodes,
+};
+export default routerConfig;

package/dist/configs/squid-v1/config.d.ts

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

package/dist/configs/squid-v1/config.d.ts.map

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

package/dist/configs/squid-v1/config.js

@@ -0,0 +1,133 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { zeroAddress } from 'viem';
+import { Bridge } from '../../types';
+import { SQUID_INTEGRATOR_ID } from '../squid-v2/constants';
+import { bridgeIcon } from '../utils';
+const serverHost = 'https://api.0xsquid.com';
+const NAME = Bridge.SQUID_V1;
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+};
+export const squidv1Config = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/v1/route`,
+            method: 'get',
+            headers: {
+                'x-integrator-id': SQUID_INTEGRATOR_ID,
+            },
+            requestAfter: (res) => {
+                if (!res.route)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                const feeCosts = res.route.estimate.feeCosts;
+                let feeCostAll = '0';
+                for (const feeCost of feeCosts) {
+                    feeCostAll = (BigInt(feeCostAll) + BigInt(feeCost.amount)).toString(10);
+                }
+                res.route.nativeFeeAll = feeCostAll;
+                return res.route;
+            },
+            requestMapping: {
+                fromChain: 'fromChainId',
+                fromToken: 'fromTokenAddress',
+                fromAmount: 'fromAmount',
+                toChain: 'toChainId',
+                toToken: 'toTokenAddress',
+                toAddress: {
+                    format: (params) => !params.toAddress ? zeroAddress : params.toAddress,
+                },
+                slippage: {
+                    format: (params) => params.slippage * 100,
+                },
+                enableForecall: true,
+                quoteOnly: false,
+                enableExpress: true,
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'transactionRequest.targetAddress',
+                toAmount: 'estimate.toAmount',
+                fee: {
+                    destinationGasFee: 'nativeFeeAll',
+                },
+                estimatedDuration: 'estimate.estimatedRouteDuration',
+                transactionData: {
+                    data: 'transactionRequest.data',
+                    value: 'transactionRequest.value',
+                },
+            },
+        },
+        status: {
+            url: `${serverHost}/v1/status`,
+            method: 'get',
+            headers: {
+                'x-integrator-id': SQUID_INTEGRATOR_ID,
+            },
+            requestAfter: (res) => {
+                if (!res.id)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                return res;
+            },
+            requestMapping: {
+                transactionId: 'fromHash',
+            },
+            responseMapping: {
+                toHash: 'toChain.transactionId',
+                statusInfo: {
+                    format: (resResult) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: resResult,
+                        };
+                        if (resResult.squidTransactionStatus === 'success' ||
+                            resResult.status === 'express_executed') {
+                            data.status = 'DONE';
+                        }
+                        else if (resResult.squidTransactionStatus === 'partial_success') {
+                            data.status = 'PARTIAL_SUCCESS';
+                        }
+                        else if (resResult.squidTransactionStatus === 'pending') {
+                            data.status = 'PENDING';
+                        }
+                        else if (resResult.squidTransactionStatus === 'error') {
+                            data.status = 'FAILED';
+                            data.message = `failed: ${resResult.status} ${resResult.squidTransactionStatus}`;
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+        tokenList: {
+            url: `${serverHost}/v1/sdk-info`,
+            method: 'get',
+            requestAfter: (res) => {
+                if (!res.tokens)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                return res;
+            },
+            responseMapping: {
+                tokens: {
+                    format: (tokenResult) => {
+                        return tokenResult.tokens.map((item) => ({
+                            chainId: item.chainId,
+                            address: item.address,
+                            name: item.name,
+                            symbol: item.symbol,
+                            decimals: item.decimals,
+                            logoImg: item.logoURI,
+                        }));
+                    },
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+export default squidv1Config;

package/dist/configs/squid-v2/config.d.ts

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

package/dist/configs/squid-v2/config.d.ts.map

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

package/dist/configs/squid-v2/config.js

@@ -0,0 +1,146 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { zeroAddress } from 'viem';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+import { SQUID_INTEGRATOR_ID } from './constants';
+const serverHost = 'https://apiplus.squidrouter.com';
+const NAME = Bridge.SQUID_V2;
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+};
+var Status;
+(function (Status) {
+    Status["SUCCESS"] = "success";
+    Status["NEEDS_GAS"] = "needs_gas";
+    Status["ONGOING"] = "ongoing";
+    Status["PARTIAL_SUCCESS"] = "partial_success";
+    Status["NOT_FOUND"] = "not_found";
+    Status["EXPRESS_EXECUTED"] = "express_executed";
+})(Status || (Status = {}));
+export const squidv2Config = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/v2/route`,
+            method: 'post',
+            headers: {
+                'x-integrator-id': SQUID_INTEGRATOR_ID,
+                'Content-Type': 'application/json',
+            },
+            // 1. maps the parameters passed to route to the http request parameters
+            requestMapping: {
+                fromAddress: {
+                    format: (params) => !params.fromAddress ? zeroAddress : params.fromAddress,
+                },
+                fromChain: {
+                    format: (params) => params.fromChainId.toString(),
+                },
+                fromToken: 'fromTokenAddress',
+                fromAmount: 'fromAmount',
+                toChain: {
+                    format: (params) => params.toChainId.toString(),
+                },
+                toToken: 'toTokenAddress',
+                toAddress: {
+                    format: (params) => !params.toAddress ? zeroAddress : params.toAddress,
+                },
+                slippage: 'slippage',
+                slippageConfig: {
+                    autoMode: 1,
+                },
+                quoteOnly: false,
+                enableExpress: true,
+            },
+            // 2. called directly after the request is done with response.data, response.header as parameters, to modify or aggregate data if needed
+            requestAfter: (data, headers) => {
+                if (!data.route)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                data.route.requestId = headers['x-request-id'];
+                const feeCosts = data.route.estimate.feeCosts;
+                let feeCostAll = '0';
+                for (const feeCost of feeCosts) {
+                    feeCostAll = (BigInt(feeCostAll) + BigInt(feeCost.amount)).toString(10);
+                }
+                data.route.nativeFeeAll = feeCostAll;
+                return data.route;
+            },
+            // 3. maps the results from requestAfter to our target object
+            responseMapping: {
+                name: NAME,
+                depositContract: 'transactionRequest.target',
+                toAmount: 'estimate.toAmount',
+                fee: {
+                    destinationGasFee: 'nativeFeeAll',
+                },
+                estimatedDuration: 'estimate.estimatedRouteDuration',
+                transactionData: {
+                    data: 'transactionRequest.data',
+                    value: 'transactionRequest.value',
+                },
+                interfaceParamData: {
+                    requestId: {
+                        format: async (data) => {
+                            return data.requestId;
+                        },
+                    },
+                },
+            },
+        },
+        status: {
+            url: `${serverHost}/v2/status`,
+            method: 'get',
+            headers: {
+                'x-integrator-id': SQUID_INTEGRATOR_ID,
+            },
+            requestAfter: (res) => {
+                if (!res.id)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                return res;
+            },
+            requestMapping: {
+                transactionId: 'fromHash',
+                requestId: 'interfaceParamData.requestId',
+                fromChainId: {
+                    format: (params) => params.fromChainId.toString(),
+                },
+                toChainId: {
+                    format: (params) => params.toChainId.toString(),
+                },
+            },
+            responseMapping: {
+                toHash: 'toChain.transactionId',
+                statusInfo: {
+                    format: (resResult) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: resResult,
+                        };
+                        if (resResult.squidTransactionStatus === Status.SUCCESS ||
+                            resResult.status === Status.EXPRESS_EXECUTED) {
+                            data.status = 'DONE';
+                        }
+                        else if (resResult.squidTransactionStatus === Status.PARTIAL_SUCCESS) {
+                            data.status = 'PARTIAL_SUCCESS';
+                        }
+                        else if (resResult.squidTransactionStatus === Status.ONGOING) {
+                            data.status = 'PENDING';
+                        }
+                        else if (resResult.squidTransactionStatus === Status.NEEDS_GAS ||
+                            resResult.squidTransactionStatus === Status.NOT_FOUND) {
+                            data.status = 'FAILED';
+                            data.message = `failed: ${resResult.status} ${resResult.squidTransactionStatus}`;
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+export default squidv2Config;

package/dist/configs/squid-v2/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const SQUID_INTEGRATOR_ID = "1delta-d6b9c20f-4658-4507-9520-f4a53ee6475e";
+//# sourceMappingURL=constants.d.ts.map

package/dist/configs/squid-v2/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/configs/squid-v2/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,mBAAmB,gDAAgD,CAAA"}

package/dist/configs/squid-v2/constants.js

@@ -0,0 +1 @@
+export const SQUID_INTEGRATOR_ID = '1delta-d6b9c20f-4658-4507-9520-f4a53ee6475e';

package/dist/configs/stargate/abis/StargatePool.d.ts

@@ -0,0 +1,41 @@
+export declare const STARGATE_POOL_ABI: {
+    inputs: ({
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    } | {
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    })[];
+    name: string;
+    outputs: {
+        components: ({
+            internalType: string;
+            name: string;
+            type: string;
+            components?: undefined;
+        } | {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        })[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+}[];
+//# sourceMappingURL=StargatePool.d.ts.map

package/dist/configs/stargate/abis/StargatePool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StargatePool.d.ts","sourceRoot":"","sources":["../../../../src/configs/stargate/abis/StargatePool.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6T7B,CAAA"}