@1delta/bridge-configs 0.1.0

package/dist/configs/orbiter/abis/ERC20.js

@@ -0,0 +1,224 @@
+export const ERC20_ABI = [
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: 'address',
+                name: 'owner',
+                type: 'address',
+            },
+            {
+                indexed: true,
+                internalType: 'address',
+                name: 'spender',
+                type: 'address',
+            },
+            {
+                indexed: false,
+                internalType: 'uint256',
+                name: 'value',
+                type: 'uint256',
+            },
+        ],
+        name: 'Approval',
+        type: 'event',
+    },
+    {
+        anonymous: false,
+        inputs: [
+            {
+                indexed: true,
+                internalType: 'address',
+                name: 'from',
+                type: 'address',
+            },
+            {
+                indexed: true,
+                internalType: 'address',
+                name: 'to',
+                type: 'address',
+            },
+            {
+                indexed: false,
+                internalType: 'uint256',
+                name: 'value',
+                type: 'uint256',
+            },
+        ],
+        name: 'Transfer',
+        type: 'event',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'owner',
+                type: 'address',
+            },
+            {
+                internalType: 'address',
+                name: 'spender',
+                type: 'address',
+            },
+        ],
+        name: 'allowance',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'spender',
+                type: 'address',
+            },
+            {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+        ],
+        name: 'approve',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool',
+            },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'account',
+                type: 'address',
+            },
+        ],
+        name: 'balanceOf',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'decimals',
+        outputs: [
+            {
+                internalType: 'uint8',
+                name: '',
+                type: 'uint8',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'name',
+        outputs: [
+            {
+                internalType: 'string',
+                name: '',
+                type: 'string',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'symbol',
+        outputs: [
+            {
+                internalType: 'string',
+                name: '',
+                type: 'string',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'totalSupply',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'recipient',
+                type: 'address',
+            },
+            {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+        ],
+        name: 'transfer',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool',
+            },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: 'sender',
+                type: 'address',
+            },
+            {
+                internalType: 'address',
+                name: 'recipient',
+                type: 'address',
+            },
+            {
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+        ],
+        name: 'transferFrom',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool',
+            },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+];

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

@@ -0,0 +1,85 @@
+export declare const Orbiter_V3_ABI_EVM: readonly [{
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly name: "Transfer";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract IERC20";
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address";
+        readonly name: "to";
+        readonly type: "address";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "value";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes";
+        readonly name: "data";
+        readonly type: "bytes";
+    }];
+    readonly name: "transferToken";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "contract IERC20";
+        readonly name: "token";
+        readonly type: "address";
+    }, {
+        readonly internalType: "address[]";
+        readonly name: "tos";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "values";
+        readonly type: "uint256[]";
+    }];
+    readonly name: "transferTokens";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address[]";
+        readonly name: "tos";
+        readonly type: "address[]";
+    }, {
+        readonly internalType: "uint256[]";
+        readonly name: "values";
+        readonly type: "uint256[]";
+    }];
+    readonly name: "transfers";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+//# sourceMappingURL=OrbiterRouterEVMV3.d.ts.map

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

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

package/dist/configs/orbiter/abis/OrbiterRouterEVMV3.js

@@ -0,0 +1,83 @@
+export const Orbiter_V3_ABI_EVM = [
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: 'address', name: 'to', type: 'address' },
+            {
+                indexed: false,
+                internalType: 'uint256',
+                name: 'amount',
+                type: 'uint256',
+            },
+        ],
+        name: 'Transfer',
+        type: 'event',
+    },
+    {
+        inputs: [
+            { internalType: 'address', name: 'to', type: 'address' },
+            {
+                internalType: 'bytes',
+                name: 'data',
+                type: 'bytes',
+            },
+        ],
+        name: 'transfer',
+        outputs: [],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'contract IERC20', name: 'token', type: 'address' },
+            {
+                internalType: 'address',
+                name: 'to',
+                type: 'address',
+            },
+            { internalType: 'uint256', name: 'value', type: 'uint256' },
+            {
+                internalType: 'bytes',
+                name: 'data',
+                type: 'bytes',
+            },
+        ],
+        name: 'transferToken',
+        outputs: [],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'contract IERC20',
+                name: 'token',
+                type: 'address',
+            },
+            { internalType: 'address[]', name: 'tos', type: 'address[]' },
+            {
+                internalType: 'uint256[]',
+                name: 'values',
+                type: 'uint256[]',
+            },
+        ],
+        name: 'transferTokens',
+        outputs: [],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'address[]', name: 'tos', type: 'address[]' },
+            {
+                internalType: 'uint256[]',
+                name: 'values',
+                type: 'uint256[]',
+            },
+        ],
+        name: 'transfers',
+        outputs: [],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+];

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

