@shapeshiftoss/swapper 17.8.0 → 18.1.0

package/dist/esm/swappers/ZrxSwapper/endpoints.js

@@ -1,72 +1,11 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
-import BigNumber from 'bignumber.js';
-import { concat, numberToHex, size } from 'viem';
-import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getZrxTradeQuote } from './getZrxTradeQuote/getZrxTradeQuote.js';
 import { getZrxTradeRate } from './getZrxTradeRate/getZrxTradeRate.js';
 export const zrxApi = {
-    getTradeQuote: async (input, { assertGetEvmChainAdapter, assetsById, config }) => {
-        const tradeQuoteResult = await getZrxTradeQuote(input, assertGetEvmChainAdapter, assetsById, config.VITE_ZRX_BASE_URL);
-        return tradeQuoteResult.map(tradeQuote => [tradeQuote]);
-    },
-    getTradeRate: async (input, { assetsById, config }) => {
-        const tradeRateResult = await getZrxTradeRate(input, assetsById, config.VITE_ZRX_BASE_URL);
-        return tradeRateResult.map(tradeRate => [tradeRate]);
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, permit2Signature, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, zrxTransactionMetadata } = step;
-        if (!zrxTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { value, to } = zrxTransactionMetadata;
-        const data = (() => {
-            if (!permit2Signature)
-                return zrxTransactionMetadata.data;
-            // Append the signature to the calldata
-            // https://0x.org/docs/0x-swap-api/guides/swap-tokens-with-0x-swap-api#5-append-signature-length-and-signature-data-to-transactiondata
-            const signatureLengthInHex = numberToHex(size(permit2Signature), {
-                signed: false,
-                size: 32,
-            });
-            return concat([zrxTransactionMetadata.data, signatureLengthInHex, permit2Signature]);
-        })();
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        return adapter.buildCustomApiTx({
-            accountNumber,
-            data,
-            from,
-            to,
-            value,
-            ...feeData,
-            // Use the higher amount of the node or the API, as the node doesn't always provide enough gas padding for total gas used.
-            gasLimit: BigNumber.max(feeData.gasLimit, zrxTransactionMetadata.gas ?? '0').toFixed(),
-        });
-    },
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, permit2Signature, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { sellAsset, zrxTransactionMetadata } = step;
-        if (!zrxTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { value, to } = zrxTransactionMetadata;
-        const data = (() => {
-            if (!permit2Signature)
-                return zrxTransactionMetadata.data;
-            // Append the signature to the calldata
-            // https://0x.org/docs/0x-swap-api/guides/swap-tokens-with-0x-swap-api#5-append-signature-length-and-signature-data-to-transactiondata
-            const signatureLengthInHex = numberToHex(size(permit2Signature), {
-                signed: false,
-                size: 32,
-            });
-            return concat([zrxTransactionMetadata.data, signatureLengthInHex, permit2Signature]);
-        })();
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        return feeData.networkFeeCryptoBaseUnit;
-    },
+    getTradeQuote: (input, deps) => getZrxTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getZrxTradeRate(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
     checkTradeStatus: checkEvmSwapStatus,
 };

package/dist/esm/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.d.ts

@@ -1,6 +1,4 @@
-import type { ChainId } from '@shapeshiftoss/caip';
-import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
-import type { AssetsByIdPartial } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
-import type { GetEvmTradeQuoteInputBase, SwapErrorRight, TradeQuote } from '../../../types.js';
-export declare function getZrxTradeQuote(input: GetEvmTradeQuoteInputBase, assertGetEvmChainAdapter: (chainId: ChainId) => EvmChainAdapter, assetsById: AssetsByIdPartial, zrxBaseUrl: string): Promise<Result<TradeQuote, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { ZrxTradeQuoteInput } from '../types.js';
+export declare const getZrxTradeQuote: (input: ZrxTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/ZrxSwapper/getZrxTradeQuote/getZrxTradeQuote.js

@@ -1,17 +1,25 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
-import { PERMIT2_CONTRACT } from '@shapeshiftoss/contracts';
-import { bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { assertQuoteAddresses, makeSwapErrorRight } from '../../../utils/index.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
 import { fetchZrxQuote } from '../utils/fetchFromZrx.js';
-import { assertValidTrade, calculateBuyAmountBeforeFeesCryptoBaseUnit, calculateRate, getProtocolFees, } from '../utils/helpers/helpers.js';
-export async function getZrxTradeQuote(input, assertGetEvmChainAdapter, assetsById, zrxBaseUrl) {
-    const { sellAsset, buyAsset, accountNumber, receiveAddress, affiliateBps, chainId, supportsEIP1559, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+import { getZrxStepData } from '../utils/getZrxStepData.js';
+import { getZrxTradeContext } from '../utils/getZrxTradeContext.js';
+import { assertValidTrade, isWrappedNativeSell } from '../utils/helpers.js';
+export const getZrxTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, accountNumber, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    // The 0x order binds taker, so a quote for a different receive address is not executable by the sender
+    if (sendAddress !== receiveAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'Cross-account trade not supported for ZRX',
+            code: TradeQuoteError.UnsupportedTradePair,
+        }));
+    }
     const assertion = assertValidTrade({ buyAsset, sellAsset });
     if (assertion.isErr())
         return Err(assertion.unwrapErr());
@@ -25,15 +33,13 @@ export async function getZrxTradeQuote(input, assertGetEvmChainAdapter, assetsBy
         sellAddress: receiveAddress,
         affiliateBps,
         slippageTolerancePercentageDecimal,
-        zrxBaseUrl,
+        zrxBaseUrl: deps.config.VITE_ZRX_BASE_URL,
     });
     if (maybeZrxQuoteResponse.isErr())
         return Err(maybeZrxQuoteResponse.unwrapErr());
-    const zrxQuoteResponse = maybeZrxQuoteResponse.unwrap();
-    const { sellAmount, buyAmount, fees, permit2, transaction, route } = zrxQuoteResponse;
+    const { sellAmount, buyAmount, fees, permit2, transaction, route } = maybeZrxQuoteResponse.unwrap();
     const permit2Eip712 = permit2?.eip712;
-    const isWrappedNative = route.fills.some(fill => fill.source === 'Wrapped_Native' && fill.proportionBps === '10000');
-    if (!isNativeEvmAsset(sellAsset.assetId) && !isWrappedNative && !permit2Eip712) {
+    if (!isNativeEvmAsset(sellAsset.assetId) && !isWrappedNativeSell(route) && !permit2Eip712) {
         return Err(makeSwapErrorRight({
             message: 'Missing required Permit2 metadata from 0x response',
             code: TradeQuoteError.InvalidResponse,
@@ -47,75 +53,38 @@ export async function getZrxTradeQuote(input, assertGetEvmChainAdapter, assetsBy
             details: { transaction, permit2Eip712 },
         }));
     }
-    const transactionMetadata = {
-        to: transaction.to,
-        data: transaction.data,
-        gasPrice: transaction.gasPrice || undefined,
-        gas: transaction.gas || undefined,
-        value: transaction.value,
-    };
-    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
-    const buyAmountBeforeFeesCryptoBaseUnit = calculateBuyAmountBeforeFeesCryptoBaseUnit({
-        buyAmount,
-        fees,
-        buyAsset,
-        sellAsset,
+    const maybeContext = getZrxTradeContext({
+        input,
+        deps,
+        slippageTolerancePercentageDecimal,
+        normalizedQuote: { buyAmount, sellAmount, fees, route },
     });
-    try {
-        const adapter = assertGetEvmChainAdapter(chainId);
-        const { average } = await adapter.getGasFeeData();
-        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
-            ...average,
-            supportsEIP1559: Boolean(supportsEIP1559),
-            // add gas limit buffer to account for the fact we perform all of our validation on the trade quote estimations
-            // which are inaccurate and not what we use for the tx to broadcast
-            gasLimit: bnOrZero(transaction.gas).times(1.2).toFixed(),
-        });
-        return Ok({
-            id: uuid(),
-            quoteOrRate: 'quote',
-            receiveAddress,
-            affiliateBps,
-            // Slippage protection is always enabled for 0x api v2 unlike api v1 which was only supported on specific pairs.
-            slippageTolerancePercentageDecimal,
-            rate,
-            swapperName: SwapperName.Zrx,
-            steps: [
-                {
-                    // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
-                    estimatedExecutionTimeMs: 0,
-                    allowanceContract: isNativeEvmAsset(sellAsset.assetId) || isWrappedNative ? undefined : PERMIT2_CONTRACT,
-                    buyAsset,
-                    sellAsset,
-                    accountNumber,
-                    rate,
-                    feeData: {
-                        protocolFees: getProtocolFees({ fees, sellAsset, assetsById }),
-                        networkFeeCryptoBaseUnit,
-                    },
-                    buyAmountBeforeFeesCryptoBaseUnit,
-                    buyAmountAfterFeesCryptoBaseUnit: buyAmount,
-                    sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    source: SwapperName.Zrx,
-                    affiliateFee: buildAffiliateFee({
-                        strategy: 'buy_asset',
-                        affiliateBps,
-                        sellAsset,
-                        buyAsset,
-                        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                        buyAmountCryptoBaseUnit: buyAmount,
-                    }),
-                    permit2Eip712: permit2Eip712,
-                    zrxTransactionMetadata: transactionMetadata,
-                },
-            ],
-        });
-    }
-    catch (err) {
-        return Err(makeSwapErrorRight({
-            message: 'failed to get fee data',
-            cause: err,
-            code: TradeQuoteError.NetworkFeeEstimationFailed,
-        }));
-    }
-}
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getZrxStepData({
+        ...stepDataArgs,
+        type: 'quote',
+        input,
+        transaction,
+        permit2Eip712,
+        from: receiveAddress,
+    });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
+};

package/dist/esm/swappers/ZrxSwapper/getZrxTradeRate/getZrxTradeRate.d.ts

@@ -1,4 +1,4 @@
-import type { AssetsByIdPartial } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
-import type { GetEvmTradeRateInput, SwapErrorRight, TradeRate } from '../../../types.js';
-export declare function getZrxTradeRate(input: GetEvmTradeRateInput, assetsById: AssetsByIdPartial, zrxBaseUrl: string): Promise<Result<TradeRate, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { ZrxTradeRateInput } from '../types.js';
+export declare const getZrxTradeRate: (input: ZrxTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/ZrxSwapper/getZrxTradeRate/getZrxTradeRate.js

@@ -1,14 +1,12 @@
-import { PERMIT2_CONTRACT } from '@shapeshiftoss/contracts';
 import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
 import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
 import { SwapperName } from '../../../types.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
 import { fetchZrxPrice } from '../utils/fetchFromZrx.js';
-import { assertValidTrade, calculateBuyAmountBeforeFeesCryptoBaseUnit, calculateRate, getProtocolFees, } from '../utils/helpers/helpers.js';
-export async function getZrxTradeRate(input, assetsById, zrxBaseUrl) {
-    const { sellAsset, buyAsset, accountNumber, receiveAddress, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
+import { getZrxStepData } from '../utils/getZrxStepData.js';
+import { getZrxTradeContext } from '../utils/getZrxTradeContext.js';
+import { assertValidTrade } from '../utils/helpers.js';
+export const getZrxTradeRate = async (input, deps) => {
+    const { accountNumber, sellAsset, buyAsset, receiveAddress, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
     const assertion = assertValidTrade({ buyAsset, sellAsset });
     if (assertion.isErr())
         return Err(assertion.unwrapErr());
@@ -22,56 +20,40 @@ export async function getZrxTradeRate(input, assetsById, zrxBaseUrl) {
         sellAddress: receiveAddress,
         affiliateBps,
         slippageTolerancePercentageDecimal,
-        zrxBaseUrl,
+        zrxBaseUrl: deps.config.VITE_ZRX_BASE_URL,
     });
     if (maybeZrxPriceResponse.isErr())
         return Err(maybeZrxPriceResponse.unwrapErr());
-    const zrxPriceResponse = maybeZrxPriceResponse.unwrap();
-    const { buyAmount, sellAmount, fees, totalNetworkFee, route } = zrxPriceResponse;
-    const isWrappedNative = route.fills.some(fill => fill.source === 'Wrapped_Native' && fill.proportionBps === '10000');
-    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
-    const buyAmountBeforeFeesCryptoBaseUnit = calculateBuyAmountBeforeFeesCryptoBaseUnit({
-        buyAmount,
-        fees,
-        buyAsset,
-        sellAsset,
+    const { buyAmount, sellAmount, fees, totalNetworkFee, route } = maybeZrxPriceResponse.unwrap();
+    const maybeContext = getZrxTradeContext({
+        input,
+        deps,
+        slippageTolerancePercentageDecimal,
+        normalizedQuote: { buyAmount, sellAmount, fees, route },
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getZrxStepData({
+        ...stepDataArgs,
+        type: 'rate',
+        input,
+        totalNetworkFee,
     });
-    return Ok({
-        id: uuid(),
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
         quoteOrRate: 'rate',
-        accountNumber: undefined,
         receiveAddress,
-        affiliateBps,
-        // Slippage protection is always enabled for 0x api v2 unlike api v1 which was only supported on specific pairs.
-        slippageTolerancePercentageDecimal,
-        rate,
-        swapperName: SwapperName.Zrx,
         steps: [
             {
-                // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
-                estimatedExecutionTimeMs: 0,
-                allowanceContract: isNativeEvmAsset(sellAsset.assetId) || isWrappedNative ? undefined : PERMIT2_CONTRACT,
-                buyAsset,
-                sellAsset,
+                ...stepCommon,
                 accountNumber,
-                rate,
-                feeData: {
-                    protocolFees: getProtocolFees({ fees, sellAsset, assetsById }),
-                    networkFeeCryptoBaseUnit: totalNetworkFee,
-                },
-                buyAmountBeforeFeesCryptoBaseUnit,
-                buyAmountAfterFeesCryptoBaseUnit: buyAmount,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                source: SwapperName.Zrx,
-                affiliateFee: buildAffiliateFee({
-                    strategy: 'buy_asset',
-                    affiliateBps,
-                    sellAsset,
-                    buyAsset,
-                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    buyAmountCryptoBaseUnit: buyAmount,
-                }),
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
             },
         ],
-    });
-}
+    };
+    return Ok([tradeRate]);
+};

package/dist/esm/swappers/ZrxSwapper/index.d.ts

@@ -0,0 +1,2 @@
+export { zrxApi } from './endpoints.js';
+export { zrxSwapper } from './ZrxSwapper.js';

package/dist/esm/swappers/ZrxSwapper/index.js

@@ -0,0 +1,2 @@
+export { zrxApi } from './endpoints.js';
+export { zrxSwapper } from './ZrxSwapper.js';

package/dist/esm/swappers/ZrxSwapper/types.d.ts

@@ -1,5 +1,8 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
 import type { Address, TypedData } from 'viem';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types.js';
+export type ZrxTradeQuoteInput = GetEvmTradeQuoteInput;
+export type ZrxTradeRateInput = GetEvmTradeRateInput;
 export declare const zrxSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet];
 export type ZrxSupportedChainId = (typeof zrxSupportedChainIds)[number];
 type ZrxFee = {

package/dist/esm/swappers/ZrxSwapper/utils/fetchFromZrx.js

@@ -1,8 +1,8 @@
 import { viemNetworkIdByChainId } from '@shapeshiftoss/contracts';
 import { bn, convertDecimalPercentageToBasisPoints } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
-import { assetIdToZrxToken } from './helpers/helpers.js';
+import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
+import { assetIdToZrxToken } from './helpers.js';
 import { zrxServiceFactory } from './zrxService.js';
 const fetchFromZrx = async ({ quoteOrRate, buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sellAddress, affiliateBps, slippageTolerancePercentageDecimal, zrxBaseUrl, }) => {
     const zrxService = zrxServiceFactory({ baseUrl: zrxBaseUrl });

package/dist/esm/swappers/ZrxSwapper/utils/getZrxStepData.d.ts

@@ -0,0 +1,23 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { ZrxQuoteResponse } from '../types.js';
+export type GetZrxStepDataArgs = StepDataArgs<unknown, {
+    totalNetworkFee: string | null;
+}, {
+    transaction: ZrxQuoteResponse['transaction'];
+    permit2Eip712: NonNullable<ZrxQuoteResponse['permit2']>['eip712'] | undefined;
+}>;
+type ZrxRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type ZrxQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getZrxStepData(args: Extract<GetZrxStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<ZrxRateStepData, SwapErrorRight>>;
+export declare function getZrxStepData(args: Extract<GetZrxStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<ZrxQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/ZrxSwapper/utils/getZrxStepData.js

@@ -0,0 +1,42 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+export async function getZrxStepData(args) {
+    if (args.type === 'rate') {
+        const stepData = {
+            networkFeeCryptoBaseUnit: bnOrZero(args.totalNetworkFee).toFixed(),
+        };
+        return Ok(stepData);
+    }
+    const { sellAsset, transaction, permit2Eip712, from, input, deps } = args;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+        to: transaction.to,
+        data: transaction.data,
+        value: transaction.value,
+        // 0x simulate with a valid permit2 signature, which can't be reproduced before signing, so trust their gas limit
+        gasLimit: transaction.gas || undefined,
+        ...(permit2Eip712 && {
+            signatureRequired: {
+                type: 'permit2',
+                eip712: permit2Eip712,
+            },
+        }),
+    };
+    try {
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter: deps.assertGetEvmChainAdapter(sellAsset.chainId),
+            transactionData,
+            from,
+            supportsEIP1559: 'supportsEIP1559' in input ? input.supportsEIP1559 : false,
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getZrxStepData', error));
+    }
+}

package/dist/esm/swappers/ZrxSwapper/utils/getZrxTradeContext.d.ts

@@ -0,0 +1,27 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { ZrxFees, ZrxPriceResponse, ZrxTradeQuoteInput, ZrxTradeRateInput } from '../types.js';
+import { getProtocolFees } from './helpers.js';
+type NormalizedZrxQuote = {
+    buyAmount: string;
+    sellAmount: string;
+    fees: ZrxFees;
+    route: ZrxPriceResponse['route'];
+};
+type ZrxTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: ReturnType<typeof getProtocolFees>;
+    stepDataArgs: {
+        deps: SwapperDeps;
+        sellAsset: Asset;
+    };
+};
+export declare const getZrxTradeContext: ({ input, deps, slippageTolerancePercentageDecimal, normalizedQuote, }: {
+    input: ZrxTradeQuoteInput | ZrxTradeRateInput;
+    deps: SwapperDeps;
+    slippageTolerancePercentageDecimal: string;
+    normalizedQuote: NormalizedZrxQuote;
+}) => Result<ZrxTradeContext, SwapErrorRight>;
+export {};

package/dist/esm/swappers/ZrxSwapper/utils/getZrxTradeContext.js

@@ -0,0 +1,55 @@
+import { PERMIT2_CONTRACT } from '@shapeshiftoss/contracts';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName } from '../../../types.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { isNativeEvmAsset } from '../../../utils/helpers.js';
+import { calculateBuyAmountBeforeFeesCryptoBaseUnit, calculateRate, getProtocolFees, isWrappedNativeSell, } from './helpers.js';
+export const getZrxTradeContext = ({ input, deps, slippageTolerancePercentageDecimal, normalizedQuote, }) => {
+    const { assetsById } = deps;
+    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const { buyAmount, sellAmount, fees, route } = normalizedQuote;
+    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const maybeBuyAmountBeforeFeesCryptoBaseUnit = calculateBuyAmountBeforeFeesCryptoBaseUnit({
+        buyAmount,
+        fees,
+        buyAsset,
+        sellAsset,
+    });
+    if (maybeBuyAmountBeforeFeesCryptoBaseUnit.isErr())
+        return Err(maybeBuyAmountBeforeFeesCryptoBaseUnit.unwrapErr());
+    // Native and fully wrapped-native sells need no Permit2 approval
+    const allowanceContract = isNativeEvmAsset(sellAsset.assetId) || isWrappedNativeSell(route) ? '' : PERMIT2_CONTRACT;
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate,
+            swapperName: SwapperName.Zrx,
+            affiliateBps,
+            // Slippage protection is always enabled for 0x api v2 unlike api v1 which was only supported on specific pairs.
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            // Assume instant execution since this is a same-chain AMM Tx which will happen within the same block
+            estimatedExecutionTimeMs: 0,
+            allowanceContract,
+            rate,
+            buyAsset,
+            sellAsset,
+            buyAmountBeforeFeesCryptoBaseUnit: maybeBuyAmountBeforeFeesCryptoBaseUnit.unwrap(),
+            buyAmountAfterFeesCryptoBaseUnit: buyAmount,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            source: SwapperName.Zrx,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmount,
+            }),
+        },
+        protocolFees: getProtocolFees({ fees, sellAsset, assetsById }),
+        stepDataArgs: { deps, sellAsset },
+    });
+};

package/dist/esm/swappers/ZrxSwapper/utils/{helpers/helpers.d.ts → helpers.d.ts}

@@ -1,14 +1,17 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset, AssetsByIdPartial } from '@shapeshiftoss/types';
 import { KnownChainIds } from '@shapeshiftoss/types';
