@synthra-swap/smart-order-router 3.16.0 → 3.16.2

package/build/main/routers/synthra-router/synthra-router.js

@@ -0,0 +1,443 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SynthraRouter = void 0;
+const abi_1 = require("@ethersproject/abi");
+const address_1 = require("@ethersproject/address");
+const bignumber_1 = require("@ethersproject/bignumber");
+const bytes_1 = require("@ethersproject/bytes");
+const core_1 = require("@synthra-swap/sdk/core");
+const universal_router_1 = require("@synthra-swap/sdk/universal-router");
+const jsbi_1 = __importDefault(require("jsbi"));
+const amounts_1 = require("../../util/amounts");
+const alpha_router_1 = require("../alpha-router");
+const router_1 = require("../router");
+const config_1 = require("./config");
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
+const UNIVERSAL_ROUTER_MSG_SENDER = '0x0000000000000000000000000000000000000001';
+const UNIVERSAL_ROUTER_ADDRESS_THIS = '0x0000000000000000000000000000000000000002';
+const UNIVERSAL_ROUTER_COMMAND_TYPE_MASK = 0x1f;
+const UNIVERSAL_ROUTER_COMMAND_V3_SWAP_EXACT_IN = 0x00;
+const UNIVERSAL_ROUTER_COMMAND_SWEEP = 0x04;
+const DEFAULT_SLIPPAGE = new core_1.Percent(50, 10000);
+const UNIVERSAL_ROUTER_INTERFACE = new abi_1.Interface([
+    'function execute(bytes commands, bytes[] inputs, uint256 deadline)',
+]);
+class SynthraRouter {
+    constructor(params) {
+        var _a, _b;
+        this.params = params;
+        this.alphaRouters = new Map();
+        this.cctp = Object.assign(Object.assign(Object.assign({}, config_1.DEFAULT_CCTP_ROUTER_CONFIG), params.cctp), { chains: Object.assign(Object.assign({}, config_1.DEFAULT_CCTP_ROUTER_CONFIG.chains), ((_b = (_a = params.cctp) === null || _a === void 0 ? void 0 : _a.chains) !== null && _b !== void 0 ? _b : {})) });
+    }
+    async route(request) {
+        var _a, _b;
+        const sourceChainId = (_a = request.sourceChainId) !== null && _a !== void 0 ? _a : request.amount.currency.wrapped.chainId;
+        const destinationChainId = this.resolveDestinationChainId(request);
+        const mode = (_b = request.mode) !== null && _b !== void 0 ? _b : 'auto';
+        if (mode !== 'cctp' && destinationChainId === sourceChainId) {
+            return this.routeSameChain(request, sourceChainId);
+        }
+        if (mode === 'same-chain') {
+            return null;
+        }
+        if (destinationChainId !== undefined) {
+            return this.routeCCTP(request, sourceChainId, destinationChainId);
+        }
+        return (await this.routeBestVenue(request, sourceChainId)).selected;
+    }
+    async routeBestVenue(request, sourceChainId) {
+        var _a, _b, _c, _d, _e;
+        if (sourceChainId === void 0) { sourceChainId = (_a = request.sourceChainId) !== null && _a !== void 0 ? _a : request.amount.currency.wrapped.chainId; }
+        const destinationChainCandidates = (_c = (_b = request.destinationChainCandidates) !== null && _b !== void 0 ? _b : this.cctp.defaultDestinationChainCandidates) !== null && _c !== void 0 ? _c : [];
+        const candidates = await Promise.all(destinationChainCandidates.map(async (destinationChainId) => this.routeBestVenueCandidate(request, sourceChainId, destinationChainId)));
+        const routable = candidates.filter((candidate) => candidate.route !== null);
+        routable.sort((a, b) => this.compareQuotes(b.route, a.route));
+        return {
+            selected: (_e = (_d = routable[0]) === null || _d === void 0 ? void 0 : _d.route) !== null && _e !== void 0 ? _e : null,
+            candidates,
+        };
+    }
+    async routeBestVenueCandidate(request, sourceChainId, destinationChainId) {
+        const tokenOut = this.resolveTokenOut(request.tokenOut, destinationChainId);
+        if (!tokenOut) {
+            return {
+                destinationChainId,
+                route: null,
+                rejectionReason: 'token-out-not-configured-for-chain',
+            };
+        }
+        try {
+            return {
+                destinationChainId,
+                tokenOut,
+                route: await this.routeCCTP(Object.assign(Object.assign({}, request), { tokenOut }), sourceChainId, destinationChainId),
+            };
+        }
+        catch (error) {
+            return {
+                destinationChainId,
+                tokenOut,
+                route: null,
+                rejectionReason: error instanceof Error ? error.message : 'unknown-error',
+            };
+        }
+    }
+    async routeSameChain(request, chainId) {
+        var _a;
+        const tokenOut = this.resolveTokenOut(request.tokenOut, chainId);
+        if (!tokenOut)
+            return null;
+        const route = await this.getAlphaRouter(chainId).route(request.amount, tokenOut, request.tradeType, request.swapOptions, (_a = request.routingConfigByChainId) === null || _a === void 0 ? void 0 : _a[chainId]);
+        if (!route)
+            return null;
+        return {
+            kind: 'same-chain',
+            sourceChainId: chainId,
+            destinationChainId: chainId,
+            tokenIn: request.amount.currency,
+            tokenOut,
+            amountIn: request.amount,
+            amountOut: route.quote,
+            route,
+            methodParameters: route.methodParameters,
+        };
+    }
+    async routeCCTP(request, sourceChainId, destinationChainId) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        if (request.tradeType !== core_1.TradeType.EXACT_INPUT) {
+            throw new Error('CCTP routing currently supports EXACT_INPUT only');
+        }
+        if (!request.recipient) {
+            throw new Error('recipient is required for CCTP routing');
+        }
+        const sourceConfig = this.getCCTPChainConfig(sourceChainId);
+        const destinationConfig = this.getCCTPChainConfig(destinationChainId);
+        const tokenOut = this.resolveTokenOut(request.tokenOut, destinationChainId);
+        if (!tokenOut)
+            return null;
+        const sourceLeg = await this.routeLocalOrNoOp(sourceChainId, request.amount, sourceConfig.bridgeToken, (_a = request.sourceSwapOptions) !== null && _a !== void 0 ? _a : this.defaultUniversalRouterSwapOptions(sourceConfig.cctpRouter, request.slippageTolerance, request.deadline), (_b = request.routingConfigByChainId) === null || _b === void 0 ? void 0 : _b[sourceChainId]);
+        if (!sourceLeg)
+            return null;
+        const feeAmount = bignumber_1.BigNumber.from((_d = (_c = request.feeAmount) !== null && _c !== void 0 ? _c : this.cctp.feeAmount) !== null && _d !== void 0 ? _d : 0);
+        const cctpMaxFee = bignumber_1.BigNumber.from((_f = (_e = request.maxFee) !== null && _e !== void 0 ? _e : this.cctp.defaultMaxFee) !== null && _f !== void 0 ? _f : 0);
+        const bridgeAmountRaw = bignumber_1.BigNumber.from(sourceLeg.amountOut.quotient.toString());
+        const totalFeeReserve = feeAmount.add(cctpMaxFee);
+        if (totalFeeReserve.gte(bridgeAmountRaw)) {
+            throw new Error('CCTP fee reserve is greater than or equal to bridge amount');
+        }
+        const destinationInputAmount = amounts_1.CurrencyAmount.fromRawAmount(destinationConfig.bridgeToken, bridgeAmountRaw.sub(totalFeeReserve).toString());
+        const destinationLeg = await this.routeLocalOrNoOp(destinationChainId, destinationInputAmount, tokenOut, (_g = request.destinationSwapOptions) !== null && _g !== void 0 ? _g : this.defaultUniversalRouterSwapOptions(request.recipient, request.slippageTolerance, request.deadline, true), (_h = request.routingConfigByChainId) === null || _h === void 0 ? void 0 : _h[destinationChainId]);
+        if (!destinationLeg)
+            return null;
+        const bridgeLeg = {
+            kind: 'cctp',
+            sourceChainId,
+            destinationChainId,
+            sourceDomain: sourceConfig.cctpDomain,
+            destinationDomain: destinationConfig.cctpDomain,
+            sourceBridgeToken: sourceConfig.bridgeToken,
+            destinationBridgeToken: destinationConfig.bridgeToken,
+            bridgeAmount: sourceLeg.amountOut,
+            destinationInputAmount,
+            maxFee: cctpMaxFee.toString(),
+            minFinalityThreshold: (_k = (_j = request.minFinalityThreshold) !== null && _j !== void 0 ? _j : this.cctp.defaultMinFinalityThreshold) !== null && _k !== void 0 ? _k : 1000,
+            feeRecipient: (_l = request.feeRecipient) !== null && _l !== void 0 ? _l : this.cctp.feeRecipient,
+            feeAmount: feeAmount.toString(),
+        };
+        return {
+            kind: 'cctp-cross-chain',
+            sourceChainId,
+            destinationChainId,
+            tokenIn: request.amount.currency,
+            tokenOut,
+            amountIn: request.amount,
+            amountOut: destinationLeg.amountOut,
+            quoteGasAdjusted: destinationLeg.amountOut,
+            estimatedGasUsed: this.sumGas(sourceLeg, destinationLeg),
+            sourceLeg,
+            bridgeLeg,
+            destinationLeg,
+            execution: this.buildCCTPExecutionPlan({
+                sourceConfig,
+                destinationConfig,
+                sourceLeg,
+                destinationLeg,
+                bridgeLeg,
+                request,
+                tokenOut,
+            }),
+        };
+    }
+    async routeLocalOrNoOp(chainId, amount, tokenOut, swapOptions, routingConfig) {
+        const tokenIn = amount.currency.wrapped;
+        if (tokenIn.equals(tokenOut)) {
+            const amountOut = amounts_1.CurrencyAmount.fromRawAmount(tokenOut, amount.quotient.toString());
+            return {
+                kind: 'no-op',
+                chainId,
+                tokenIn,
+                tokenOut,
+                amountIn: amount,
+                amountOut,
+            };
+        }
+        const route = await this.getAlphaRouter(chainId).route(amount, tokenOut, core_1.TradeType.EXACT_INPUT, swapOptions, routingConfig);
+        if (!route)
+            return null;
+        return {
+            kind: 'local-swap',
+            chainId,
+            route,
+            amountIn: amount,
+            amountOut: route.quote,
+            methodParameters: route.methodParameters,
+        };
+    }
+    buildCCTPExecutionPlan({ sourceConfig, destinationConfig, sourceLeg, destinationLeg, bridgeLeg, request, tokenOut, }) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        if (!request.recipient) {
+            throw new Error('recipient is required for CCTP execution');
+        }
+        const sourceUniversalRouter = (_a = sourceConfig.universalRouter) !== null && _a !== void 0 ? _a : (0, universal_router_1.UNIVERSAL_ROUTER_ADDRESS)(sourceConfig.chainId);
+        const destinationUniversalRouter = (_b = destinationConfig.universalRouter) !== null && _b !== void 0 ? _b : (0, universal_router_1.UNIVERSAL_ROUTER_ADDRESS)(destinationConfig.chainId);
+        const feeRecipient = (_d = (_c = request.feeRecipient) !== null && _c !== void 0 ? _c : this.cctp.feeRecipient) !== null && _d !== void 0 ? _d : ZERO_ADDRESS;
+        const quoteDeadline = String((_e = request.quoteDeadline) !== null && _e !== void 0 ? _e : Math.floor(Date.now() / 1000) +
+            ((_f = this.cctp.defaultQuoteTtlSeconds) !== null && _f !== void 0 ? _f : 300));
+        const sourceSwap = sourceLeg.kind === 'local-swap' ? sourceLeg.methodParameters : undefined;
+        const destinationSwap = destinationLeg.kind === 'local-swap'
+            ? destinationLeg.methodParameters
+            : undefined;
+        const decodedSourceSwap = this.decodeUniversalRouterCall(sourceSwap);
+        const decodedDestinationSwap = this.decodeUniversalRouterCall(destinationSwap);
+        const sourceBridgeCall = this.rewriteSourceBridgeSwapForNativeSweep(decodedSourceSwap, sourceConfig, bridgeLeg);
+        const destinationMinTokenOut = this.destinationMinTokenOut(decodedDestinationSwap, sourceBridgeCall.minBridgeAmount, destinationLeg, bridgeLeg, tokenOut, destinationConfig);
+        const sourceQuote = {
+            tokenIn: request.amount.currency.wrapped.address,
+            amountIn: request.amount.quotient.toString(),
+            sourceUsdc: sourceConfig.bridgeToken.address,
+            minBridgeAmount: sourceBridgeCall.minBridgeAmount,
+            destinationDomain: destinationConfig.cctpDomain,
+            mintRecipient: this.addressToBytes32(destinationConfig.cctpRouter),
+            destinationCaller: this.addressToBytes32(destinationConfig.cctpRouter),
+            maxFee: bridgeLeg.maxFee,
+            minFinalityThreshold: bridgeLeg.minFinalityThreshold,
+            recipient: request.recipient,
+            destinationBridgeToken: destinationConfig.bridgeToken.address,
+            tokenOut: tokenOut.address,
+            minTokenOut: destinationMinTokenOut,
+            feeRecipient,
+            feeAmount: bridgeLeg.feeAmount,
+            universalRouter: sourceUniversalRouter,
+            quoteDeadline,
+        };
+        return {
+            sourceRouter: sourceConfig.cctpRouter,
+            destinationRouter: destinationConfig.cctpRouter,
+            sourceUniversalRouter,
+            destinationUniversalRouter,
+            sourceSwap,
+            destinationSwap,
+            sourceRouterCommands: (_g = sourceBridgeCall.call) === null || _g === void 0 ? void 0 : _g.commands,
+            sourceRouterInputs: (_h = sourceBridgeCall.call) === null || _h === void 0 ? void 0 : _h.inputs,
+            sourceRouterDeadline: (_j = sourceBridgeCall.call) === null || _j === void 0 ? void 0 : _j.deadline,
+            destinationRouterCommands: decodedDestinationSwap === null || decodedDestinationSwap === void 0 ? void 0 : decodedDestinationSwap.commands,
+            destinationRouterInputs: decodedDestinationSwap === null || decodedDestinationSwap === void 0 ? void 0 : decodedDestinationSwap.inputs,
+            destinationRouterDeadline: decodedDestinationSwap === null || decodedDestinationSwap === void 0 ? void 0 : decodedDestinationSwap.deadline,
+            sourceQuote,
+        };
+    }
+    resolveDestinationChainId(request) {
+        if (request.destinationChainId !== undefined)
+            return request.destinationChainId;
+        if (this.isTokenByChainId(request.tokenOut))
+            return undefined;
+        return request.tokenOut.wrapped.chainId;
+    }
+    resolveTokenOut(tokenOut, chainId) {
+        if (this.isTokenByChainId(tokenOut))
+            return tokenOut[chainId];
+        const wrapped = tokenOut.wrapped;
+        return wrapped.chainId === chainId ? wrapped : undefined;
+    }
+    isTokenByChainId(tokenOut) {
+        return tokenOut.wrapped === undefined;
+    }
+    getAlphaRouter(chainId) {
+        var _a, _b, _c, _d, _e;
+        const cached = this.alphaRouters.get(chainId);
+        if (cached)
+            return cached;
+        const provider = this.params.providersByChainId[chainId];
+        if (!provider) {
+            throw new Error(`No provider configured for chain ${chainId}`);
+        }
+        const alphaRouterParams = (_b = (_a = this.params.alphaRouterParamsByChainId) === null || _a === void 0 ? void 0 : _a[chainId]) !== null && _b !== void 0 ? _b : {};
+        const router = (_e = (_d = (_c = this.params).alphaRouterFactory) === null || _d === void 0 ? void 0 : _d.call(_c, Object.assign(Object.assign({}, alphaRouterParams), { chainId,
+            provider }))) !== null && _e !== void 0 ? _e : new alpha_router_1.AlphaRouter(Object.assign(Object.assign({}, alphaRouterParams), { chainId,
+            provider }));
+        this.alphaRouters.set(chainId, router);
+        return router;
+    }
+    getCCTPChainConfig(chainId) {
+        const config = this.cctp.chains[chainId];
+        if (!config) {
+            throw new Error(`No CCTP router config for chain ${chainId}`);
+        }
+        return config;
+    }
+    defaultUniversalRouterSwapOptions(recipient, slippageTolerance = DEFAULT_SLIPPAGE, deadline, useRouterBalance = false) {
+        return {
+            type: router_1.SwapType.UNIVERSAL_ROUTER,
+            recipient,
+            slippageTolerance,
+            deadlineOrPreviousBlockhash: deadline !== null && deadline !== void 0 ? deadline : Math.floor(Date.now() / 1000) + 1200,
+            useRouterBalance,
+        };
+    }
+    decodeUniversalRouterCall(methodParameters) {
+        if (!methodParameters)
+            return undefined;
+        const decoded = UNIVERSAL_ROUTER_INTERFACE.decodeFunctionData('execute', methodParameters.calldata);
+        return {
+            commands: decoded.commands,
+            inputs: decoded.inputs,
+            deadline: decoded.deadline.toString(),
+        };
+    }
+    rewriteSourceBridgeSwapForNativeSweep(call, sourceConfig, bridgeLeg) {
+        var _a;
+        const quotedBridgeAmount = bridgeLeg.bridgeAmount.quotient.toString();
+        if (!call || !this.shouldSweepSourceBridgeOutput(sourceConfig)) {
+            return {
+                call,
+                minBridgeAmount: (_a = this.sourceBridgeMinAmount(call)) !== null && _a !== void 0 ? _a : quotedBridgeAmount,
+            };
+        }
+        const commandBytes = this.hexToCommandBytes(call.commands);
+        const inputs = [...call.inputs];
+        let rewroteV3ExactIn = false;
+        let minBridgeAmount = quotedBridgeAmount;
+        for (let i = 0; i < commandBytes.length; i++) {
+            const commandByte = commandBytes[i];
+            if (commandByte === undefined) {
+                throw new Error('Universal Router command byte is missing');
+            }
+            const command = commandByte & UNIVERSAL_ROUTER_COMMAND_TYPE_MASK;
+            if (command !== UNIVERSAL_ROUTER_COMMAND_V3_SWAP_EXACT_IN)
+                continue;
+            const input = inputs[i];
+            if (input === undefined) {
+                throw new Error('Universal Router input is missing');
+            }
+            const decoded = abi_1.defaultAbiCoder.decode(['address', 'uint256', 'uint256', 'bytes', 'bool'], input);
+            inputs[i] = abi_1.defaultAbiCoder.encode(['address', 'uint256', 'uint256', 'bytes', 'bool'], [
+                UNIVERSAL_ROUTER_ADDRESS_THIS,
+                decoded[1],
+                decoded[2],
+                decoded[3],
+                decoded[4],
+            ]);
+            minBridgeAmount = decoded[2].toString();
+            rewroteV3ExactIn = true;
+        }
+        if (!rewroteV3ExactIn) {
+            return {
+                call,
+                minBridgeAmount,
+            };
+        }
+        commandBytes.push(UNIVERSAL_ROUTER_COMMAND_SWEEP);
+        inputs.push(abi_1.defaultAbiCoder.encode(['address', 'address', 'uint256'], [
+            sourceConfig.bridgeToken.address,
+            UNIVERSAL_ROUTER_MSG_SENDER,
+            minBridgeAmount,
+        ]));
+        return {
+            call: Object.assign(Object.assign({}, call), { commands: this.commandBytesToHex(commandBytes), inputs }),
+            minBridgeAmount,
+        };
+    }
+    sourceBridgeMinAmount(call) {
+        if (!call)
+            return undefined;
+        const commandBytes = this.hexToCommandBytes(call.commands);
+        for (let i = commandBytes.length - 1; i >= 0; i--) {
+            const commandByte = commandBytes[i];
+            if (commandByte === undefined)
+                continue;
+            const command = commandByte & UNIVERSAL_ROUTER_COMMAND_TYPE_MASK;
+            if (command !== UNIVERSAL_ROUTER_COMMAND_V3_SWAP_EXACT_IN)
+                continue;
+            const input = call.inputs[i];
+            if (input === undefined)
+                continue;
+            const decoded = abi_1.defaultAbiCoder.decode(['address', 'uint256', 'uint256', 'bytes', 'bool'], input);
+            return decoded[2].toString();
+        }
+        return undefined;
+    }
+    destinationMinTokenOut(destinationCall, sourceMinBridgeAmount, destinationLeg, bridgeLeg, tokenOut, destinationConfig) {
+        var _a;
+        if (destinationLeg.kind === 'no-op' &&
+            tokenOut.equals(destinationConfig.bridgeToken)) {
+            // The recipient receives minBridgeAmount minus BOTH the CCTP fee
+            // (maxFee, withheld in transit) and the service feeAmount. Subtracting only
+            // feeAmount leaves minTokenOut too high, so a fast transfer (where CCTP
+            // charges a non-zero fee) reverts on-chain with InsufficientDestinationOutput.
+            const minBridgeAfterFee = bignumber_1.BigNumber.from(sourceMinBridgeAmount)
+                .sub(bridgeLeg.feeAmount)
+                .sub(bridgeLeg.maxFee);
+            if (minBridgeAfterFee.lt(0)) {
+                throw new Error('CCTP fee amount is greater than source bridge minimum');
+            }
+            return minBridgeAfterFee.toString();
+        }
+        return ((_a = this.sourceBridgeMinAmount(destinationCall)) !== null && _a !== void 0 ? _a : destinationLeg.amountOut.quotient.toString());
+    }
+    shouldSweepSourceBridgeOutput(sourceConfig) {
+        return (sourceConfig.chainId === core_1.ChainId.ARC &&
+            sourceConfig.bridgeToken.address.toLowerCase() ===
+                '0x3600000000000000000000000000000000000000');
+    }
+    hexToCommandBytes(commands) {
+        const hex = commands.startsWith('0x') ? commands.slice(2) : commands;
+        if (hex.length % 2 !== 0) {
+            throw new Error('Universal Router commands must be valid bytes');
+        }
+        const bytes = [];
+        for (let i = 0; i < hex.length; i += 2) {
+            bytes.push(parseInt(hex.slice(i, i + 2), 16));
+        }
+        return bytes;
+    }
+    commandBytesToHex(bytes) {
+        return `0x${bytes
+            .map((byte) => byte.toString(16).padStart(2, '0'))
+            .join('')}`;
+    }
+    compareQuotes(a, b) {
+        if (jsbi_1.default.greaterThan(a.quoteGasAdjusted.quotient, b.quoteGasAdjusted.quotient)) {
+            return 1;
+        }
+        if (jsbi_1.default.lessThan(a.quoteGasAdjusted.quotient, b.quoteGasAdjusted.quotient)) {
+            return -1;
+        }
+        return 0;
+    }
+    sumGas(sourceLeg, destinationLeg) {
+        return this.legGas(sourceLeg).add(this.legGas(destinationLeg));
+    }
+    legGas(leg) {
+        return leg.kind === 'local-swap'
+            ? leg.route.estimatedGasUsed
+            : bignumber_1.BigNumber.from(0);
+    }
+    addressToBytes32(address) {
+        return (0, bytes_1.hexZeroPad)((0, address_1.getAddress)(address), 32);
+    }
+}
+exports.SynthraRouter = SynthraRouter;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"synthra-router.js","sourceRoot":"","sources":["../../../../src/routers/synthra-router/synthra-router.ts"],"names":[],"mappings":"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"}