@@ -0,0 +1,32 @@
+import { TransactionData as BuildTransactionDataResponse } from '@1delta/bridge-core';
+export interface OrbiterRoute {
+    line: string;
+    type: string;
+    endpoint: string;
+    endpointContract: string;
+    srcChain: string;
+    tgtChain: string;
+    srcToken: string;
+    tgtToken: string;
+    maxAmt: string;
+    minAmt: string;
+    tradeFee: string;
+    withholdingFee: string;
+    vc: string;
+    state: string;
+    compRatio: number;
+    spentTime: number;
+    tieredFee: [];
+}
+export declare enum OrbiterRouterV3 {
+    Transfer = "transfer",
+    TransferToken = "transferToken"
+}
+export declare namespace OrbiterRouterV3 {
+    const encodeTransaction: (route: OrbiterRoute, amount: string, to?: string) => BuildTransactionDataResponse | undefined;
+    const encodeEvmContractTransfer: (endpoint: string, endpointContract: string, amount: bigint | string, str: string) => BuildTransactionDataResponse;
+    const encodeEvmContractTransferToken: (srcToken: string, endpoint: string, endpointContract: string, amount: bigint | string, str: string) => BuildTransactionDataResponse;
+    const encodeEvmNativeTransfer: (endpoint: string, amount: string, vc: string) => BuildTransactionDataResponse;
+    const encodeEvmNativeTransferToken: (srcToken: string, endpoint: string, amount: string, vc: string) => BuildTransactionDataResponse;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/configs/orbiter/calldata/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,IAAI,4BAA4B,EAAE,MAAM,qBAAqB,CAAA;AAIrF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,gBAAgB,EAAE,MAAM,CAAA;IACxB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,cAAc,EAAE,MAAM,CAAA;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,EAAE,CAAA;CACd;AAGD,oBAAY,eAAe;IACzB,QAAQ,aAAa;IACrB,aAAa,kBAAkB;CAChC;AACD,yBAAiB,eAAe,CAAC;IACxB,MAAM,iBAAiB,GAC5B,OAAO,YAAY,EACnB,QAAQ,MAAM,EACd,KAAK,MAAM,KACV,4BAA4B,GAAG,SA+BjC,CAAA;IACM,MAAM,yBAAyB,GACpC,UAAU,MAAM,EAChB,kBAAkB,MAAM,EACxB,QAAQ,MAAM,GAAG,MAAM,EACvB,KAAK,MAAM,KACV,4BAQF,CAAA;IACM,MAAM,8BAA8B,GACzC,UAAU,MAAM,EAChB,UAAU,MAAM,EAChB,kBAAkB,MAAM,EACxB,QAAQ,MAAM,GAAG,MAAM,EACvB,KAAK,MAAM,KACV,4BAQF,CAAA;IACM,MAAM,uBAAuB,GAClC,UAAU,MAAM,EAChB,QAAQ,MAAM,EACd,IAAI,MAAM,KACT,4BAIF,CAAA;IACM,MAAM,4BAA4B,GACvC,UAAU,MAAM,EAChB,UAAU,MAAM,EAChB,QAAQ,MAAM,EACd,IAAI,MAAM,KACT,4BAQF,CAAA;CACF"}

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

@@ -0,0 +1,59 @@
+import { encodeFunctionData, parseUnits, toHex } from 'viem';
+import { Orbiter_V3_ABI_EVM } from '../abis/OrbiterRouterEVMV3';
+import { ERC20_ABI } from '../abis/ERC20';
+export var OrbiterRouterV3;
+(function (OrbiterRouterV3) {
+    OrbiterRouterV3["Transfer"] = "transfer";
+    OrbiterRouterV3["TransferToken"] = "transferToken";
+})(OrbiterRouterV3 || (OrbiterRouterV3 = {}));
+(function (OrbiterRouterV3) {
+    OrbiterRouterV3.encodeTransaction = (route, amount, to) => {
+        const vc = Number(route.vc.slice(1, 4));
+        const extendedParameters = `c=${vc}&t=${to}`;
+        if (route.srcToken == '0x0000000000000000000000000000000000000000' &&
+            route.endpointContract == null) {
+            return OrbiterRouterV3.encodeEvmNativeTransfer(route.endpoint, amount, route.vc);
+        }
+        else if (route.srcToken == '0x0000000000000000000000000000000000000000') {
+            return OrbiterRouterV3.encodeEvmContractTransfer(route.endpoint, route.endpointContract, amount, extendedParameters);
+        }
+        else if (route.endpointContract) {
+            return OrbiterRouterV3.encodeEvmContractTransferToken(route.srcToken, route.endpoint, route.endpointContract, amount, extendedParameters);
+        }
+        else {
+            return OrbiterRouterV3.encodeEvmNativeTransferToken(route.srcToken, route.endpoint, amount, route.vc);
+        }
+    };
+    OrbiterRouterV3.encodeEvmContractTransfer = (endpoint, endpointContract, amount, str) => {
+        const data = encodeFunctionData({
+            abi: Orbiter_V3_ABI_EVM,
+            functionName: OrbiterRouterV3.Transfer,
+            args: [endpoint, toHex(str)],
+        });
+        const value = amount.toString();
+        return { data, value, to: endpointContract };
+    };
+    OrbiterRouterV3.encodeEvmContractTransferToken = (srcToken, endpoint, endpointContract, amount, str) => {
+        const data = encodeFunctionData({
+            abi: Orbiter_V3_ABI_EVM,
+            functionName: OrbiterRouterV3.TransferToken,
+            args: [srcToken, endpoint, amount, toHex(str)],
+        });
+        const value = '0';
+        return { data, value, to: endpointContract };
+    };
+    OrbiterRouterV3.encodeEvmNativeTransfer = (endpoint, amount, vc) => {
+        const data = '0x';
+        const value = parseUnits(amount, 0).toString();
+        return { data, value, to: endpoint };
+    };
+    OrbiterRouterV3.encodeEvmNativeTransferToken = (srcToken, endpoint, amount, vc) => {
+        const data = encodeFunctionData({
+            abi: ERC20_ABI,
+            functionName: 'transfer',
+            args: [endpoint, parseUnits(amount, 0)],
+        });
+        const value = '0'; // Since the value is always zero for token transfers
+        return { data, value, to: srcToken };
+    };
+})(OrbiterRouterV3 || (OrbiterRouterV3 = {}));

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

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

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

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

package/dist/configs/orbiter/config.js

@@ -0,0 +1,178 @@
+import { CrossChainBusinessException, } from '@1delta/bridge-core';
+import { SupportedChainId } from '@1delta/lib-utils';
+import { AxiosError } from 'axios';
+import { Bridge } from '../../types';
+import { bridgeIcon } from '../utils';
+import { OrbiterRouterV3 } from './calldata';
+const serverHost = 'https://api.orbiter.finance/sdk';
+const NAME = Bridge.ORBITER;
+const nativeCoinAddress = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
+const chainIdMapping = {
+    FUEL_MAIN: SupportedChainId.FUEL, //FUEL
+};
+const tokenAddressMapping = {
+    '0x0000000000000000000000000000000000000000': nativeCoinAddress, //FUEL
+};
+const errorCodes = {
+    ERROR: { code: 'ERROR', message: 'unknown error' },
+    NOT_SUPPORT: { code: 'NOT_SUPPORT', message: 'NOT SUPPORT' },
+};
+var Status;
+(function (Status) {
+    Status[Status["SUCCESS"] = 99] = "SUCCESS";
+})(Status || (Status = {}));
+export const orbiterConfig = {
+    name: NAME,
+    icon: {
+        light: bridgeIcon(NAME),
+        dark: bridgeIcon(NAME),
+    },
+    apiInterface: {
+        route: {
+            url: `${serverHost}/routers/v2`,
+            method: 'get',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Channel': 'bridge-sdk', // some Fuel routes are just returned with this header !!!
+            },
+            // 1. maps the parameters passed to route to the http request parameters
+            requestMapping: {
+                entry: 'contract',
+            },
+            before: (crossChainParamsData) => {
+                if (crossChainParamsData.fromChainId == SupportedChainId.FUEL)
+                    throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+            },
+            // 2. called directly after the request is done with response.data, response.header as parameters, to modify or aggregate data if needed
+            requestAfter: async (res, headers, crossChainParamsData) => {
+                if (res.message != 'success' ||
+                    res.status != 'success' ||
+                    res.result.length == 0)
+                    throw new CrossChainBusinessException(errorCodes.ERROR);
+                // Find all matching routes and return the one with best quote (lowest fees)
+                const bestRoute = getBestRoute(res, crossChainParamsData);
+                bestRoute.transactionData = OrbiterRouterV3.encodeTransaction(bestRoute, crossChainParamsData.fromAmount, crossChainParamsData.toAddress);
+                // const tradPair: TradePair = {
+                //   srcChainId: bestRoute.srcChain,
+                //   dstChainId: bestRoute.tgtChain,
+                //   srcTokenSymbol: bestRoute.line.split('-')[1].split('/')[0],
+                //   dstTokenSymbol: bestRoute.line.split('-')[1].split('/')[1],
+                //   routerType: bestRoute.endpointContract ? RouterType.CONTRACT : RouterType.EOA
+                // }
+                // const router = orbiter.createRouter(tradPair)
+                // const fromAmount = Number(BigInt(crossChainParamsData.fromAmount)) / Number(10 ** crossChainParamsData.fromTokenDecimals)
+                // bestRoute.transactionData = await router.createTransaction(crossChainParamsData.fromAddress, crossChainParamsData.toAddress, fromAmount.toString())
+                return bestRoute;
+            },
+            // 3. maps the results from requestAfter to our target object
+            responseMapping: {
+                name: NAME,
+                depositContract: 'endpointContract',
+                toAmount: {
+                    format: (route, { crossChainParamsData }) => {
+                        const fromAmount = BigInt(crossChainParamsData.fromAmount);
+                        const withholdingAmount = BigInt(route.withholdingFee *
+                            10 ** crossChainParamsData.fromTokenDecimals);
+                        const conversion_rate = (1 - route.tradeFee / 100) * route.compRatio;
+                        const outputAmount = ((fromAmount - withholdingAmount) *
+                            BigInt(Math.floor(conversion_rate * 1e18))) /
+                            BigInt(1e18);
+                        const decimalsDifference = crossChainParamsData.toTokenDecimals -
+                            crossChainParamsData.fromTokenDecimals;
+                        return decimalsDifference > 0
+                            ? outputAmount * 10n ** BigInt(decimalsDifference)
+                            : outputAmount / 10n ** BigInt(-decimalsDifference); // check if decimalDifference is negative, since BigInt can't support negative exponent
+                    },
+                },
+                fee: {},
+                estimatedDuration: 'spentTime',
+                transactionData: {
+                    data: 'transactionData.data',
+                    value: 'transactionData.value',
+                    to: 'transactionData.to',
+                },
+                interfaceParamData: {
+                    format: (route, { crossChainParamsData }) => {
+                        return route;
+                    },
+                },
+            },
+        },
+        status: {
+            url: `${serverHost}/transaction/status/:hash`,
+            pathParams: {
+                hash: 'fromHash',
+            },
+            method: 'get',
+            headers: {},
+            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;
+            },
+            requestAfter: (res) => {
+                return res;
+            },
+            requestMapping: {},
+            responseMapping: {
+                toHash: 'result.targetId',
+                statusInfo: {
+                    format: (result) => {
+                        const data = {
+                            status: 'PENDING',
+                            bridgeResponseResult: result.result,
+                        };
+                        if (result.result.opStatus == Status.SUCCESS) {
+                            data.status = 'DONE';
+                        }
+                        return data;
+                    },
+                },
+            },
+        },
+    },
+    errorCodes,
+};
+const getBestRoute = (routes, crossChainParamsData) => {
+    const fromAmount = Number(BigInt(crossChainParamsData.fromAmount)) /
+        Number(10 ** crossChainParamsData.fromTokenDecimals);
+    const matchingRoutes = routes.result.filter((route) => (route.srcChain == crossChainParamsData.fromChainId ||
+        chainIdMapping[route.srcChain] == crossChainParamsData.fromChainId) &&
+        (route.tgtChain == crossChainParamsData.toChainId ||
+            chainIdMapping[route.tgtChain] == crossChainParamsData.toChainId) &&
+        (route.srcToken.toLowerCase() ===
+            crossChainParamsData.fromTokenAddress.toLowerCase() ||
+            tokenAddressMapping[route.srcToken] ===
+                crossChainParamsData.fromTokenAddress) &&
+        (route.tgtToken.toLowerCase() ===
+            crossChainParamsData.toTokenAddress.toLowerCase() ||
+            tokenAddressMapping[route.tgtToken] ===
+                crossChainParamsData.toTokenAddress) &&
+        fromAmount >= Number(route.minAmt) &&
+        fromAmount <= Number(route.maxAmt));
+    if (matchingRoutes.length === 0)
+        throw new CrossChainBusinessException(errorCodes.NOT_SUPPORT);
+    // Return route with lowest total fees
+    const bestRoute = matchingRoutes.reduce((bestRoute, currentRoute) => {
+        const bestTotalFee = (1 - Number(bestRoute.tradeFee)) * fromAmount +
+            Number(bestRoute.withholdingFee);
+        const currentTotalFee = (1 - Number(currentRoute.tradeFee)) * fromAmount +
+            Number(currentRoute.withholdingFee);
+        return currentTotalFee < bestTotalFee ? currentRoute : bestRoute;
+    });
+    return bestRoute;
+};
+export default orbiterConfig;

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

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

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

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