@paraswap/dex-lib 4.8.23 → 4.8.24

package/build/dex/renegade/renegade-levels-response.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenegadeLevelsResponse = void 0;
+const constants_1 = require("./constants");
+// Depth response from Renegade API.
+class RenegadeLevelsResponse {
+    levels;
+    poolLiquidity;
+    constructor(data) {
+        this.levels = data;
+        if (!this.levels || typeof this.levels !== 'object') {
+            throw new Error('Invalid Renegade levels response: expected object');
+        }
+        this.poolLiquidity = {};
+        for (const [pairIdentifier, pairData] of Object.entries(this.levels)) {
+            const askLiquidityUSD = pairData.asks.reduce((acc, [price, size]) => {
+                return acc + parseFloat(size) * parseFloat(price);
+            }, 0);
+            const bidLiquidityUSD = pairData.bids.reduce((acc, [price, size]) => {
+                return acc + parseFloat(size) * parseFloat(price);
+            }, 0);
+            const liquidityUSD = askLiquidityUSD + bidLiquidityUSD;
+            this.poolLiquidity[pairIdentifier] = {
+                poolIdentifier: pairIdentifier,
+                exchange: constants_1.RENEGADE_NAME,
+                address: pairIdentifier.split('/')[0],
+                connectorTokens: [],
+                liquidityUSD,
+            };
+        }
+    }
+    // Returns the raw levels data.
+    getRawData() {
+        return this.levels;
+    }
+    // Returns the pool liquidity for the given base token.
+    getPoolLiquidity(tokenAddress) {
+        const pools = [];
+        for (const [pair, pool] of Object.entries(this.poolLiquidity)) {
+            if (pair.toLowerCase().indexOf(tokenAddress.toLowerCase()) !== -1) {
+                pools.push(pool);
+            }
+        }
+        return pools;
+    }
+    // Returns directional liquidity data for a token across all relevant pairs.
+    getDirectionalLiquidityForToken(tokenAddress, usdcAddress) {
+        const normalizedTokenAddress = tokenAddress.toLowerCase();
+        const normalizedUsdcAddress = usdcAddress.toLowerCase();
+        const results = [];
+        for (const [pairIdentifier, pairDepth] of Object.entries(this.levels)) {
+            const parsedPair = this.parsePairIdentifier(pairIdentifier);
+            if (!parsedPair)
+                continue;
+            const [baseToken, quoteToken] = parsedPair;
+            if (quoteToken !== normalizedUsdcAddress)
+                continue; // quote token should always be USDC
+            const isTokenBase = normalizedTokenAddress === baseToken;
+            const isTokenQuote = normalizedTokenAddress === quoteToken;
+            if (!isTokenBase && !isTokenQuote)
+                continue;
+            // Calculate directional liquidity
+            // If token is base: outbound = bids (sell base), reverse = asks (buy base)
+            // If token is quote: outbound = asks (sell quote), reverse = bids (buy quote)
+            const outboundLiquidityUSD = isTokenBase
+                ? this.calculateLiquidityUSD(pairDepth.bids)
+                : this.calculateLiquidityUSD(pairDepth.asks);
+            const reverseLiquidityUSD = isTokenBase
+                ? this.calculateLiquidityUSD(pairDepth.asks)
+                : this.calculateLiquidityUSD(pairDepth.bids);
+            if (outboundLiquidityUSD <= 0)
+                continue;
+            results.push({
+                baseToken,
+                quoteToken,
+                outboundLiquidityUSD,
+                reverseLiquidityUSD,
+                isTokenBase,
+            });
+        }
+        return results;
+    }
+    // Internal helper: parse pair identifier into [base, quote] tuple.
+    // Pair identifiers are formatted as [base]/[quote], where quote is always USDC.
+    parsePairIdentifier(pairIdentifier) {
+        const parts = pairIdentifier.split('/').map(s => s.toLowerCase());
+        if (parts.length !== 2 || !parts[0] || !parts[1]) {
+            return null;
+        }
+        return [parts[0], parts[1]];
+    }
+    // Internal helper: calculate USD liquidity from price levels.
+    // Sums price * size across all levels (both are strings).
+    calculateLiquidityUSD(levels) {
+        return levels.reduce((acc, [price, size]) => acc + parseFloat(size) * parseFloat(price), 0);
+    }
+}
+exports.RenegadeLevelsResponse = RenegadeLevelsResponse;
+//# sourceMappingURL=renegade-levels-response.js.map