-import type { ZrxFees } from '../../types.js';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+import type { ZrxFees, ZrxPriceResponse } from '../types.js';
 export declare const assetIdToZrxToken: (assetId: AssetId) => string;
 export declare const zrxTokenToAssetId: (token: string, chainId: ChainId) => AssetId;
 export declare const isSupportedChainId: (chainId: ChainId) => chainId is KnownChainIds.EthereumMainnet | KnownChainIds.AvalancheMainnet | KnownChainIds.OptimismMainnet | KnownChainIds.BnbSmartChainMainnet | KnownChainIds.PolygonMainnet | KnownChainIds.ArbitrumMainnet | KnownChainIds.BaseMainnet;
+export declare const isWrappedNativeSell: (route: ZrxPriceResponse['route']) => boolean;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
-}) => import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<boolean, never>;
+}) => import("@sniptt/monads/build/result/result").ResOk<boolean, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, SwapErrorRight>;
 export declare const calculateRate: ({ buyAmount, sellAmount, buyAsset, sellAsset, }: {
     buyAmount: string;
     sellAmount: string;
@@ -20,7 +23,7 @@ export declare const calculateBuyAmountBeforeFeesCryptoBaseUnit: ({ buyAmount, f
     fees: ZrxFees;
     buyAsset: Asset;
     sellAsset: Asset;
-}) => string | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight>;
+}) => Result<string, SwapErrorRight>;
 export declare const getProtocolFees: ({ fees, sellAsset, assetsById, }: {
     fees: ZrxFees;
     sellAsset: Asset;

package/dist/esm/swappers/ZrxSwapper/utils/{helpers/helpers.js → helpers.js}

@@ -3,10 +3,10 @@ import { KnownChainIds } from '@shapeshiftoss/types';
 import { bn, convertPrecision } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { getAddress, isAddressEqual } from 'viem';
-import { TradeQuoteError } from '../../../../types.js';
-import { makeSwapErrorRight } from '../../../../utils.js';
-import { zrxSupportedChainIds } from '../../types.js';
-import { ZRX_NATIVE_ASSET_ADDRESS } from '../constants.js';
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { zrxSupportedChainIds } from '../types.js';
+import { ZRX_NATIVE_ASSET_ADDRESS } from './constants.js';
 // converts an asset to zrx token (symbol or contract address)
 export const assetIdToZrxToken = (assetId) => {
     const { assetReference, assetNamespace } = fromAssetId(assetId);
@@ -69,6 +69,8 @@ export const zrxTokenToAssetId = (token, chainId) => {
 export const isSupportedChainId = (chainId) => {
     return zrxSupportedChainIds.includes(chainId);
 };
+// A fully wrapped-native sell (e.g. WETH->ETH) needs no Permit2 allowance
+export const isWrappedNativeSell = (route) => route.fills.some(fill => fill.source === 'Wrapped_Native' && fill.proportionBps === '10000');
 export const assertValidTrade = ({ buyAsset, sellAsset, }) => {
     const sellAssetChainId = sellAsset.chainId;
     const buyAssetChainId = buyAsset.chainId;
@@ -117,7 +119,7 @@ export const calculateBuyAmountBeforeFeesCryptoBaseUnit = ({ buyAmount, fees, bu
     }
     // We can safely add the integrator fee now we know its the correct asset.
     const integratorFeeCryptoBaseUnit = fees.integratorFee?.amount ?? '0';
-    return bn(buyAmount).plus(integratorFeeCryptoBaseUnit).toFixed();
+    return Ok(bn(buyAmount).plus(integratorFeeCryptoBaseUnit).toFixed());
 };
 export const getProtocolFees = ({ fees, sellAsset, assetsById, }) => {
     if (!fees.zeroExFee)

package/dist/esm/swappers/ZrxSwapper/utils/zrxService.js

@@ -1,5 +1,5 @@
 import identity from 'lodash/identity';
-import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const maxAge = 5 * 1000; // 5 seconds
 const cachedUrls = ['/swap/v1/price', '/swap/permit2/price'];
 const axiosConfig = {