@paraswap/dex-lib 5.1.31 → 5.1.32

package/build/generic-swap-transaction-builder/dex-encoder/types.d.ts

@@ -0,0 +1,207 @@
+import type { SwapSide } from '@paraswap/core';
+import type { Address } from '../../types';
+import { SpecialDex } from '../../executor/types';
+import type { DirectContractMethodV6 } from './direct-methods';
+export type DecimalString = string;
+export type HexString = `0x${string}`;
+export type DexEncoderJsonValue = null | boolean | number | string | DexEncoderJsonValue[] | {
+    [key: string]: DexEncoderJsonValue;
+};
+export type DexEncoderSwapExchangeData = DexEncoderJsonValue;
+export type NeedWrapNativeAuditDexKey = 'CurveV1Factory' | 'CurveV1StableNg';
+export declare const AUDITED_FUNCTION_NEED_WRAP_NATIVE_DEXES: readonly ["CurveV1Factory", "CurveV1StableNg"];
+export type AddressNormalizationPolicy = 'lowercase';
+export type AmountNormalizationPolicy = 'decimal-string';
+export type BytesNormalizationPolicy = '0x-prefixed-hex';
+export type UnknownFieldPolicy = 'reject';
+export type SwapExchangeDataPolicy = 'dex-owned-pass-through';
+export type OptionalFieldPolicy = 'omit-or-null-normalized-to-undefined';
+export type DexEncoderDtoNormalizationPolicy = {
+    addressFields: AddressNormalizationPolicy;
+    amountFields: AmountNormalizationPolicy;
+    calldataFields: BytesNormalizationPolicy;
+    swapExchangeData: SwapExchangeDataPolicy;
+    unknownFields: UnknownFieldPolicy;
+    optionalFields: OptionalFieldPolicy;
+};
+export declare const DEX_ENCODER_DTO_NORMALIZATION_POLICY: DexEncoderDtoNormalizationPolicy;
+export type DexEncoderDtoFieldContract = {
+    addressFields: readonly string[];
+    amountFields: readonly string[];
+    booleanFields: readonly string[];
+    calldataFields: readonly string[];
+    nullableInputFields: readonly string[];
+    numberFields: readonly string[];
+    passThroughFields: readonly string[];
+    strictOutputFields: readonly string[];
+};
+export declare const KNOWN_SPECIAL_DEX_FLAGS: readonly [SpecialDex.DEFAULT, SpecialDex.SWAP_ON_SWAAP_V2_SINGLE, SpecialDex.SWAP_ON_BALANCER_V1, SpecialDex.SWAP_ON_MAKER_PSM, SpecialDex.SEND_NATIVE, SpecialDex.SWAP_ON_BALANCER_V2, SpecialDex.SWAP_ON_UNISWAP_V2_FORK, SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK, SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK_WITH_FEE, SpecialDex.SWAP_ON_AUGUSTUS_RFQ, SpecialDex.EXECUTE_VERTICAL_BRANCHING, SpecialDex.BUY_ON_SOLIDLY_V3, SpecialDex.SWAP_ON_DEXALOT, SpecialDex.SWAP_ON_HASHFLOW];
+export declare const SPECIAL_DEX_FLAG_RESERVED_RANGE: {
+    readonly min: 0;
+    readonly max: 255;
+};
+export type NeedWrapNativeRouteContext = {
+    network: number;
+    side: SwapSide;
+    routeIndex: number;
+    routePercent: number;
+    blockNumber: number;
+    srcToken: Address;
+    destToken: Address;
+    srcAmount: DecimalString;
+    destAmount: DecimalString;
+};
+export type NeedWrapNativeSwapContext = {
+    swapIndex: number;
+    srcToken: Address;
+    destToken: Address;
+    srcAmount: DecimalString;
+    destAmount: DecimalString;
+};
+export type NeedWrapNativeSwapExchangeContext = {
+    swapExchangeIndex: number;
+    exchange: string;
+    srcAmount: DecimalString;
+    destAmount: DecimalString;
+    percent: number;
+    data: DexEncoderSwapExchangeData;
+};
+export type NeedWrapNativeInput = {
+    route: NeedWrapNativeRouteContext;
+    swap: NeedWrapNativeSwapContext;
+    swapExchange: NeedWrapNativeSwapExchangeContext;
+};
+export declare const NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT: {
+    readonly addressFields: readonly ["route.srcToken", "route.destToken", "swap.srcToken", "swap.destToken"];
+    readonly amountFields: readonly ["route.srcAmount", "route.destAmount", "swap.srcAmount", "swap.destAmount", "swapExchange.srcAmount", "swapExchange.destAmount"];
+    readonly booleanFields: readonly [];
+    readonly calldataFields: readonly [];
+    readonly nullableInputFields: readonly ["swapExchange.data"];
+    readonly numberFields: readonly ["route.network", "route.routeIndex", "route.routePercent", "route.blockNumber", "swap.swapIndex", "swapExchange.swapExchangeIndex", "swapExchange.percent"];
+    readonly passThroughFields: readonly ["swapExchange.data"];
+    readonly strictOutputFields: readonly [];
+};
+export type DexParamInput = NeedWrapNativeInput & {
+    dexKey: string;
+    srcToken: Address;
+    destToken: Address;
+    srcAmount: DecimalString;
+    destAmount: DecimalString;
+    recipient: Address;
+    executorAddress: Address;
+    side: SwapSide;
+    data: DexEncoderSwapExchangeData;
+};
+export declare const DEX_PARAM_INPUT_FIELD_CONTRACT: {
+    readonly addressFields: readonly ["route.srcToken", "route.destToken", "swap.srcToken", "swap.destToken", "srcToken", "destToken", "recipient", "executorAddress"];
+    readonly amountFields: readonly ["route.srcAmount", "route.destAmount", "swap.srcAmount", "swap.destAmount", "swapExchange.srcAmount", "swapExchange.destAmount", "srcAmount", "destAmount"];
+    readonly booleanFields: readonly [];
+    readonly calldataFields: readonly [];
+    readonly nullableInputFields: readonly ["swapExchange.data", "data"];
+    readonly numberFields: readonly ["route.network", "route.routeIndex", "route.routePercent", "route.blockNumber", "swap.swapIndex", "swapExchange.swapExchangeIndex", "swapExchange.percent"];
+    readonly passThroughFields: readonly ["swapExchange.data", "data"];
+    readonly strictOutputFields: readonly [];
+};
+export type DexExchangeParam = {
+    needWrapNative: boolean;
+    needUnwrapNative?: boolean;
+    skipApproval?: boolean;
+    wethAddress?: Address;
+    exchangeData: HexString;
+    targetExchange: Address;
+    dexFuncHasRecipient: boolean;
+    specialDexFlag?: SpecialDex;
+    transferSrcTokenBeforeSwap?: Address;
+    spender?: Address;
+    sendEthButSupportsInsertFromAmount?: boolean;
+    specialDexSupportsInsertFromAmount?: boolean;
+    swappedAmountNotPresentInExchangeData?: boolean;
+    returnAmountPos?: number;
+    insertFromAmountPos?: number;
+    amountsPacked128?: boolean;
+    permit2Approval?: boolean;
+};
+export declare const DEX_EXCHANGE_PARAM_FIELD_CONTRACT: {
+    readonly addressFields: readonly ["wethAddress", "targetExchange", "transferSrcTokenBeforeSwap", "spender"];
+    readonly amountFields: readonly [];
+    readonly booleanFields: readonly ["needWrapNative", "needUnwrapNative", "skipApproval", "dexFuncHasRecipient", "sendEthButSupportsInsertFromAmount", "specialDexSupportsInsertFromAmount", "swappedAmountNotPresentInExchangeData", "amountsPacked128", "permit2Approval"];
+    readonly calldataFields: readonly ["exchangeData"];
+    readonly nullableInputFields: readonly ["needUnwrapNative", "skipApproval", "wethAddress", "specialDexFlag", "transferSrcTokenBeforeSwap", "spender", "sendEthButSupportsInsertFromAmount", "specialDexSupportsInsertFromAmount", "swappedAmountNotPresentInExchangeData", "returnAmountPos", "insertFromAmountPos", "amountsPacked128", "permit2Approval"];
+    readonly numberFields: readonly ["specialDexFlag", "returnAmountPos", "insertFromAmountPos"];
+    readonly passThroughFields: readonly [];
+    readonly strictOutputFields: readonly ["needWrapNative", "needUnwrapNative", "skipApproval", "wethAddress", "exchangeData", "targetExchange", "dexFuncHasRecipient", "specialDexFlag", "transferSrcTokenBeforeSwap", "spender", "sendEthButSupportsInsertFromAmount", "specialDexSupportsInsertFromAmount", "swappedAmountNotPresentInExchangeData", "returnAmountPos", "insertFromAmountPos", "amountsPacked128", "permit2Approval"];
+};
+export type DirectParamInput = {
+    dexKey: string;
+    network: number;
+    contractMethod: DirectContractMethodV6;
+    srcToken: Address;
+    destToken: Address;
+    srcAmount: DecimalString;
+    destAmount: DecimalString;
+    quotedAmount: DecimalString;
+    data: DexEncoderSwapExchangeData;
+    side: SwapSide;
+    permit: HexString;
+    uuid: string;
+    partnerAndFee: DecimalString;
+    beneficiary: Address;
+    blockNumber: number;
+};
+export declare const DIRECT_PARAM_INPUT_FIELD_CONTRACT: {
+    readonly addressFields: readonly ["srcToken", "destToken", "beneficiary"];
+    readonly amountFields: readonly ["srcAmount", "destAmount", "quotedAmount", "partnerAndFee"];
+    readonly booleanFields: readonly [];
+    readonly calldataFields: readonly ["permit"];
+    readonly nullableInputFields: readonly ["data"];
+    readonly numberFields: readonly ["network", "blockNumber"];
+    readonly passThroughFields: readonly ["data"];
+    readonly strictOutputFields: readonly [];
+};
+export type DirectParamResult = {
+    params: DexEncoderJsonValue[];
+};
+export declare const DIRECT_PARAM_RESULT_FIELD_CONTRACT: {
+    readonly addressFields: readonly [];
+    readonly amountFields: readonly [];
+    readonly booleanFields: readonly [];
+    readonly calldataFields: readonly [];
+    readonly nullableInputFields: readonly [];
+    readonly numberFields: readonly [];
+    readonly passThroughFields: readonly ["params"];
+    readonly strictOutputFields: readonly ["params"];
+};
+export type WethDepositWithdrawInput = {
+    srcAmountWeth: DecimalString;
+    destAmountWeth: DecimalString;
+    side: SwapSide;
+};
+export type WethCallData = {
+    callee: Address;
+    calldata: HexString;
+    value: DecimalString;
+};
+export type WethDepositWithdrawResult = {
+    deposit?: WethCallData;
+    withdraw?: WethCallData;
+};
+export declare const WETH_DEPOSIT_WITHDRAW_INPUT_FIELD_CONTRACT: {
+    readonly addressFields: readonly [];
+    readonly amountFields: readonly ["srcAmountWeth", "destAmountWeth"];
+    readonly booleanFields: readonly [];
+    readonly calldataFields: readonly [];
+    readonly nullableInputFields: readonly [];
+    readonly numberFields: readonly [];
+    readonly passThroughFields: readonly [];
+    readonly strictOutputFields: readonly [];
+};
+export declare const WETH_DEPOSIT_WITHDRAW_RESULT_FIELD_CONTRACT: {
+    readonly addressFields: readonly ["deposit.callee", "withdraw.callee"];
+    readonly amountFields: readonly ["deposit.value", "withdraw.value"];
+    readonly booleanFields: readonly [];
+    readonly calldataFields: readonly ["deposit.calldata", "withdraw.calldata"];
+    readonly nullableInputFields: readonly ["deposit", "withdraw"];
+    readonly numberFields: readonly [];
+    readonly passThroughFields: readonly [];
+    readonly strictOutputFields: readonly ["deposit", "withdraw"];
+};

