@1delta/bridge-configs 0.1.0

package/dist/configs/mayan/config.js

@@ -0,0 +1,222 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { SupportedChainId } from '@1delta/lib-utils';
+import { addresses, getSdkVersion } from '@mayanfinance/swap-sdk';
+import { AxiosError } from 'axios';
+import lodashRound from 'lodash/round';
+import { formatUnits, parseUnits, zeroAddress } from 'viem';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+import { MayanBridge } from './calldata';
+const NAME = Bridge.MAYAN;
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+};
+var Status;
+(function (Status) {
+    Status["COMPLETED"] = "COMPLETED";
+    Status["INPROGRESS"] = "INPROGRESS";
+    Status["REFUNDED"] = "REFUNDED";
+})(Status || (Status = {}));
+const CHAINID_TO_NAME = {
+    [SupportedChainId.ETHEREUM_MAINNET]: 'ethereum',
+    [SupportedChainId.BNB_SMART_CHAIN_MAINNET]: 'bsc',
+    [SupportedChainId.POLYGON_MAINNET]: 'polygon',
+    [SupportedChainId.AVALANCHE_C_CHAIN]: 'avalanche',
+    [SupportedChainId.ARBITRUM_ONE]: 'arbitrum',
+    [SupportedChainId.OP_MAINNET]: 'optimism',
+    [SupportedChainId.BASE]: 'base',
+    [SupportedChainId.UNICHAIN]: 'unichain',
+    [SupportedChainId.LINEA]: 'linea',
+    [SupportedChainId.HYPEREVM]: 'hyperevm',
+    [SupportedChainId.SONIC_MAINNET]: 'sonic',
+};
+const APP_NATIVE_ASSET = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+export const mayanConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${addresses.PRICE_URL}/quote`,
+            method: 'get',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            before: async (params) => {
+                if (!CHAINID_TO_NAME[params.fromChainId] ||
+                    !CHAINID_TO_NAME[params.toChainId]) {
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+                }
+            },
+            requestMapping: {
+                swift: true,
+                mctp: true,
+                gasless: {
+                    format: (params) => params.permitEnabled && params.canDirectlyPermit,
+                },
+                onlyDirect: false,
+                solanaProgram: addresses.MAYAN_PROGRAM_ID,
+                forwarderAddress: addresses.MAYAN_FORWARDER_CONTRACT,
+                amountIn: {
+                    format: (params) => Number(formatUnits(params.fromAmount, params.fromTokenDecimals)),
+                },
+                fromToken: {
+                    format: (params) => params.fromTokenAddress === APP_NATIVE_ASSET
+                        ? zeroAddress
+                        : params.fromTokenAddress,
+                },
+                fromChain: {
+                    format: (params) => CHAINID_TO_NAME[params.fromChainId],
+                },
+                toToken: {
+                    format: (params) => params.toTokenAddress === APP_NATIVE_ASSET
+                        ? zeroAddress
+                        : params.toTokenAddress,
+                },
+                toChain: {
+                    format: (params) => CHAINID_TO_NAME[params.toChainId],
+                },
+                slippageBps: {
+                    format: (params) => params.slippage * 100,
+                },
+                gasDrop: 0,
+                // referrer: "",
+                // referrerBps: undefined,
+                sdkVersion: getSdkVersion(),
+            },
+            requestAfter: async (res, _, crossChainParamsData) => {
+                if (!Array.isArray(res.quotes) || res.quotes.length === 0) {
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                }
+                const quote = res.quotes[0];
+                const isIntent = quote.type === 'SWIFT' && quote.gasless;
+                const userIsDefined = !!crossChainParamsData.fromAddress && !!crossChainParamsData.toAddress;
+                const order = userIsDefined && isIntent
+                    ? MayanBridge.createEVMIntent(quote, crossChainParamsData.fromAddress, crossChainParamsData.fromChainId, crossChainParamsData.toAddress)
+                    : undefined;
+                const txn = userIsDefined && !isIntent
+                    ? MayanBridge.createEVMTransaction(quote, crossChainParamsData.fromAddress, crossChainParamsData.fromChainId, crossChainParamsData.toAddress)
+                    : undefined;
+                return { ...quote, order, txn };
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: {
+                    format: (result) => result.order
+                        ? result.swiftMayanContract
+                        : addresses.MAYAN_FORWARDER_CONTRACT,
+                },
+                toAmount: {
+                    format: (result) => parseUnits(
+                    // use lodash rounding and crop decimals for `parseUnits` as this will error if there are too many decimal places
+                    String(lodashRound(result.expectedAmountOut, result.toToken.decimals)?.toFixed(result.toToken.decimals)), result.toToken.decimals).toString(),
+                },
+                otherPayOut: {},
+                fee: {
+                // "bridgeFee" always seems to be 0
+                },
+                estimatedDuration: 'etaSeconds', // estimated time of arrival in seconds
+                transactionData: {
+                    data: {
+                        format: (result) => result?.txn?.data,
+                    },
+                    value: {
+                        format: (result) => result?.txn?.value,
+                    },
+                    to: {
+                        format: (result) => result?.txn?.to,
+                    },
+                },
+                orderData: {
+                    typedData: {
+                        format: (result) => result?.order?.typedData,
+                    },
+                    broadcastIntent: {
+                        format: (result) => result?.order?.broadcastIntent,
+                    },
+                },
+                interfaceParamData: {
+                    orderId: {
+                        format: (result) => {
+                            return result?.order?.orderId;
+                        },
+                    },
+                },
+            },
+            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: `${addresses.EXPLORER_URL}/swap/trx/:hash:orderId`,
+            method: 'get',
+            before: async (params) => {
+                if (params.orderId) {
+                    params.fromHash = '';
+                }
+                else {
+                    params.orderId = '';
+                }
+            },
+            pathParams: {
+                hash: 'fromHash',
+                orderId: 'orderId',
+            },
+            requestMapping: {},
+            requestAfter: (res) => {
+                if (!res.id)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                return res;
+            },
+            responseMapping: {
+                fromHash: {
+                    format: (result) => result.createTxHash,
+                },
+                toHash: {
+                    format: (result) => result.fulfillTxHash,
+                },
+                statusInfo: {
+                    format: (result) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: result,
+                        };
+                        if (result.clientStatus == Status.COMPLETED)
+                            data.status = 'DONE';
+                        else if (result.clientStatus == Status.REFUNDED)
+                            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 mayanConfig;

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

@@ -0,0 +1,8 @@
+import { CrossChainConfig } from '@1delta/bridge-core';
+/**
+ * Fetches quotes cross-chain swaps using Odos. it utilizes the Across Protocol for bridging.
+ * Note that while this function provides a price quote, the transaction execution is not working for unknown reasons (destination swap is not executed).
+ */
+export declare const odosConfig: CrossChainConfig;
+export default odosConfig;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/configs/odos/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EACjB,MAAM,qBAAqB,CAAA;AAiB5B;;;GAGG;AACH,eAAO,MAAM,UAAU,EAAE,gBAsHxB,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/configs/odos/config.js

@@ -0,0 +1,127 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { NATIVE_PLACEHOLDER } from '@1delta/lib-utils';
+import { AxiosError } from 'axios';
+import { zeroAddress } from 'viem';
+const NAME = 'Odos Cross-Chain';
+const URL = 'https://api.odos.xyz/cross-chain';
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+};
+const ODOS_ICON = 'https://raw.githubusercontent.com/1delta-DAO/protocol-icons/main/aggregator/odos.webp';
+/**
+ * Fetches quotes cross-chain swaps using Odos. it utilizes the Across Protocol for bridging.
+ * Note that while this function provides a price quote, the transaction execution is not working for unknown reasons (destination swap is not executed).
+ */
+export const odosConfig = {
+    name: NAME,
+    icon: {
+        light: ODOS_ICON,
+        dark: ODOS_ICON,
+    },
+    apiInterface: {
+        route: {
+            url: `${URL}/quote`,
+            method: 'post',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            requestMapping: {
+                sourceChain: 'fromChainId',
+                destinationChain: 'toChainId',
+                inputTokens: {
+                    format: (params) => [
+                        {
+                            tokenAddress: params.fromTokenAddress === NATIVE_PLACEHOLDER
+                                ? zeroAddress
+                                : params.fromTokenAddress,
+                            amount: params.fromAmount,
+                        },
+                    ],
+                },
+                outputTokens: {
+                    format: (params) => [
+                        {
+                            tokenAddress: params.toTokenAddress === NATIVE_PLACEHOLDER
+                                ? zeroAddress
+                                : params.toTokenAddress,
+                            proportion: 1,
+                        },
+                    ],
+                },
+                slippageLimitPercent: 'slippage',
+                userAddr: 'toAddress',
+                compact: {
+                    format: () => true,
+                },
+                disableRFQs: {
+                    format: () => false,
+                },
+                sourceBlacklist: {
+                    format: () => [],
+                },
+                pathViz: {
+                    format: () => false,
+                },
+                referralCode: {
+                    format: () => 0,
+                },
+                likeAsset: {
+                    format: () => false,
+                },
+            },
+            requestAfter: async (res, _, crossChainParamsData) => {
+                if (!res?.destinationQuote || !res?.transaction) {
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                }
+                const quote = res.destinationQuote;
+                const userIsDefined = !!crossChainParamsData.fromAddress && !!crossChainParamsData.toAddress;
+                const txn = userIsDefined ? res.transaction : undefined;
+                return { ...quote, txn };
+            },
+            responseMapping: {
+                name: NAME,
+                depositContract: 'txn.to',
+                toAmount: {
+                    format: (result) => result?.outAmounts[0],
+                },
+                otherPayOut: {},
+                fee: {
+                // "bridgeFee" always seems to be 0
+                },
+                estimatedDuration: '60', // estimated time of arrival in seconds
+                transactionData: {
+                    data: 'txn.data',
+                    value: 'txn.value',
+                    to: 'txn.to',
+                },
+                interfaceParamData: {},
+            },
+            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: `${URL}`,
+            method: 'get',
+            requestMapping: {},
+            requestAfter: () => { },
+            responseMapping: {
+                fromHash: '',
+                toHash: '',
+                statusInfo: {
+                    status: 'DONE',
+                    message: '',
+                    bridgeResponseResult: '',
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+export default odosConfig;

package/dist/configs/orbiter/abis/ERC20.d.ts

@@ -0,0 +1,172 @@
+export declare const ERC20_ABI: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Approval";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "from";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly name: "allowance";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "approve";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "account";
+        readonly type: "address";
+    }];
+    readonly name: "balanceOf";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "decimals";
+    readonly outputs: readonly [{
+        readonly internalType: "uint8";
+        readonly name: "";
+        readonly type: "uint8";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "name";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "symbol";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "totalSupply";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "sender";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "recipient";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "transferFrom";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=ERC20.d.ts.map

package/dist/configs/orbiter/abis/ERC20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ERC20.d.ts","sourceRoot":"","sources":["../../../../src/configs/orbiter/abis/ERC20.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+NZ,CAAA"}