@1delta/bridge-configs 0.1.0

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

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

package/dist/configs/across/config.js

@@ -0,0 +1,317 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { CurrencyHandler, getWNative as getWrappedNative, NATIVE_PLACEHOLDER, normalizeDecimals, SupportedChainId, } from '@1delta/lib-utils';
+import axios, { AxiosError } from 'axios';
+import { concat } from 'viem';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+const vercelApiHost = 'https://app.across.to';
+const NAME = Bridge.ACROSS;
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    SERVICE_UNAVAILABLE: {
+        code: 'SERVICE_UNAVAILABLE',
+        message: 'service unavailable',
+    },
+    // other error code
+    UNSUPPORTED_TOKEN: {
+        code: 'UNSUPPORTED_TOKEN',
+        message: 'unsupported token',
+    },
+    AMOUNT_TOO_LOW: {
+        code: 'AMOUNT_TOO_LOW',
+        message: 'amount is too low relative to fees',
+    },
+    DEPOSIT_NOT_FOUND: {
+        code: 'DEPOSIT_NOT_FOUND',
+        message: 'deposit not found',
+    },
+};
+const ALLOW_UNMATCHED_DECIMALS_CHAINS = [
+    SupportedChainId.BNB_SMART_CHAIN_MAINNET,
+];
+export const acrossConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        // Route (required)
+        route: {
+            url: `${vercelApiHost}/api/suggested-fees`,
+            method: 'get',
+            // call this function before execution
+            before: async (params) => {
+                const { fromTokenAddress, fromChainId, fromTokenDecimals, toTokenAddress, toChainId, toTokenDecimals, fromAmount, message, } = params;
+                const isNative = fromTokenAddress === NATIVE_PLACEHOLDER;
+                const fromToken = fromTokenAddress === NATIVE_PLACEHOLDER
+                    ? getWrappedNative(fromChainId).address
+                    : fromTokenAddress;
+                const toToken = toTokenAddress === NATIVE_PLACEHOLDER
+                    ? getWrappedNative(toChainId).address
+                    : toTokenAddress;
+                const routes = await axios.get(`${vercelApiHost}/api/available-routes`, {
+                    params: {
+                        originToken: fromToken,
+                        originChainId: fromChainId,
+                        destinationToken: toToken,
+                        destinationChainId: toChainId,
+                    },
+                });
+                if (routes.data.length === 0 ||
+                    !routes.data.some((route) => route.isNative === isNative) ||
+                    (!message &&
+                        CurrencyHandler.isWNativeAddress(toTokenAddress, toChainId)) || // Across only supports wrapped native as destination token if receiver is contract
+                    (!!message &&
+                        CurrencyHandler.isNativeAddress(toTokenAddress, toChainId)) // Across only supports native as destination token if receiver is EOA
+                ) {
+                    throw new CrossChainBusinessException(errorCodes.UNSUPPORTED_TOKEN);
+                }
+                const toAmount = normalizeDecimals(BigInt(fromAmount), fromTokenDecimals, toTokenDecimals);
+                return {
+                    ...params,
+                    fromTokenAddress: fromToken,
+                    toTokenAddress: toToken,
+                    toAmount,
+                };
+            },
+            // call this function after execution
+            after: (err, res) => {
+                if (!err) {
+                    return res;
+                }
+                if (err instanceof AxiosError) {
+                    if (err.response?.status === 400) {
+                        const errorRes = err.response;
+                        if (errorRes.data.message.match(/no.*token.*found/)) {
+                            throw new CrossChainBusinessException(errorCodes.UNSUPPORTED_TOKEN);
+                        }
+                        if (errorRes.data.message.match(/amount.*too.*low/)) {
+                            throw new CrossChainBusinessException(errorCodes.AMOUNT_TOO_LOW);
+                        }
+                    }
+                }
+                throw err;
+            },
+            // call this function after making API request
+            requestAfter: (res) => res,
+            // Interface request parameter data is put into "requestMapping", and field values are mapped from "CrossChainParamsData" parameters
+            requestMapping: {
+                allowUnmatchedDecimals: {
+                    format: (params) => (ALLOW_UNMATCHED_DECIMALS_CHAINS.includes(params.fromChainId) ||
+                        ALLOW_UNMATCHED_DECIMALS_CHAINS.includes(params.toChainId)) &&
+                        params.fromTokenDecimals !== params.toTokenDecimals,
+                },
+                amount: 'fromAmount',
+                toAmount: 'toAmount',
+                destinationChainId: 'toChainId',
+                originChainId: 'fromChainId',
+                recipient: 'toAddress',
+                token: {
+                    format: (params) => params.fromTokenAddress === NATIVE_PLACEHOLDER
+                        ? getWrappedNative(params.fromChainId).address
+                        : params.fromTokenAddress,
+                },
+                outputToken: {
+                    format: (params) => params.toTokenAddress === NATIVE_PLACEHOLDER
+                        ? getWrappedNative(params.toChainId).address
+                        : params.toTokenAddress,
+                },
+                message: {
+                    format: (params) => params.message,
+                },
+            },
+            // The interface return data is put into "responseMapping", and the field values are mapped from "interface response data
+            responseMapping: {
+                name: NAME,
+                depositContract: 'spokePoolAddress', // deposit contract address
+                toAmount: 'outputAmount',
+                // Fees already subtracted from the toAmount
+                fee: {},
+                estimatedDuration: 'estimatedFillTimeSec',
+                // "Route" API may return data needed for subsequent actions, and this data can be stored in "interfaceParamData" section for later use
+                interfaceParamData: {
+                    relayFeePct: 'relayFeePct',
+                    quoteTimestamp: 'timestamp',
+                    exclusiveRelayer: 'exclusiveRelayer',
+                    exclusivityDeadline: 'exclusivityDeadline',
+                    fillDeadline: 'fillDeadline',
+                    // these are crucial for calldata building, store them here
+                    fromTokenDecimals: {
+                        format: (_, p) => p.crossChainParamsData.fromTokenDecimals,
+                    },
+                    // these are crucial for calldata building, store them here
+                    toTokenDecimals: {
+                        format: (_, p) => p.crossChainParamsData.toTokenDecimals,
+                    },
+                    fixedFee: {
+                        format: (route, _) => {
+                            return BigInt(route.relayGasFeeTotal).toString();
+                        },
+                    },
+                    percFee: {
+                        format: (route, _) => {
+                            // convert 1e18 = 100% to 1e9 = 100%
+                            return ((BigInt(route.capitalFeePct) + BigInt(route.lpFeePct)) /
+                                1000000000n).toString();
+                        },
+                    },
+                    toAmount: 'outputAmount',
+                    fromChainId: {
+                        format: (route, { crossChainParamsData }) => crossChainParamsData.fromChainId,
+                    },
+                    toChainId: {
+                        format: (route, { crossChainParamsData }) => crossChainParamsData.toChainId,
+                    },
+                    fromTokenAddress: {
+                        format: (route, { beforeResult }) => beforeResult.fromTokenAddress,
+                    },
+                    toTokenAddress: {
+                        format: (route, { beforeResult }) => beforeResult.toTokenAddress,
+                    },
+                    message: {
+                        format: (route, { crossChainParamsData }) => {
+                            return crossChainParamsData.message;
+                        },
+                    },
+                    isNative: {
+                        format: (route, { crossChainParamsData }) => crossChainParamsData.fromTokenAddress === NATIVE_PLACEHOLDER,
+                    },
+                },
+            },
+        },
+        // Get Status Interface (required)
+        status: {
+            url: `${vercelApiHost}/api/deposit/status`,
+            method: 'get',
+            after: (err, res) => {
+                if (!err) {
+                    return res;
+                }
+                if (err instanceof AxiosError) {
+                    if (err.response?.status === 404) {
+                        return {
+                            toHash: '',
+                            statusInfo: {
+                                status: 'PENDING',
+                                message: 'PENDING',
+                                bridgeResponseResult: {},
+                            },
+                        };
+                    }
+                }
+                throw err;
+            },
+            requestAfter: (res) => res,
+            requestMapping: {
+                depositTxHash: 'fromHash',
+                originChainId: 'fromChainId',
+            },
+            responseMapping: {
+                toHash: {
+                    format: (resResult) => {
+                        const isFilled = resResult.status === 'filled';
+                        if (!isFilled) {
+                            return '';
+                        }
+                        return resResult.fillTx;
+                    },
+                },
+                statusInfo: {
+                    format: (resResult) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: resResult,
+                        };
+                        if (resResult.status === 'filled') {
+                            data.status = 'DONE';
+                        }
+                        else if (resResult.status === 'expired') {
+                            data.status = 'FAILED';
+                        }
+                        else if (resResult.status === 'refunded') {
+                            data.status = 'TRANSFER_REFUNDED';
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+        // get information on tokens supporting cross chain transactions (required)
+        tokenList: {
+            url: `${vercelApiHost}/api/token-list`,
+            method: 'get',
+            requestAfter: (res) => res,
+            responseMapping: {
+                tokens: {
+                    format: (tokenList) => {
+                        return tokenList.flatMap((item) => {
+                            return {
+                                chainId: item.chainId,
+                                address: item.address,
+                                name: item.name,
+                                symbol: item.symbol,
+                                decimals: item.decimals,
+                                logoImg: item.logoURI,
+                            };
+                        });
+                    },
+                },
+            },
+        },
+        buildTransactionData: {
+            // API to generate onchain transaction data. If "Route" API doesn't return "transactionData",  need to provide this API (optional)
+            url: `${vercelApiHost}/api/build-deposit-tx`,
+            method: 'get',
+            requestAfter: (res) => {
+                return res;
+            },
+            requestMapping: {
+                inputAmount: 'fromAmount',
+                outputAmount: 'toAmount',
+                inputToken: {
+                    format: (params) => params.fromTokenAddress === NATIVE_PLACEHOLDER
+                        ? getWrappedNative(params.fromChainId).address
+                        : params.fromTokenAddress,
+                },
+                outputToken: {
+                    format: (params) => params.toTokenAddress === NATIVE_PLACEHOLDER
+                        ? getWrappedNative(params.toChainId).address
+                        : params.toTokenAddress,
+                },
+                destinationChainId: 'toChainId',
+                originChainId: 'fromChainId',
+                recipient: 'toAddress',
+                depositor: 'fromAddress',
+                quoteTimestamp: {
+                    format: (_, { interfaceParamData }) => interfaceParamData.quoteTimestamp,
+                },
+                isNative: {
+                    format: (_, { interfaceParamData }) => interfaceParamData.isNative,
+                },
+                message: {
+                    format: (_, { interfaceParamData }) => interfaceParamData.message,
+                },
+            },
+            responseMapping: {
+                data: {
+                    format: (resData, { crossChainParamsData }) => {
+                        if (crossChainParamsData.referrer) {
+                            return concat([
+                                resData.data,
+                                '0xd00dfeeddeadbeef',
+                                crossChainParamsData.referrer,
+                            ]);
+                        }
+                        else {
+                            return resData.data;
+                        }
+                    },
+                },
+                value: 'value',
+            },
+        },
+    },
+    errorCodes, // errors status code
+};
+export default acrossConfig;

package/dist/configs/axelar/abis/AxelarGasService.d.ts

@@ -0,0 +1,103 @@
+export declare const AXELAR_GAS_SERVICE_ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: ({
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    } | {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    })[];
+    name: string;
+    type: string;
+    stateMutability?: undefined;
+    outputs?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    inputs: ({
+        internalType: string;
+        name: string;
+        type: string;
+        components?: undefined;
+    } | {
+        components: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        internalType: string;
+        name: string;
+        type: string;
+    })[];
+    name: string;
+    outputs: never[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+})[];
+//# sourceMappingURL=AxelarGasService.d.ts.map

package/dist/configs/axelar/abis/AxelarGasService.d.ts.map

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