package/build/generic-swap-transaction-builder/dex-encoder/types.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WETH_DEPOSIT_WITHDRAW_RESULT_FIELD_CONTRACT = exports.WETH_DEPOSIT_WITHDRAW_INPUT_FIELD_CONTRACT = exports.DIRECT_PARAM_RESULT_FIELD_CONTRACT = exports.DIRECT_PARAM_INPUT_FIELD_CONTRACT = exports.DEX_EXCHANGE_PARAM_FIELD_CONTRACT = exports.DEX_PARAM_INPUT_FIELD_CONTRACT = exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT = exports.SPECIAL_DEX_FLAG_RESERVED_RANGE = exports.KNOWN_SPECIAL_DEX_FLAGS = exports.DEX_ENCODER_DTO_NORMALIZATION_POLICY = exports.AUDITED_FUNCTION_NEED_WRAP_NATIVE_DEXES = void 0;
+const types_1 = require("../../executor/types");
+// Phase 0 audit: concrete V6 DEX keys under src/dex/** whose needWrapNative
+// member is function-shaped instead of a static boolean.
+exports.AUDITED_FUNCTION_NEED_WRAP_NATIVE_DEXES = [
+    'CurveV1Factory',
+    'CurveV1StableNg',
+];
+exports.DEX_ENCODER_DTO_NORMALIZATION_POLICY = {
+    addressFields: 'lowercase',
+    amountFields: 'decimal-string',
+    calldataFields: '0x-prefixed-hex',
+    swapExchangeData: 'dex-owned-pass-through',
+    unknownFields: 'reject',
+    optionalFields: 'omit-or-null-normalized-to-undefined',
+};
+// Keep this list in lockstep with SpecialDex until Phase 5 adds an enum/list
+// parity test alongside the needWrapNative audit scanner.
+exports.KNOWN_SPECIAL_DEX_FLAGS = [
+    types_1.SpecialDex.DEFAULT,
+    types_1.SpecialDex.SWAP_ON_SWAAP_V2_SINGLE,
+    types_1.SpecialDex.SWAP_ON_BALANCER_V1,
+    types_1.SpecialDex.SWAP_ON_MAKER_PSM,
+    types_1.SpecialDex.SEND_NATIVE,
+    types_1.SpecialDex.SWAP_ON_BALANCER_V2,
+    types_1.SpecialDex.SWAP_ON_UNISWAP_V2_FORK,
+    types_1.SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK,
+    types_1.SpecialDex.SWAP_ON_DYSTOPIA_UNISWAP_V2_FORK_WITH_FEE,
+    types_1.SpecialDex.SWAP_ON_AUGUSTUS_RFQ,
+    types_1.SpecialDex.EXECUTE_VERTICAL_BRANCHING,
+    types_1.SpecialDex.BUY_ON_SOLIDLY_V3,
+    types_1.SpecialDex.SWAP_ON_DEXALOT,
+    types_1.SpecialDex.SWAP_ON_HASHFLOW,
+];
+exports.SPECIAL_DEX_FLAG_RESERVED_RANGE = {
+    min: 0,
+    max: 255,
+};
+exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT = {
+    addressFields: [
+        'route.srcToken',
+        'route.destToken',
+        'swap.srcToken',
+        'swap.destToken',
+    ],
+    amountFields: [
+        'route.srcAmount',
+        'route.destAmount',
+        'swap.srcAmount',
+        'swap.destAmount',
+        'swapExchange.srcAmount',
+        'swapExchange.destAmount',
+    ],
+    booleanFields: [],
+    calldataFields: [],
+    nullableInputFields: ['swapExchange.data'],
+    numberFields: [
+        'route.network',
+        'route.routeIndex',
+        'route.routePercent',
+        'route.blockNumber',
+        'swap.swapIndex',
+        'swapExchange.swapExchangeIndex',
+        'swapExchange.percent',
+    ],
+    passThroughFields: ['swapExchange.data'],
+    strictOutputFields: [],
+};
+exports.DEX_PARAM_INPUT_FIELD_CONTRACT = {
+    addressFields: [
+        ...exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT.addressFields,
+        'srcToken',
+        'destToken',
+        'recipient',
+        'executorAddress',
+    ],
+    amountFields: [
+        ...exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT.amountFields,
+        'srcAmount',
+        'destAmount',
+    ],
+    booleanFields: exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT.booleanFields,
+    calldataFields: [],
+    nullableInputFields: [
+        ...exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT.nullableInputFields,
+        'data',
+    ],
+    numberFields: exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT.numberFields,
+    passThroughFields: [
+        ...exports.NEED_WRAP_NATIVE_INPUT_FIELD_CONTRACT.passThroughFields,
+        'data',
+    ],
+    strictOutputFields: [],
+};
+exports.DEX_EXCHANGE_PARAM_FIELD_CONTRACT = {
+    addressFields: [
+        'wethAddress',
+        'targetExchange',
+        'transferSrcTokenBeforeSwap',
+        'spender',
+    ],
+    amountFields: [],
+    booleanFields: [
+        'needWrapNative',
+        'needUnwrapNative',
+        'skipApproval',
+        'dexFuncHasRecipient',
+        'sendEthButSupportsInsertFromAmount',
+        'specialDexSupportsInsertFromAmount',
+        'swappedAmountNotPresentInExchangeData',
+        'amountsPacked128',
+        'permit2Approval',
+    ],
+    calldataFields: ['exchangeData'],
+    nullableInputFields: [
+        'needUnwrapNative',
+        'skipApproval',
+        'wethAddress',
+        'specialDexFlag',
+        'transferSrcTokenBeforeSwap',
+        'spender',
+        'sendEthButSupportsInsertFromAmount',
+        'specialDexSupportsInsertFromAmount',
+        'swappedAmountNotPresentInExchangeData',
+        'returnAmountPos',
+        'insertFromAmountPos',
+        'amountsPacked128',
+        'permit2Approval',
+    ],
+    numberFields: ['specialDexFlag', 'returnAmountPos', 'insertFromAmountPos'],
+    passThroughFields: [],
+    strictOutputFields: [
+        'needWrapNative',
+        'needUnwrapNative',
+        'skipApproval',
+        'wethAddress',
+        'exchangeData',
+        'targetExchange',
+        'dexFuncHasRecipient',
+        'specialDexFlag',
+        'transferSrcTokenBeforeSwap',
+        'spender',
+        'sendEthButSupportsInsertFromAmount',
+        'specialDexSupportsInsertFromAmount',
+        'swappedAmountNotPresentInExchangeData',
+        'returnAmountPos',
+        'insertFromAmountPos',
+        'amountsPacked128',
+        'permit2Approval',
+    ],
+};
+exports.DIRECT_PARAM_INPUT_FIELD_CONTRACT = {
+    addressFields: ['srcToken', 'destToken', 'beneficiary'],
+    amountFields: ['srcAmount', 'destAmount', 'quotedAmount', 'partnerAndFee'],
+    booleanFields: [],
+    calldataFields: ['permit'],
+    nullableInputFields: ['data'],
+    numberFields: ['network', 'blockNumber'],
+    passThroughFields: ['data'],
+    strictOutputFields: [],
+};
+exports.DIRECT_PARAM_RESULT_FIELD_CONTRACT = {
+    addressFields: [],
+    amountFields: [],
+    booleanFields: [],
+    calldataFields: [],
+    nullableInputFields: [],
+    numberFields: [],
+    passThroughFields: ['params'],
+    strictOutputFields: ['params'],
+};
+exports.WETH_DEPOSIT_WITHDRAW_INPUT_FIELD_CONTRACT = {
+    addressFields: [],
+    amountFields: ['srcAmountWeth', 'destAmountWeth'],
+    booleanFields: [],
+    calldataFields: [],
+    nullableInputFields: [],
+    numberFields: [],
+    passThroughFields: [],
+    strictOutputFields: [],
+};
+exports.WETH_DEPOSIT_WITHDRAW_RESULT_FIELD_CONTRACT = {
+    addressFields: ['deposit.callee', 'withdraw.callee'],
+    amountFields: ['deposit.value', 'withdraw.value'],
+    booleanFields: [],
+    calldataFields: ['deposit.calldata', 'withdraw.calldata'],
+    nullableInputFields: ['deposit', 'withdraw'],
+    numberFields: [],
+    passThroughFields: [],
+    strictOutputFields: ['deposit', 'withdraw'],
+};
+//# sourceMappingURL=types.js.map