package/build/dex/renegade/renegade-levels-response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"renegade-levels-response.js","sourceRoot":"","sources":["../../../src/dex/renegade/renegade-levels-response.ts"],"names":[],"mappings":"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"}

package/build/dex/renegade/renegade.d.ts

@@ -0,0 +1,57 @@
+import { Network, SwapSide } from '../../constants';
+import { IDexHelper } from '../../dex-helper/idex-helper';
+import { IDex } from '../../dex/idex';
+import { AdapterExchangeParam, Address, DexExchangeParam, ExchangePrices, ExchangeTxInfo, Logger, NumberAsString, OptimalSwapExchange, PoolLiquidity, PoolPrices, PreprocessTransactionOptions, Token, TransferFeeParams } from '../../types';
+import { SimpleExchange } from '../simple-exchange';
+import { SignedExternalQuote } from './api/types';
+import { RenegadeLevelsResponse } from './renegade-levels-response';
+import { RenegadeData } from './types';
+export declare class Renegade extends SimpleExchange implements IDex<RenegadeData> {
+    readonly network: Network;
+    readonly dexKey: string;
+    readonly dexHelper: IDexHelper;
+    readonly hasConstantPriceLargeAmounts = false;
+    readonly needWrapNative = true;
+    readonly isFeeOnTransferSupported = false;
+    readonly isStatePollingDex = true;
+    static dexKeysWithNetwork: {
+        key: string;
+        networks: Network[];
+    }[];
+    private rateFetcher;
+    private renegadeClient;
+    private tokensMap;
+    private readonly apiKey;
+    private readonly apiSecret;
+    private usdcAddress;
+    logger: Logger;
+    constructor(network: Network, dexKey: string, dexHelper: IDexHelper);
+    initializePricing(blockNumber: number): Promise<void>;
+    getAdapters(side: SwapSide): {
+        name: string;
+        index: number;
+    }[] | null;
+    private getPoolIdentifier;
+    getPoolIdentifiers(srcToken: Token, destToken: Token, side: SwapSide, blockNumber: number): Promise<string[]>;
+    getPricesVolume(srcToken: Token, destToken: Token, amounts: bigint[], side: SwapSide, blockNumber: number, limitPools?: string[], transferFees?: TransferFeeParams, isFirstSwap?: boolean): Promise<ExchangePrices<RenegadeData> | null>;
+    private getRateForAmount;
+    getCalldataGasCost(_poolPrices: PoolPrices<RenegadeData>): number | number[];
+    getAdapterParam(srcToken: string, destToken: string, srcAmount: string, destAmount: string, data: RenegadeData, side: SwapSide): AdapterExchangeParam;
+    updatePoolState(): Promise<void>;
+    setTokensMap(): Promise<void>;
+    getTopPoolsForToken(tokenAddress: Address, limit: number): Promise<PoolLiquidity[]>;
+    getDexParam(srcToken: Address, destToken: Address, srcAmount: NumberAsString, destAmount: NumberAsString, recipient: Address, data: RenegadeData, side: SwapSide): DexExchangeParam;
+    preProcessTransaction(optimalSwapExchange: OptimalSwapExchange<RenegadeData>, srcToken: Token, destToken: Token, side: SwapSide, options: PreprocessTransactionOptions): Promise<[OptimalSwapExchange<RenegadeData>, ExchangeTxInfo]>;
+    releaseResources(): Promise<void>;
+    getCachedSignedQuote(srcToken: Token, destToken: Token): Promise<SignedExternalQuote | null>;
+    getCachedLevels(): Promise<RenegadeLevelsResponse | null>;
+    getCachedTokens(): Promise<Record<string, Token> | null>;
+    private getQuoteCacheKey;
+    private createExternalOrderWithInputAmount;
+    private createExternalOrderWithExactOutputAmount;
+    private areTokensSupported;
+    private isRenegadeSell;
+    getTokenFromAddress(address: Address): Token;
+    isUSDC(tokenAddress: Address): boolean;
+    private _sortTokens;
+}