package/build/main/routers/synthra-router/types.d.ts

@@ -0,0 +1,158 @@
+import { BigNumber, BigNumberish } from '@ethersproject/bignumber';
+import { BaseProvider } from '@ethersproject/providers';
+import { ChainId, Currency, Percent, Token, TradeType } from '@synthra-swap/sdk/core';
+import { CurrencyAmount } from '../../util/amounts';
+import { AlphaRouter, AlphaRouterConfig, AlphaRouterParams } from '../alpha-router';
+import { MethodParameters, SwapOptions, SwapRoute } from '../router';
+export declare type SynthraRouteMode = 'auto' | 'same-chain' | 'cctp';
+export declare type TokenByChainId = Record<number, Token>;
+export declare type SynthraRouterProviderMap = Partial<Record<ChainId, BaseProvider>> & Record<number, BaseProvider | undefined>;
+export declare type SynthraRouterAlphaParams = Omit<AlphaRouterParams, 'chainId' | 'provider'>;
+export declare type SynthraRouterAlphaParamsByChainId = Partial<Record<ChainId, SynthraRouterAlphaParams>> & Record<number, SynthraRouterAlphaParams | undefined>;
+export declare type CCTPRouterChainConfig = {
+    chainId: ChainId;
+    cctpDomain: number;
+    cctpRouter: string;
+    bridgeToken: Token;
+    universalRouter?: string;
+};
+export declare type CCTPRouterConfig = {
+    chains: Partial<Record<ChainId, CCTPRouterChainConfig>> & Record<number, CCTPRouterChainConfig | undefined>;
+    defaultDestinationChainCandidates?: ChainId[];
+    defaultMaxFee?: BigNumberish;
+    defaultMinFinalityThreshold?: number;
+    defaultQuoteTtlSeconds?: number;
+    feeRecipient?: string;
+    feeAmount?: BigNumberish;
+};
+export declare type SynthraRouterParams = {
+    providersByChainId: SynthraRouterProviderMap;
+    alphaRouterParamsByChainId?: SynthraRouterAlphaParamsByChainId;
+    alphaRouterFactory?: (params: AlphaRouterParams) => AlphaRouter;
+    cctp?: CCTPRouterConfig;
+};
+export declare type SynthraRouteRequest = {
+    amount: CurrencyAmount;
+    tokenOut: Currency | TokenByChainId;
+    tradeType: TradeType;
+    sourceChainId?: ChainId;
+    destinationChainId?: ChainId;
+    destinationChainCandidates?: ChainId[];
+    recipient?: string;
+    mode?: SynthraRouteMode;
+    swapOptions?: SwapOptions;
+    sourceSwapOptions?: SwapOptions;
+    destinationSwapOptions?: SwapOptions;
+    routingConfigByChainId?: Partial<Record<ChainId, Partial<AlphaRouterConfig>>> & Record<number, Partial<AlphaRouterConfig> | undefined>;
+    slippageTolerance?: Percent;
+    deadline?: number;
+    quoteDeadline?: number;
+    maxFee?: BigNumberish;
+    minFinalityThreshold?: number;
+    feeRecipient?: string;
+    feeAmount?: BigNumberish;
+};
+export declare type SynthraNoOpRoute = {
+    kind: 'no-op';
+    chainId: ChainId;
+    tokenIn: Token;
+    tokenOut: Token;
+    amountIn: CurrencyAmount;
+    amountOut: CurrencyAmount;
+};
+export declare type SynthraLocalRoute = {
+    kind: 'local-swap';
+    chainId: ChainId;
+    route: SwapRoute;
+    amountIn: CurrencyAmount;
+    amountOut: CurrencyAmount;
+    methodParameters?: MethodParameters;
+};
+export declare type SynthraRouteLeg = SynthraNoOpRoute | SynthraLocalRoute;
+export declare type SameChainSynthraRoute = {
+    kind: 'same-chain';
+    sourceChainId: ChainId;
+    destinationChainId: ChainId;
+    tokenIn: Currency;
+    tokenOut: Currency;
+    amountIn: CurrencyAmount;
+    amountOut: CurrencyAmount;
+    route: SwapRoute;
+    methodParameters?: MethodParameters;
+};
+export declare type CCTPBridgeLeg = {
+    kind: 'cctp';
+    sourceChainId: ChainId;
+    destinationChainId: ChainId;
+    sourceDomain?: number;
+    destinationDomain: number;
+    sourceBridgeToken: Token;
+    destinationBridgeToken: Token;
+    bridgeAmount: CurrencyAmount;
+    destinationInputAmount: CurrencyAmount;
+    maxFee: string;
+    minFinalityThreshold: number;
+    feeRecipient?: string;
+    feeAmount: string;
+};
+export declare type CCTPSourceQuoteDraft = {
+    intentHash?: string;
+    tokenIn: string;
+    amountIn: string;
+    sourceUsdc: string;
+    minBridgeAmount: string;
+    destinationDomain: number;
+    mintRecipient: string;
+    destinationCaller: string;
+    maxFee: string;
+    minFinalityThreshold: number;
+    recipient: string;
+    destinationBridgeToken: string;
+    tokenOut: string;
+    minTokenOut: string;
+    feeRecipient: string;
+    feeAmount: string;
+    universalRouter: string;
+    quoteDeadline: string;
+};
+export declare type CCTPExecutionPlan = {
+    sourceRouter: string;
+    destinationRouter: string;
+    sourceUniversalRouter: string;
+    destinationUniversalRouter: string;
+    sourceSwap?: MethodParameters;
+    destinationSwap?: MethodParameters;
+    sourceRouterCommands?: string;
+    sourceRouterInputs?: string[];
+    sourceRouterDeadline?: string;
+    destinationRouterCommands?: string;
+    destinationRouterInputs?: string[];
+    destinationRouterDeadline?: string;
+    sourceQuote: CCTPSourceQuoteDraft;
+};
+export declare type CCTPSynthraRoute = {
+    kind: 'cctp-cross-chain';
+    sourceChainId: ChainId;
+    destinationChainId: ChainId;
+    tokenIn: Currency;
+    tokenOut: Token;
+    amountIn: CurrencyAmount;
+    amountOut: CurrencyAmount;
+    quoteGasAdjusted: CurrencyAmount;
+    estimatedGasUsed: BigNumber;
+    sourceLeg: SynthraRouteLeg;
+    bridgeLeg: CCTPBridgeLeg;
+    destinationLeg: SynthraRouteLeg;
+    execution: CCTPExecutionPlan;
+};
+export declare type SynthraRoute = SameChainSynthraRoute | CCTPSynthraRoute;
+export declare type BestVenueCandidate = {
+    destinationChainId: ChainId;
+    tokenOut?: Token;
+    route: CCTPSynthraRoute | null;
+    rejectionReason?: string;
+};
+export declare type BestVenueResult = {
+    selected: CCTPSynthraRoute | null;
+    candidates: BestVenueCandidate[];
+};

package/build/main/routers/synthra-router/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcm91dGVycy9zeW50aHJhLXJvdXRlci90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=