package/build/generic-swap-transaction-builder/dex-encoder/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/generic-swap-transaction-builder/dex-encoder/types.ts"],"names":[],"mappings":"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"}

package/build/generic-swap-transaction-builder/orchestration.d.ts

@@ -0,0 +1,65 @@
+import { SwapSide } from '@paraswap/core';
+import type { DepositWithdrawReturn } from '../dex/weth/types';
+import type { ExecutorEncodingContext } from '../executor/encoding-types';
+import type { Address, OptimalRate, OptimalSwap, OptimalSwapExchange } from '../types';
+import type { ResolvedLeg, RoutePlan } from './resolved/types';
+export type GenericDexCallParams = {
+    srcToken: Address;
+    destToken: Address;
+    recipient: Address;
+    srcAmount: string;
+    destAmount: string;
+    wethDeposit: bigint;
+    wethWithdraw: bigint;
+};
+export type WethCallDataProvider = (srcAmountWeth: string, destAmountWeth: string, side: SwapSide) => DepositWithdrawReturn | undefined | Promise<DepositWithdrawReturn | undefined>;
+export type ResolvedLegWithWeth = {
+    resolvedLeg: ResolvedLeg;
+    wethDeposit: bigint;
+    wethWithdraw: bigint;
+};
+export type DexExchangeApprovalRequest = {
+    params: [token: Address, target: Address, permit2: boolean];
+    routePositionKey: string;
+};
+export declare function resolveQuotedAmount(priceRoute: Pick<OptimalRate, 'side' | 'srcAmount' | 'destAmount'>, quotedAmount?: string): string;
+export declare function resolveBeneficiary(userAddress: Address, beneficiary?: Address): Address;
+export declare function resolvePermit(permit?: string): string;
+export declare function buildGenericDexCallParams({ priceRoute, routeIndex, swap, swapIndex, swapExchange, minMaxAmount, dexNeedWrapNative, executionContractAddress, wrappedNativeTokenAddress, augustusV6Address, }: {
+    priceRoute: OptimalRate;
+    routeIndex: number;
+    swap: OptimalSwap;
+    swapIndex: number;
+    swapExchange: OptimalSwapExchange<unknown>;
+    minMaxAmount: string;
+    dexNeedWrapNative: boolean;
+    executionContractAddress: Address;
+    wrappedNativeTokenAddress: Address;
+    augustusV6Address: Address;
+}): GenericDexCallParams;
+export declare function buildResolvedWethPlan({ resolvedLegsWithWeth, side, routePlan, getWethCallData, wrappedNativeTokenAddress, }: {
+    resolvedLegsWithWeth: ResolvedLegWithWeth[];
+    side: SwapSide;
+    routePlan: RoutePlan;
+    getWethCallData: WethCallDataProvider;
+    wrappedNativeTokenAddress: Address;
+}): Promise<{
+    resolvedLegs: ResolvedLeg[];
+    wethPlan?: DepositWithdrawReturn;
+}>;
+export declare function hasAnyRouteWithEthAndDifferentNeedWrapNative({ routePlan, resolvedLegs, wrappedNativeTokenAddress, }: {
+    routePlan: RoutePlan;
+    resolvedLegs: ResolvedLeg[];
+    wrappedNativeTokenAddress: Address;
+}): boolean;
+export declare function buildDexExchangeApprovalRequests({ executorEncodingContext, priceRoute, routePlan, resolvedLegs, }: {
+    executorEncodingContext: ExecutorEncodingContext;
+    priceRoute: OptimalRate;
+    routePlan: RoutePlan;
+    resolvedLegs: ResolvedLeg[];
+}): DexExchangeApprovalRequest[];
+export declare function applyDexExchangeApprovalDecisions({ resolvedLegs, approvalRequests, approvalDecisions, }: {
+    resolvedLegs: ResolvedLeg[];
+    approvalRequests: DexExchangeApprovalRequest[];
+    approvalDecisions: boolean[];
+}): ResolvedLeg[];

