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

package/build/module/providers/v3/pool-provider.js

@@ -1,3 +1,4 @@
+import { ChainId } from '@synthra-swap/sdk/core';
 import { computePoolAddress, Pool } from '@synthra-swap/sdk/v3';
 import retry from 'async-retry';
 import _ from 'lodash';
@@ -5,6 +6,13 @@ import { ISynthraV3PoolState__factory } from '../../types/v3/factories/ISynthraV
 import { V3_CORE_FACTORY_ADDRESSES } from '../../util/addresses';
 import { log } from '../../util/log';
 import { poolToString } from '../../util/routes';
+const UNISWAP_V3_POOL_INIT_CODE_HASH = '0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54';
+function getPoolInitCodeHashManualOverride(chainId) {
+    if (chainId === ChainId.SEPOLIA) {
+        return UNISWAP_V3_POOL_INIT_CODE_HASH;
+    }
+    return undefined;
+}
 export class V3PoolProvider {
     /**
      * Creates an instance of V3PoolProvider.
@@ -96,7 +104,7 @@ export class V3PoolProvider {
             tokenA: token0,
             tokenB: token1,
             fee: feeAmount,
-            initCodeHashManualOverride: '0x499aba1e2f07d97749c4eabd822eca2efa521b1d6e34a67285e4a3cb773905dd',
+            initCodeHashManualOverride: getPoolInitCodeHashManualOverride(this.chainId),
         });
         this.POOL_ADDRESS_CACHE[cacheKey] = poolAddress;
         return { poolAddress, token0, token1 };
@@ -114,4 +122,4 @@ export class V3PoolProvider {
         return results;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/routers/index.d.ts

@@ -1,3 +1,4 @@
 export * from '../util/metric';
 export * from './alpha-router';
 export * from './router';
+export * from './synthra-router';

package/build/module/routers/index.js

@@ -1,4 +1,5 @@
 export * from '../util/metric';
 export * from './alpha-router';
 export * from './router';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcm91dGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUMifQ==
+export * from './synthra-router';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvcm91dGVycy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxrQkFBa0IsQ0FBQyJ9

package/build/module/routers/synthra-router/config.d.ts

@@ -0,0 +1,5 @@
+import { Token } from '@synthra-swap/sdk/core';
+import { CCTPRouterConfig } from './types';
+export declare const ARC_TESTNET_USDC: Token;
+export declare const SEPOLIA_USDC: Token;
+export declare const DEFAULT_CCTP_ROUTER_CONFIG: CCTPRouterConfig;

package/build/module/routers/synthra-router/config.js

@@ -0,0 +1,27 @@
+import { ChainId, Token } from '@synthra-swap/sdk/core';
+export const ARC_TESTNET_USDC = new Token(ChainId.ARC, '0x3600000000000000000000000000000000000000', 6, 'USDC', 'USDC');
+export const SEPOLIA_USDC = new Token(ChainId.SEPOLIA, '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238', 6, 'USDC', 'USDC');
+export const DEFAULT_CCTP_ROUTER_CONFIG = {
+    chains: {
+        [ChainId.ARC]: {
+            chainId: ChainId.ARC,
+            cctpDomain: 26,
+            cctpRouter: '0x195ee789dE3d3edde5Bcd830d9eF2C9e4f39715F',
+            bridgeToken: ARC_TESTNET_USDC,
+            universalRouter: '0xbf4479C07Dc6fdc6dAa764A0ccA06969e894275F',
+        },
+        [ChainId.SEPOLIA]: {
+            chainId: ChainId.SEPOLIA,
+            cctpDomain: 0,
+            cctpRouter: '0xD97D43631741e20811ebd8A3aD6265759909f0Ff',
+            bridgeToken: SEPOLIA_USDC,
+            universalRouter: '0x3fC91A3afd70395Cd496C647d5a6CC9D4B2b7FAD',
+        },
+    },
+    defaultDestinationChainCandidates: [ChainId.ARC, ChainId.SEPOLIA],
+    defaultMaxFee: '10000',
+    defaultMinFinalityThreshold: 1000,
+    defaultQuoteTtlSeconds: 300,
+    feeAmount: '0',
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3JvdXRlcnMvc3ludGhyYS1yb3V0ZXIvY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sd0JBQXdCLENBQUM7QUFJeEQsTUFBTSxDQUFDLE1BQU0sZ0JBQWdCLEdBQUcsSUFBSSxLQUFLLENBQ3ZDLE9BQU8sQ0FBQyxHQUFHLEVBQ1gsNENBQTRDLEVBQzVDLENBQUMsRUFDRCxNQUFNLEVBQ04sTUFBTSxDQUNQLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsSUFBSSxLQUFLLENBQ25DLE9BQU8sQ0FBQyxPQUFPLEVBQ2YsNENBQTRDLEVBQzVDLENBQUMsRUFDRCxNQUFNLEVBQ04sTUFBTSxDQUNQLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSwwQkFBMEIsR0FBcUI7SUFDMUQsTUFBTSxFQUFFO1FBQ04sQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUU7WUFDYixPQUFPLEVBQUUsT0FBTyxDQUFDLEdBQUc7WUFDcEIsVUFBVSxFQUFFLEVBQUU7WUFDZCxVQUFVLEVBQUUsNENBQTRDO1lBQ3hELFdBQVcsRUFBRSxnQkFBZ0I7WUFDN0IsZUFBZSxFQUFFLDRDQUE0QztTQUM5RDtRQUNELENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFO1lBQ2pCLE9BQU8sRUFBRSxPQUFPLENBQUMsT0FBTztZQUN4QixVQUFVLEVBQUUsQ0FBQztZQUNiLFVBQVUsRUFBRSw0Q0FBNEM7WUFDeEQsV0FBVyxFQUFFLFlBQVk7WUFDekIsZUFBZSxFQUFFLDRDQUE0QztTQUM5RDtLQUNGO0lBQ0QsaUNBQWlDLEVBQUUsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxPQUFPLENBQUM7SUFDakUsYUFBYSxFQUFFLE9BQU87SUFDdEIsMkJBQTJCLEVBQUUsSUFBSTtJQUNqQyxzQkFBc0IsRUFBRSxHQUFHO0lBQzNCLFNBQVMsRUFBRSxHQUFHO0NBQ2YsQ0FBQyJ9

package/build/module/routers/synthra-router/index.d.ts

@@ -0,0 +1,3 @@
+export * from './config';
+export * from './synthra-router';
+export * from './types';

package/build/module/routers/synthra-router/index.js

@@ -0,0 +1,4 @@
+export * from './config';
+export * from './synthra-router';
+export * from './types';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcm91dGVycy9zeW50aHJhLXJvdXRlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsU0FBUyxDQUFDIn0=

package/build/module/routers/synthra-router/synthra-router.d.ts

@@ -0,0 +1,31 @@
+import { BestVenueResult, SynthraRoute, SynthraRouteRequest, SynthraRouterParams } from './types';
+export declare class SynthraRouter {
+    private readonly params;
+    private readonly alphaRouters;
+    private readonly cctp;
+    constructor(params: SynthraRouterParams);
+    route(request: SynthraRouteRequest): Promise<SynthraRoute | null>;
+    routeBestVenue(request: SynthraRouteRequest, sourceChainId?: number): Promise<BestVenueResult>;
+    private routeBestVenueCandidate;
+    private routeSameChain;
+    private routeCCTP;
+    private routeLocalOrNoOp;
+    private buildCCTPExecutionPlan;
+    private resolveDestinationChainId;
+    private resolveTokenOut;
+    private isTokenByChainId;
+    private getAlphaRouter;
+    private getCCTPChainConfig;
+    private defaultUniversalRouterSwapOptions;
+    private decodeUniversalRouterCall;
+    private rewriteSourceBridgeSwapForNativeSweep;
+    private sourceBridgeMinAmount;
+    private destinationMinTokenOut;
+    private shouldSweepSourceBridgeOutput;
+    private hexToCommandBytes;
+    private commandBytesToHex;
+    private compareQuotes;
+    private sumGas;
+    private legGas;
+    private addressToBytes32;
+}

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

@@ -0,0 +1,453 @@
+import { defaultAbiCoder, Interface } from '@ethersproject/abi';
+import { getAddress } from '@ethersproject/address';
+import { BigNumber } from '@ethersproject/bignumber';
+import { hexZeroPad } from '@ethersproject/bytes';
+import { ChainId, Percent, TradeType, } from '@synthra-swap/sdk/core';
+import { UNIVERSAL_ROUTER_ADDRESS } from '@synthra-swap/sdk/universal-router';
+import JSBI from 'jsbi';
+import { CurrencyAmount } from '../../util/amounts';
+import { AlphaRouter } from '../alpha-router';
+import { SwapType } from '../router';
+import { DEFAULT_CCTP_ROUTER_CONFIG } from './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 Percent(50, 10000);
+const UNIVERSAL_ROUTER_INTERFACE = new Interface([
+    'function execute(bytes commands, bytes[] inputs, uint256 deadline)',
+]);
+export class SynthraRouter {
+    constructor(params) {
+        var _a, _b;
+        this.params = params;
+        this.alphaRouters = new Map();
+        this.cctp = {
+            ...DEFAULT_CCTP_ROUTER_CONFIG,
+            ...params.cctp,
+            chains: {
+                ...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({ ...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 !== 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.from((_d = (_c = request.feeAmount) !== null && _c !== void 0 ? _c : this.cctp.feeAmount) !== null && _d !== void 0 ? _d : 0);
+        const cctpMaxFee = BigNumber.from((_f = (_e = request.maxFee) !== null && _e !== void 0 ? _e : this.cctp.defaultMaxFee) !== null && _f !== void 0 ? _f : 0);
+        const bridgeAmountRaw = 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 = 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 = 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, 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 : UNIVERSAL_ROUTER_ADDRESS(sourceConfig.chainId);
+        const destinationUniversalRouter = (_b = destinationConfig.universalRouter) !== null && _b !== void 0 ? _b : 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, {
+            ...alphaRouterParams,
+            chainId,
+            provider,
+        })) !== null && _e !== void 0 ? _e : new AlphaRouter({
+            ...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: 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 = defaultAbiCoder.decode(['address', 'uint256', 'uint256', 'bytes', 'bool'], input);
+            inputs[i] = 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(defaultAbiCoder.encode(['address', 'address', 'uint256'], [
+            sourceConfig.bridgeToken.address,
+            UNIVERSAL_ROUTER_MSG_SENDER,
+            minBridgeAmount,
+        ]));
+        return {
+            call: {
+                ...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 = 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.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 === 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.greaterThan(a.quoteGasAdjusted.quotient, b.quoteGasAdjusted.quotient)) {
+            return 1;
+        }
+        if (JSBI.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.from(0);
+    }
+    addressToBytes32(address) {
+        return hexZeroPad(getAddress(address), 32);
+    }
+}
+//# 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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"}