package/build/dex/renegade/renegade.js

@@ -0,0 +1,499 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Renegade = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const ts_essentials_1 = require("ts-essentials");
+const CALLDATA_GAS_COST = __importStar(require("../../calldata-gas-cost"));
+const constants_1 = require("../../constants");
+const simple_exchange_1 = require("../simple-exchange");
+const utils_1 = require("../../utils");
+const renegade_client_1 = require("./api/renegade-client");
+const config_1 = require("./config");
+const constants_2 = require("./constants");
+const rate_fetcher_1 = require("./rate-fetcher");
+const renegade_levels_response_1 = require("./renegade-levels-response");
+class Renegade extends simple_exchange_1.SimpleExchange {
+    network;
+    dexKey;
+    dexHelper;
+    hasConstantPriceLargeAmounts = false;
+    needWrapNative = true;
+    isFeeOnTransferSupported = false;
+    isStatePollingDex = true;
+    static dexKeysWithNetwork = [
+        { key: constants_2.RENEGADE_NAME, networks: [constants_1.Network.ARBITRUM, constants_1.Network.BASE] },
+    ];
+    rateFetcher;
+    renegadeClient;
+    tokensMap = {};
+    apiKey;
+    apiSecret;
+    usdcAddress;
+    logger;
+    constructor(network, dexKey, dexHelper) {
+        super(dexHelper, dexKey);
+        this.network = network;
+        this.dexKey = dexKey;
+        this.dexHelper = dexHelper;
+        this.logger = dexHelper.getLogger(dexKey);
+        // Ensure API credentials are set
+        const apiKey = this.dexHelper.config.data.renegadeAuthApiKey;
+        const apiSecret = this.dexHelper.config.data.renegadeAuthApiSecret;
+        (0, ts_essentials_1.assert)(apiKey !== undefined, 'Renegade API key is not specified with env variable API_KEY_RENEGADE_AUTH_API_KEY');
+        (0, ts_essentials_1.assert)(apiSecret !== undefined, 'Renegade API secret is not specified with env variable API_KEY_RENEGADE_AUTH_API_SECRET');
+        // Initialize rate fetcher with credentials and caching config
+        this.apiKey = apiKey;
+        this.apiSecret = apiSecret;
+        const rateFetcherConfig = {
+            apiKey,
+            apiSecret,
+            levelsCacheKey: constants_2.RENEGADE_LEVELS_CACHE_KEY,
+            levelsCacheTTL: constants_2.RENEGADE_LEVELS_CACHE_TTL_SECONDS,
+            tokenMetadataCacheKey: constants_2.RENEGADE_TOKEN_METADATA_CACHE_KEY,
+            tokenMetadataCacheTTL: constants_2.RENEGADE_TOKEN_METADATA_CACHE_TTL_SECONDS,
+        };
+        this.rateFetcher = new rate_fetcher_1.RateFetcher(this.dexHelper, this.dexKey, this.network, this.logger, rateFetcherConfig);
+        this.renegadeClient = new renegade_client_1.RenegadeClient(this.dexHelper, this.network, this.apiKey, this.apiSecret, this.logger);
+        this.usdcAddress = config_1.RenegadeConfig[constants_2.RENEGADE_NAME][this.network].usdcAddress;
+    }
+    async initializePricing(blockNumber) {
+        if (!this.dexHelper.config.isSlave) {
+            this.rateFetcher.start();
+            await sleep(constants_2.RENEGADE_INIT_TIMEOUT_MS);
+        }
+        await this.setTokensMap();
+    }
+    // Legacy: was only used for V5
+    // Returns the list of contract adapters (name and index)
+    // for a buy/sell. Return null if there are no adapters.
+    getAdapters(side) {
+        return null;
+    }
+    // Returns pool identifier as the Renegade API expects it.
+    getPoolIdentifier(tokenA, tokenB) {
+        const srcIsUSDC = this.isUSDC(tokenA);
+        const baseToken = srcIsUSDC ? tokenB : tokenA;
+        const quoteToken = srcIsUSDC ? tokenA : tokenB;
+        return `${this.dexKey}_${baseToken.toLowerCase()}_${quoteToken.toLowerCase()}`;
+    }
+    // Returns list of pool identifiers that can be used
+    // for a given swap.
+    async getPoolIdentifiers(srcToken, destToken, side, blockNumber) {
+        if (!this.areTokensSupported(srcToken.address, destToken.address)) {
+            return [];
+        }
+        return [this.getPoolIdentifier(srcToken.address, destToken.address)];
+    }
+    // Returns pool prices for amounts.
+    async getPricesVolume(srcToken, destToken, amounts, side, blockNumber, limitPools, transferFees, isFirstSwap) {
+        try {
+            if (amounts.length === 0) {
+                return null;
+            }
+            if (!this.areTokensSupported(srcToken.address, destToken.address)) {
+                this.logger.debug('Tokens not supported by Renegade API', {
+                    srcToken: srcToken.address,
+                    destToken: destToken.address,
+                });
+                return null;
+            }
+            // Use the last amount as reference for the quote
+            const referenceAmount = amounts[amounts.length - 1].toString();
+            this.logger.debug('Getting rate for amount', {
+                srcToken,
+                destToken,
+                referenceAmount,
+                side,
+            });
+            // Get rate from helper method
+            const rate = await this.getRateForAmount(srcToken, destToken, referenceAmount, side);
+            // Apply rate to all amounts
+            const prices = amounts.map(amount => {
+                const output = new bignumber_js_1.default(amount.toString()).multipliedBy(rate);
+                return BigInt(output.decimalPlaces(0, bignumber_js_1.default.ROUND_FLOOR).toFixed(0));
+            });
+            const poolIdentifier = this.getPoolIdentifier(srcToken.address, destToken.address);
+            const outputDecimals = side === constants_1.SwapSide.SELL ? destToken.decimals : srcToken.decimals;
+            return [
+                {
+                    prices,
+                    unit: (0, utils_1.getBigIntPow)(outputDecimals),
+                    data: {},
+                    poolIdentifiers: [poolIdentifier],
+                    exchange: this.dexKey,
+                    gasCost: constants_2.RENEGADE_GAS_COST,
+                },
+            ];
+        }
+        catch (e) {
+            this.logger.error(`Error_getPricesVolume ${srcToken.address || srcToken.symbol}, ${destToken.address || destToken.symbol}, ${side}:`, e);
+            return null;
+        }
+    }
+    // Helper method to construct external order, request quote, cache response, and return rate.
+    async getRateForAmount(srcToken, destToken, referenceAmount, side) {
+        // Determine tokens and Renegade side
+        const isRenegadeSell = this.isRenegadeSell(srcToken, destToken);
+        // Determine base and quote mints (quote is always USDC)
+        const isDestUSDC = this.isUSDC(destToken.address);
+        const baseMint = isDestUSDC ? srcToken.address : destToken.address;
+        const quoteMint = this.usdcAddress;
+        const renegadeSide = isRenegadeSell ? 'Sell' : 'Buy';
+        const externalOrder = side === constants_1.SwapSide.SELL
+            ? this.createExternalOrderWithInputAmount(quoteMint, baseMint, renegadeSide, referenceAmount)
+            : this.createExternalOrderWithExactOutputAmount(quoteMint, baseMint, renegadeSide, referenceAmount);
+        // Fetch quote from Renegade API
+        const quoteResponse = await this.renegadeClient.requestQuote(externalOrder);
+        // Cache the signed quote for later use in preProcessTransaction
+        const cacheKey = this.getQuoteCacheKey(srcToken, destToken);
+        // Extract send/receive from quote
+        const send = quoteResponse.signed_quote.quote.send;
+        const receive = quoteResponse.signed_quote.quote.receive;
+        // Determine input and output tokens for rate calculation
+        const inputToken = side === constants_1.SwapSide.SELL ? srcToken : destToken;
+        // Identify which is input and which is output in send/receive
+        const isSendInput = send.mint.toLowerCase() === inputToken.address.toLowerCase();
+        const inputAmount = isSendInput ? send.amount : receive.amount;
+        const outputAmount = isSendInput ? receive.amount : send.amount;
+        // Protect against division by zero
+        if (new bignumber_js_1.default(inputAmount).isZero()) {
+            throw new Error('Division by zero: inputAmount is zero');
+        }
+        // Calculate rate: output per input (in atomic units)
+        const rate = new bignumber_js_1.default(outputAmount).dividedBy(inputAmount);
+        // Store the signed quote response directly in cache
+        await this.dexHelper.cache.setex(this.dexKey, this.network, cacheKey, constants_2.RENEGADE_QUOTE_CACHE_TTL_SECONDS, JSON.stringify(quoteResponse));
+        return rate;
+    }
+    // Returns estimated gas cost of calldata for this DEX in multiSwap
+    //
+    // Estimates calldata gas cost for [function sponsorAtomicMatchSettle()](https://github.com/renegade-fi/renegade-contracts/blob/c1df0e58a6fc665133540c79ef2f0c6226fa670f/src/darkpool/v1/contracts/GasSponsor.sol#L174-L189)
+    getCalldataGasCost(_poolPrices) {
+        // Assumptions
+        const INTERNAL_PARTY_MODIFIED_SHARES_LEN = 70;
+        const PLONK_PROOF_WORDS = 36;
+        const LINKING_PROOF_WORDS = 4;
+        const { ADDRESS, AMOUNT, BOOL, BPS, DEX_OVERHEAD, FULL_WORD, FUNCTION_SELECTOR, INDEX, LENGTH_SMALL, OFFSET_LARGE, UUID, } = CALLDATA_GAS_COST;
+        const PARTY_MATCH_PAYLOAD = 3 * INDEX + // OrderSettlementIndices
+            3 * FULL_WORD; // ValidReblindStatement (3 scalars)
+        const EXTERNAL_MATCH_RESULT = ADDRESS + ADDRESS + AMOUNT + AMOUNT + INDEX; // direction ~ small enum
+        const FEE_TAKE = AMOUNT + AMOUNT;
+        const INTERNAL_PARTY_SETTLEMENT_INDICES = 3 * INDEX;
+        const VMSA_HEAD = EXTERNAL_MATCH_RESULT +
+            FEE_TAKE +
+            OFFSET_LARGE + // internal array offset
+            INTERNAL_PARTY_SETTLEMENT_INDICES +
+            BPS + // protocolFeeRate (approx small)
+            ADDRESS; // relayerFeeAddress
+        const VMSA_TAIL = LENGTH_SMALL + INTERNAL_PARTY_MODIFIED_SHARES_LEN * FULL_WORD;
+        const VALID_MATCH_SETTLE_ATOMIC_STATEMENT = OFFSET_LARGE + // top-level struct offset
+            VMSA_HEAD +
+            VMSA_TAIL;
+        const MATCH_ATOMIC_PROOFS = 3 * PLONK_PROOF_WORDS * FULL_WORD;
+        const MATCH_ATOMIC_LINKING_PROOFS = 2 * LINKING_PROOF_WORDS * FULL_WORD;
+        const FOOTER = ADDRESS + // refundAddress
+            BOOL + // refundNativeEth
+            AMOUNT + // refundAmount
+            UUID; // nonce (approx)
+        const SIGNATURE = OFFSET_LARGE + // bytes offset
+            LENGTH_SMALL + // length (65)
+            2 * FULL_WORD + // r, s
+            BOOL; // v
+        const total = DEX_OVERHEAD +
+            FUNCTION_SELECTOR +
+            PARTY_MATCH_PAYLOAD +
+            VALID_MATCH_SETTLE_ATOMIC_STATEMENT +
+            MATCH_ATOMIC_PROOFS +
+            MATCH_ATOMIC_LINKING_PROOFS +
+            FOOTER +
+            SIGNATURE;
+        return total; // ~103000 L1 gas
+    }
+    // Encode params required by the exchange adapter
+    // V5: Used for multiSwap, buy & megaSwap
+    // V6: Not used, can be left blank
+    getAdapterParam(srcToken, destToken, srcAmount, destAmount, data, side) {
+        const settlementTx = data?.settlementTx;
+        if (!settlementTx) {
+            throw new Error(`${this.dexKey}-${this.network}: settlementTx missing from data`);
+        }
+        return {
+            targetExchange: settlementTx.to,
+            payload: settlementTx.data,
+            networkFee: settlementTx.value,
+        };
+    }
+    async updatePoolState() {
+        await this.setTokensMap();
+    }
+    async setTokensMap() {
+        const metadata = await this.getCachedTokens();
+        if (metadata) {
+            this.tokensMap = metadata;
+        }
+    }
+    // Returns list of top pools based on liquidity. Max
+    // limit number pools should be returned.
+    async getTopPoolsForToken(tokenAddress, limit) {
+        // Ensure we have cached levels and token metadata available
+        const levels = await this.getCachedLevels();
+        if (!levels)
+            return [];
+        await this.setTokensMap();
+        const normalizedTokenAddress = tokenAddress.toLowerCase();
+        const normalizedUsdcAddress = this.usdcAddress.toLowerCase();
+        const directionalLiquidity = levels.getDirectionalLiquidityForToken(normalizedTokenAddress, normalizedUsdcAddress);
+        const results = [];
+        for (const liquidityData of directionalLiquidity) {
+            const { baseToken, outboundLiquidityUSD, reverseLiquidityUSD, isTokenBase, } = liquidityData;
+            // Determine connector token: USDC if token is base, base token if token is quote
+            const connectorAddress = isTokenBase ? normalizedUsdcAddress : baseToken;
+            const connectorMeta = this.tokensMap[connectorAddress];
+            if (!connectorMeta) {
+                continue;
+            }
+            results.push({
+                exchange: this.dexKey,
+                address: baseToken,
+                connectorTokens: [
+                    {
+                        address: connectorAddress,
+                        decimals: connectorMeta.decimals,
+                        symbol: connectorMeta.symbol,
+                        liquidityUSD: reverseLiquidityUSD,
+                    },
+                ],
+                liquidityUSD: outboundLiquidityUSD,
+            });
+        }
+        return results
+            .sort((a, b) => b.liquidityUSD - a.liquidityUSD)
+            .slice(0, limit);
+    }
+    getDexParam(srcToken, destToken, srcAmount, destAmount, recipient, data, side) {
+        const settlementTx = data?.settlementTx;
+        if (!settlementTx) {
+            throw new Error(`${this.dexKey}-${this.network}: settlementTx missing from data`);
+        }
+        return {
+            needWrapNative: this.needWrapNative,
+            dexFuncHasRecipient: false,
+            exchangeData: settlementTx.data,
+            targetExchange: settlementTx.to,
+            returnAmountPos: undefined,
+            specialDexSupportsInsertFromAmount: false,
+        };
+    }
+    // Called before getAdapterParam to use async calls and receive data if needed
+    async preProcessTransaction(optimalSwapExchange, srcToken, destToken, side, options) {
+        try {
+            if (!this.areTokensSupported(srcToken.address, destToken.address)) {
+                throw new Error(`${this.dexKey}-${this.network}: Tokens not supported by Renegade API: ${srcToken.address}, ${destToken.address}`);
+            }
+            // 1. Retrieve cached fixed signed quote for the pair (now side-specific)
+            const cachedSignedQuote = await this.getCachedSignedQuote(srcToken, destToken);
+            if (!cachedSignedQuote) {
+                throw new Error(`${this.dexKey}-${this.network}: No cached quote available for pair ${srcToken.address}-${destToken.address}`);
+            }
+            // 2. Extract base_mint, quote_mint, and side from cached quote
+            const cachedOrder = cachedSignedQuote.quote.order;
+            const baseMint = cachedOrder.base_mint;
+            const quoteMint = cachedOrder.quote_mint;
+            const renegadeSide = cachedOrder.side;
+            // 3. Create updated order with actual transaction amount
+            const updatedOrder = side === constants_1.SwapSide.SELL
+                ? this.createExternalOrderWithInputAmount(quoteMint, baseMint, renegadeSide, optimalSwapExchange.srcAmount)
+                : this.createExternalOrderWithExactOutputAmount(quoteMint, baseMint, renegadeSide, optimalSwapExchange.destAmount);
+            // 4. Request calldata from Renegade API with updated order
+            const response = await this.renegadeClient.assembleExternalMatch(cachedSignedQuote, { updated_order: updatedOrder });
+            const settlementTxRequest = response?.match_bundle?.settlement_tx;
+            (0, ts_essentials_1.assert)(settlementTxRequest !== undefined, `${this.dexKey}-${this.network}: Invalid match response`);
+            const settlementTx = {
+                to: settlementTxRequest.to || '',
+                data: settlementTxRequest.data || settlementTxRequest.input || '',
+                value: settlementTxRequest.value || '0',
+            };
+            const exchangeWithData = {
+                ...optimalSwapExchange,
+                data: {
+                    settlementTx,
+                    rawResponse: response,
+                },
+            };
+            return [exchangeWithData, {}];
+        }
+        catch (e) {
+            const message = `${this.dexKey}-${this.network}: ${e}`;
+            this.logger.error(message);
+            throw new Error(message);
+        }
+    }
+    // Cleans up any resources used by the DEX.
+    async releaseResources() {
+        if (!this.dexHelper.config.isSlave) {
+            this.rateFetcher.stop();
+        }
+    }
+    // Cache
+    // Get cached signed quote for a token pair and side.
+    async getCachedSignedQuote(srcToken, destToken) {
+        try {
+            // Build cache key using helper method
+            const cacheKey = this.getQuoteCacheKey(srcToken, destToken);
+            // Check cache for existing quote
+            const cachedQuote = await this.dexHelper.cache.getAndCacheLocally(this.dexKey, this.network, cacheKey, constants_2.RENEGADE_QUOTE_CACHE_TTL_SECONDS);
+            if (cachedQuote) {
+                const quoteResponse = JSON.parse(cachedQuote);
+                return quoteResponse.signed_quote;
+            }
+            return null;
+        }
+        catch (e) {
+            this.logger.error(`Error retrieving cached quote for ${srcToken.address}-${destToken.address}:`, e);
+            return null;
+        }
+    }
+    // Get cached price levels from persistent cache.
+    async getCachedLevels() {
+        const cachedLevels = await this.dexHelper.cache.getAndCacheLocally(this.dexKey, this.network, constants_2.RENEGADE_LEVELS_CACHE_KEY, constants_2.RENEGADE_LEVELS_CACHE_TTL_SECONDS);
+        if (cachedLevels) {
+            const rawData = JSON.parse(cachedLevels);
+            return new renegade_levels_response_1.RenegadeLevelsResponse(rawData);
+        }
+        return null;
+    }
+    // Get cached token metadata from persistent cache.
+    async getCachedTokens() {
+        const cachedTokens = await this.dexHelper.cache.getAndCacheLocally(this.dexKey, this.network, constants_2.RENEGADE_TOKEN_METADATA_CACHE_KEY, constants_2.RENEGADE_TOKEN_METADATA_CACHE_TTL_SECONDS);
+        if (cachedTokens) {
+            return JSON.parse(cachedTokens);
+        }
+        return null;
+    }
+    // Generate cache key for quote storage and retrieval.
+    getQuoteCacheKey(srcToken, destToken) {
+        // Determine Renegade side based on which token is USDC
+        const isRenegadeSell = this.isRenegadeSell(srcToken, destToken);
+        // Build cache key from alphabetically sorted token addresses and side
+        const sortedAddresses = this._sortTokens(srcToken.address, destToken.address);
+        return `${constants_2.RENEGADE_QUOTE_CACHE_KEY}_${sortedAddresses[0]}_${sortedAddresses[1]}_${isRenegadeSell ? 'Sell' : 'Buy'}`;
+    }
+    // Helpers
+    // Create updated order for exact input (ParaSwap SELL side).
+    // Preserves token pair and side from cached quote, updates amounts only.
+    createExternalOrderWithInputAmount(quoteMint, baseMint, side, srcAmount) {
+        // Determine which amount field to set based on Renegade side
+        // Rule: Exactly ONE sizing parameter must be non-zero
+        const isRenegadeSell = side === 'Sell';
+        // For exact input, we specify the input amount
+        // If Renegade Sell: base is input (base_amount)
+        // If Renegade Buy: quote is input (quote_amount)
+        const baseAmount = isRenegadeSell ? srcAmount : '0';
+        const quoteAmount = isRenegadeSell ? '0' : srcAmount;
+        return {
+            quote_mint: quoteMint,
+            base_mint: baseMint,
+            side: side,
+            base_amount: baseAmount,
+            quote_amount: quoteAmount,
+            min_fill_size: srcAmount,
+            exact_base_output: '0',
+            exact_quote_output: '0',
+        };
+    }
+    // Create updated order for exact output (ParaSwap BUY side).
+    // Preserves token pair and side from cached quote, updates amounts only.
+    createExternalOrderWithExactOutputAmount(quoteMint, baseMint, side, destAmount) {
+        // Determine which exact output field to set based on Renegade side
+        // Rule: Exactly ONE sizing parameter must be non-zero
+        // Rule: When using exact outputs, min_fill_size MUST be 0
+        const isRenegadeSell = side === 'Sell';
+        // For exact output, we specify the output amount
+        // If Renegade Sell: quote is output (exact_quote_output)
+        // If Renegade Buy: base is output (exact_base_output)
+        const exactQuoteOutput = isRenegadeSell ? destAmount : '0';
+        const exactBaseOutput = isRenegadeSell ? '0' : destAmount;
+        return {
+            quote_mint: quoteMint,
+            base_mint: baseMint,
+            side: side,
+            base_amount: '0',
+            quote_amount: '0',
+            min_fill_size: '0', // MUST be 0 with exact outputs
+            exact_base_output: exactBaseOutput,
+            exact_quote_output: exactQuoteOutput,
+        };
+    }
+    // Ensures both tokens are supported by Renegade API and exactly one of them is USDC.
+    areTokensSupported(srcTokenAddress, destTokenAddress) {
+        const srcTokenLower = srcTokenAddress.toLowerCase();
+        const destTokenLower = destTokenAddress.toLowerCase();
+        const srcTokenExists = this.tokensMap[srcTokenLower] !== undefined;
+        const destTokenExists = this.tokensMap[destTokenLower] !== undefined;
+        if (!srcTokenExists || !destTokenExists) {
+            return false;
+        }
+        const srcIsUSDC = this.isUSDC(srcTokenAddress);
+        const destIsUSDC = this.isUSDC(destTokenAddress);
+        const exactlyOneIsUSDC = srcIsUSDC !== destIsUSDC;
+        return exactlyOneIsUSDC;
+    }
+    // Determine if this is a Renegade Sell operation (base → USDC).
+    isRenegadeSell(srcToken, destToken) {
+        return this.isUSDC(destToken.address);
+    }
+    // Returns the token metadata for a given address.
+    getTokenFromAddress(address) {
+        return this.tokensMap[address.toLowerCase()];
+    }
+    // Check if a token address is USDC for the current network.
+    isUSDC(tokenAddress) {
+        return tokenAddress.toLowerCase() === this.usdcAddress.toLowerCase();
+    }
+    // Sort token addresses alphabetically.
+    _sortTokens(srcAddress, destAddress) {
+        return [srcAddress, destAddress].sort((a, b) => (a < b ? -1 : 1));
+    }
+}
+exports.Renegade = Renegade;
+// Helper function to sleep for a given time
+const sleep = (time) => new Promise(resolve => {
+    setTimeout(resolve, time);
+});
+//# sourceMappingURL=renegade.js.map