package/build/generic-swap-transaction-builder/orchestration.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveQuotedAmount = resolveQuotedAmount;
+exports.resolveBeneficiary = resolveBeneficiary;
+exports.resolvePermit = resolvePermit;
+exports.buildGenericDexCallParams = buildGenericDexCallParams;
+exports.buildResolvedWethPlan = buildResolvedWethPlan;
+exports.hasAnyRouteWithEthAndDifferentNeedWrapNative = hasAnyRouteWithEthAndDifferentNeedWrapNative;
+exports.buildDexExchangeApprovalRequests = buildDexExchangeApprovalRequests;
+exports.applyDexExchangeApprovalDecisions = applyDexExchangeApprovalDecisions;
+const core_1 = require("@paraswap/core");
+const constants_1 = require("../constants");
+const approval_1 = require("../executor/approval");
+const utils_1 = require("../utils");
+const route_plan_1 = require("./resolved/route-plan");
+function resolveQuotedAmount(priceRoute, quotedAmount) {
+    if (quotedAmount)
+        return quotedAmount;
+    return priceRoute.side === core_1.SwapSide.SELL
+        ? priceRoute.destAmount
+        : priceRoute.srcAmount;
+}
+function resolveBeneficiary(userAddress, beneficiary = constants_1.NULL_ADDRESS) {
+    return beneficiary !== constants_1.NULL_ADDRESS &&
+        beneficiary.toLowerCase() !== userAddress.toLowerCase()
+        ? beneficiary
+        : constants_1.NULL_ADDRESS;
+}
+function resolvePermit(permit) {
+    return permit || '0x';
+}
+function buildGenericDexCallParams({ priceRoute, routeIndex, swap, swapIndex, swapExchange, minMaxAmount, dexNeedWrapNative, executionContractAddress, wrappedNativeTokenAddress, augustusV6Address, }) {
+    const side = priceRoute.side;
+    const isMegaSwap = priceRoute.bestRoute.length > 1;
+    const isMultiSwap = !isMegaSwap && priceRoute.bestRoute[0].swaps.length > 1;
+    const isLastSwap = swapIndex === priceRoute.bestRoute[routeIndex].swaps.length - 1;
+    let srcToken = swap.srcToken;
+    let destToken = swap.destToken;
+    let wethDeposit = 0n;
+    let wethWithdraw = 0n;
+    // For buys, apply slippage to the first swap srcAmount in the same
+    // proportion as the complete swap.
+    const srcAmount = swapIndex > 0 || side === core_1.SwapSide.SELL
+        ? swapExchange.srcAmount
+        : ((BigInt(swapExchange.srcAmount) * BigInt(minMaxAmount)) /
+            BigInt(priceRoute.srcAmount)).toString();
+    const destAmount = side === core_1.SwapSide.SELL ? '1' : swapExchange.destAmount;
+    if ((0, utils_1.isETHAddress)(swap.srcToken) && dexNeedWrapNative) {
+        srcToken = wrappedNativeTokenAddress;
+        wethDeposit = BigInt(srcAmount);
+    }
+    const forceUnwrap = (0, utils_1.isETHAddress)(swap.destToken) &&
+        (isMultiSwap || isMegaSwap) &&
+        !dexNeedWrapNative &&
+        !isLastSwap;
+    if (((0, utils_1.isETHAddress)(swap.destToken) && dexNeedWrapNative) || forceUnwrap) {
+        destToken =
+            forceUnwrap && !dexNeedWrapNative ? destToken : wrappedNativeTokenAddress;
+        wethWithdraw = BigInt(swapExchange.destAmount);
+    }
+    const needToWithdrawAfterSwap = destToken === wrappedNativeTokenAddress && wethWithdraw > 0n;
+    return {
+        srcToken,
+        destToken,
+        recipient: needToWithdrawAfterSwap || !isLastSwap || priceRoute.side === core_1.SwapSide.BUY
+            ? executionContractAddress
+            : augustusV6Address,
+        srcAmount,
+        destAmount,
+        wethDeposit,
+        wethWithdraw,
+    };
+}
+async function buildResolvedWethPlan({ resolvedLegsWithWeth, side, routePlan, getWethCallData, wrappedNativeTokenAddress, }) {
+    const { resolvedLegs, srcAmountWethToDeposit, destAmountWethToWithdraw } = resolvedLegsWithWeth.reduce((acc, resolvedLegWithWeth) => {
+        acc.srcAmountWethToDeposit += BigInt(resolvedLegWithWeth.wethDeposit);
+        acc.destAmountWethToWithdraw += BigInt(resolvedLegWithWeth.wethWithdraw);
+        acc.resolvedLegs.push(resolvedLegWithWeth.resolvedLeg);
+        return acc;
+    }, {
+        resolvedLegs: [],
+        srcAmountWethToDeposit: 0n,
+        destAmountWethToWithdraw: 0n,
+    });
+    if (srcAmountWethToDeposit === 0n && destAmountWethToWithdraw === 0n) {
+        return { resolvedLegs };
+    }
+    if (srcAmountWethToDeposit === destAmountWethToWithdraw &&
+        !hasAnyRouteWithEthAndDifferentNeedWrapNative({
+            routePlan,
+            resolvedLegs,
+            wrappedNativeTokenAddress,
+        })) {
+        return { resolvedLegs };
+    }
+    return {
+        resolvedLegs,
+        wethPlan: await getWethCallData(srcAmountWethToDeposit.toString(), destAmountWethToWithdraw.toString(), side),
+    };
+}
+function hasAnyRouteWithEthAndDifferentNeedWrapNative({ routePlan, resolvedLegs, wrappedNativeTokenAddress, }) {
+    const eth = constants_1.ETHER_ADDRESS.toLowerCase();
+    const weth = wrappedNativeTokenAddress.toLowerCase();
+    const resolvedLegByKey = buildResolvedLegMap(resolvedLegs);
+    return !routePlan.routes.every((route, routeIndex) => {
+        const swapExchangeParams = [];
+        route.swaps.forEach((swap, swapIndex) => {
+            swap.swapExchanges.forEach((_swapExchange, swapExchangeIndex) => {
+                const key = (0, route_plan_1.routePositionKey)({
+                    routeIndex,
+                    swapIndex,
+                    swapExchangeIndex,
+                });
+                const curResolvedLeg = resolvedLegByKey.get(key);
+                if (!curResolvedLeg) {
+                    throw new Error(`missing resolved leg for route position ${key}`);
+                }
+                if (swap.destToken.toLowerCase() === weth ||
+                    swap.destToken.toLowerCase() === eth ||
+                    swap.srcToken.toLowerCase() === weth ||
+                    swap.srcToken.toLowerCase() === eth) {
+                    swapExchangeParams.push(curResolvedLeg.exchangeParam);
+                }
+            });
+        });
+        return (swapExchangeParams.every(p => p.needWrapNative === true) ||
+            swapExchangeParams.every(p => p.needWrapNative === false));
+    });
+}
+function buildDexExchangeApprovalRequests({ executorEncodingContext, priceRoute, routePlan, resolvedLegs, }) {
+    const resolvedLegByKey = buildResolvedLegMap(resolvedLegs);
+    const approvalRequests = [];
+    (0, route_plan_1.walkRoutePlan)(routePlan).forEach(routePosition => {
+        const key = (0, route_plan_1.routePositionKey)(routePosition);
+        const curResolvedLeg = resolvedLegByKey.get(key);
+        if (!curResolvedLeg) {
+            throw new Error(`missing resolved leg for route position ${key}`);
+        }
+        const swap = priceRoute.bestRoute[routePosition.routeIndex].swaps[routePosition.swapIndex];
+        const curExchangeParam = curResolvedLeg.exchangeParam;
+        const approveParams = (0, approval_1.getApprovalTokenAndTarget)(swap, curExchangeParam, executorEncodingContext);
+        if (approveParams) {
+            approvalRequests.push({
+                params: [
+                    approveParams.token,
+                    approveParams.target,
+                    !!curExchangeParam.permit2Approval,
+                ],
+                routePositionKey: key,
+            });
+        }
+    });
+    return approvalRequests;
+}
+function applyDexExchangeApprovalDecisions({ resolvedLegs, approvalRequests, approvalDecisions, }) {
+    if (approvalDecisions.length !== approvalRequests.length) {
+        throw new Error('approval decision length must match approval request count');
+    }
+    const resolvedLegByKey = buildResolvedLegMap(resolvedLegs);
+    approvalDecisions.forEach((alreadyApproved, index) => {
+        if (alreadyApproved)
+            return;
+        const [token, target] = approvalRequests[index].params;
+        const key = approvalRequests[index].routePositionKey;
+        const curResolvedLeg = resolvedLegByKey.get(key);
+        if (!curResolvedLeg) {
+            throw new Error(`missing resolved leg for route position ${key}`);
+        }
+        resolvedLegByKey.set(key, {
+            ...curResolvedLeg,
+            exchangeParam: {
+                ...curResolvedLeg.exchangeParam,
+                approveData: {
+                    token: normalizeAddress(token),
+                    target: normalizeAddress(target),
+                },
+            },
+        });
+    });
+    return resolvedLegs.map(resolvedLeg => {
+        const key = (0, route_plan_1.routePositionKey)(resolvedLeg);
+        const curResolvedLeg = resolvedLegByKey.get(key);
+        if (!curResolvedLeg) {
+            throw new Error(`missing resolved leg for route position ${key}`);
+        }
+        return curResolvedLeg;
+    });
+}
+function buildResolvedLegMap(resolvedLegs) {
+    return new Map(resolvedLegs.map(resolvedLeg => [
+        (0, route_plan_1.routePositionKey)(resolvedLeg),
+        resolvedLeg,
+    ]));
+}
+function normalizeAddress(address) {
+    return address.toLowerCase();
+}
+//# sourceMappingURL=orchestration.js.map