@shapeshiftoss/swapper 17.6.6 → 17.6.7

package/dist/esm/swappers/ThorchainSwapper/utils/longTailHelpers.d.ts

@@ -0,0 +1,48 @@
+import type { UNISWAP_V3_QUOTER_ABI } from '@shapeshiftoss/contracts';
+import type { Asset } from '@shapeshiftoss/types';
+import { Token } from '@uniswap/sdk-core';
+import { FeeAmount } from '@uniswap/v3-sdk';
+import type { Address, GetContractReturnType, PublicClient } from 'viem';
+import type { ThornodePoolResponse } from '../../../thorchain-utils/index.js';
+import { TradeType } from '../../../thorchain-utils/index.js';
+export declare const getWrappedToken: (nativeAsset: Asset) => Token;
+export declare const getTokenFromAsset: (asset: Asset) => Token;
+export declare function getTradeType(sellAssetPool: ThornodePoolResponse | undefined, buyAssetPool: ThornodePoolResponse | undefined, sellPoolId: string | undefined, buyPoolId: string | undefined): TradeType | undefined;
+export declare enum AggregatorContract {
+    TSAggregatorUniswapV3_100 = "0xbd68cbe6c247e2c3a0e36b8f0e24964914f26ee8",
+    TSAggregatorUniswapV3_500 = "0xe4ddca21881bac219af7f217703db0475d2a9f02",
+    TSAggregatorUniswapV3_3000 = "0x11733abf0cdb43298f7e949c930188451a9a9ef2",
+    TSAggregatorUniswapV3_10000 = "0xb33874810e5395eb49d8bd7e912631db115d5a03"
+}
+export declare const contractToFeeAmountMap: Record<AggregatorContract, FeeAmount>;
+export declare const feeAmountToContractMap: Record<FeeAmount, AggregatorContract>;
+export declare const generateV3PoolAddressesAcrossFeeRange: (factoryAddress: string, tokenA: Token, tokenB: Token) => Map<Address, {
+    token0Address: Address;
+    token1Address: Address;
+    fee: FeeAmount;
+}>;
+type ContractData = {
+    fee: FeeAmount;
+    tokenIn: Address;
+    tokenOut: Address;
+};
+export declare const getContractDataByPool: (poolAddresses: Map<Address, {
+    token0Address: Address;
+    token1Address: Address;
+    fee: FeeAmount;
+}>, publicClient: PublicClient, tokenAAddress: string, tokenBAddress: string) => Map<Address, ContractData>;
+export declare const getQuotedAmountOutByPool: (poolContracts: Map<Address, ContractData>, sellAmount: bigint, quoterContract: GetContractReturnType<typeof UNISWAP_V3_QUOTER_ABI, PublicClient, Address>) => Promise<Map<Address, bigint>>;
+export declare const selectBestRate: (quotedAmounts: Map<Address, bigint>) => [Address | undefined, bigint | undefined];
+export declare const shortenedNativeAssetNameByNativeAssetName: {
+    readonly 'THOR.RUNE': "r";
+    readonly 'BTC.BTC': "b";
+    readonly 'ETH.ETH': "e";
+    readonly 'BNB.BNB': "n";
+    readonly 'GAIA.ATOM': "g";
+    readonly 'DOGE.DOGE': "d";
+    readonly 'LTC.LTC': "l";
+    readonly 'BCH.BCH': "c";
+    readonly 'AVAX.AVAX': "a";
+    readonly 'BSC.BNB': "s";
+};
+export {};

package/dist/esm/swappers/ThorchainSwapper/utils/longTailHelpers.js

@@ -0,0 +1,136 @@
+import { avalancheChainId, bscChainId, ethChainId, fromAssetId } from '@shapeshiftoss/caip';
+import { I_UNISWAP_V3_POOL_ABI } from '@shapeshiftoss/contracts';
+import { Token } from '@uniswap/sdk-core';
+import { computePoolAddress, FeeAmount } from '@uniswap/v3-sdk';
+import { getAddress, getContract } from 'viem';
+import { TradeType } from '../../../thorchain-utils/index.js';
+import { WAVAX_TOKEN, WBNB_TOKEN, WETH_TOKEN } from './constants.js';
+export const getWrappedToken = (nativeAsset) => {
+    switch (nativeAsset.chainId) {
+        case ethChainId:
+            return WETH_TOKEN;
+        case bscChainId:
+            return WBNB_TOKEN;
+        case avalancheChainId:
+            return WAVAX_TOKEN;
+        default:
+            throw new Error(`getWrappedToken: Unsupported chainId ${nativeAsset.chainId}`);
+    }
+};
+export const getTokenFromAsset = (asset) => {
+    const { symbol, name, precision, assetId } = asset;
+    const { chainReference: chainReferenceStr, assetReference } = fromAssetId(assetId);
+    const chainReference = Number(chainReferenceStr);
+    return new Token(chainReference, assetReference, precision, symbol, name);
+};
+export function getTradeType(sellAssetPool, buyAssetPool, sellPoolId, buyPoolId) {
+    switch (true) {
+        case !!sellAssetPool && !!buyAssetPool:
+        case !!buyAssetPool && !sellAssetPool && ['THOR.RUNE', 'THOR.TCY'].includes(sellPoolId ?? ''):
+        case !!sellAssetPool && !buyAssetPool && ['THOR.RUNE', 'THOR.TCY'].includes(buyPoolId ?? ''):
+            return TradeType.L1ToL1;
+        case ['THOR.RUNE', 'THOR.TCY'].includes(sellPoolId ?? '') && !buyAssetPool:
+            return TradeType.L1ToLongTail;
+        case !!sellAssetPool && !buyAssetPool:
+            return TradeType.L1ToLongTail;
+        case !sellAssetPool && !buyAssetPool:
+            return TradeType.LongTailToLongTail;
+        case !sellAssetPool && !!buyAssetPool:
+            return TradeType.LongTailToL1;
+        default:
+            return undefined;
+    }
+}
+// TODO: we need to fetch these contracts dynamically, as the whitelist can change
+export var AggregatorContract;
+(function (AggregatorContract) {
+    AggregatorContract["TSAggregatorUniswapV3_100"] = "0xbd68cbe6c247e2c3a0e36b8f0e24964914f26ee8";
+    AggregatorContract["TSAggregatorUniswapV3_500"] = "0xe4ddca21881bac219af7f217703db0475d2a9f02";
+    AggregatorContract["TSAggregatorUniswapV3_3000"] = "0x11733abf0cdb43298f7e949c930188451a9a9ef2";
+    AggregatorContract["TSAggregatorUniswapV3_10000"] = "0xb33874810e5395eb49d8bd7e912631db115d5a03";
+})(AggregatorContract || (AggregatorContract = {}));
+export const contractToFeeAmountMap = {
+    [AggregatorContract.TSAggregatorUniswapV3_100]: FeeAmount.LOWEST,
+    [AggregatorContract.TSAggregatorUniswapV3_500]: FeeAmount.LOW,
+    [AggregatorContract.TSAggregatorUniswapV3_3000]: FeeAmount.MEDIUM,
+    [AggregatorContract.TSAggregatorUniswapV3_10000]: FeeAmount.HIGH,
+};
+export const feeAmountToContractMap = Object.entries(contractToFeeAmountMap).reduce((acc, [key, value]) => ({ ...acc, [value]: key }), {});
+export const generateV3PoolAddressesAcrossFeeRange = (factoryAddress, tokenA, tokenB) => {
+    const [token0, token1] = tokenA.sortsBefore(tokenB) ? [tokenA, tokenB] : [tokenB, tokenA];
+    const poolAddresses = new Map();
+    Object.values(FeeAmount)
+        .filter((value) => typeof value === 'number')
+        .forEach((fee) => {
+        const poolAddress = computePoolAddress({
+            factoryAddress,
+            tokenA,
+            tokenB,
+            fee,
+        });
+        poolAddresses.set(getAddress(poolAddress), {
+            fee: fee,
+            token0Address: getAddress(token0.address),
+            token1Address: getAddress(token1.address),
+        });
+    });
+    return poolAddresses;
+};
+export const getContractDataByPool = (poolAddresses, publicClient, tokenAAddress, tokenBAddress) => {
+    const poolContracts = new Map();
+    Array.from(poolAddresses.entries()).forEach(([address, { fee, token0Address, token1Address }]) => {
+        const poolContract = getContract({
+            abi: I_UNISWAP_V3_POOL_ABI,
+            address,
+            client: publicClient,
+        });
+        const tokenIn = token0Address === tokenAAddress ? token0Address : token1Address;
+        const tokenOut = token1Address === tokenBAddress ? token1Address : token0Address;
+        try {
+            poolContracts.set(poolContract.address, { fee, tokenIn, tokenOut });
+        }
+        catch {
+            // The pool contract is not supported, that's ok - skip it without logging an error
+            return;
+        }
+    });
+    return poolContracts;
+};
+export const getQuotedAmountOutByPool = async (poolContracts, sellAmount, quoterContract) => {
+    const results = await Promise.allSettled(Array.from(poolContracts.entries()).map(async ([poolContract, data]) => {
+        const { fee, tokenIn, tokenOut } = data;
+        try {
+            const params = [tokenIn, tokenOut, fee, sellAmount, BigInt(0)];
+            const { result: quotedAmountOut } = await quoterContract.simulate.quoteExactInputSingle(params);
+            return [poolContract, quotedAmountOut];
+        }
+        catch {
+            // The pool contract is not supported, that's ok - skip it without logging an error
+            return undefined;
+        }
+    }));
+    return new Map(results.reduce((prev, result) => {
+        if (result.status !== 'fulfilled' || !result.value)
+            return prev;
+        return [...prev, result.value];
+    }, []));
+};
+export const selectBestRate = (quotedAmounts) => {
+    return Array.from(quotedAmounts.entries()).reduce((addressWithHighestAmount, [poolAddress, amount]) => {
+        if (addressWithHighestAmount[1] === undefined)
+            return [poolAddress, amount];
+        return amount > addressWithHighestAmount[1] ? [poolAddress, amount] : addressWithHighestAmount;
+    }, [undefined, undefined]);
+};
+export const shortenedNativeAssetNameByNativeAssetName = {
+    'THOR.RUNE': 'r',
+    'BTC.BTC': 'b',
+    'ETH.ETH': 'e',
+    'BNB.BNB': 'n',
+    'GAIA.ATOM': 'g',
+    'DOGE.DOGE': 'd',
+    'LTC.LTC': 'l',
+    'BCH.BCH': 'c',
+    'AVAX.AVAX': 'a',
+    'BSC.BNB': 's',
+};

package/dist/esm/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.d.ts

@@ -0,0 +1,6 @@
+import type { AssetId } from '@shapeshiftoss/caip';
+export declare const assetIdToThorPoolAssetIdMap: import("lodash").Dictionary<string>;
+export declare const thorPoolAssetIdToAssetId: (id: string) => AssetId | undefined;
+export declare const assetIdToThorPoolAssetId: ({ assetId }: {
+    assetId: AssetId;
+}) => string | undefined;

package/dist/esm/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.js

@@ -0,0 +1,6 @@
+import invert from 'lodash/invert';
+import generatedTradableAssetMap from '../../generated/generatedTradableAssetMap.json';
+const thorPoolIdAssetIdSymbolMap = generatedTradableAssetMap;
+export const assetIdToThorPoolAssetIdMap = invert(thorPoolIdAssetIdSymbolMap);
+export const thorPoolAssetIdToAssetId = (id) => thorPoolIdAssetIdSymbolMap[id.toUpperCase()];
+export const assetIdToThorPoolAssetId = ({ assetId }) => assetIdToThorPoolAssetIdMap[assetId.toLowerCase()];

package/dist/esm/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/swappers/ThorchainSwapper/utils/poolAssetHelpers/poolAssetHelpers.test.js

@@ -0,0 +1,54 @@
+import { btcAssetId, ethAssetId } from '@shapeshiftoss/caip';
+import { describe, expect, it } from 'vitest';
+import { assetIdToThorPoolAssetId, thorPoolAssetIdToAssetId } from './poolAssetHelpers.js';
+describe('poolAssetHelpers', () => {
+    const usdcAssetId = 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
+    describe('thorPoolAssetIdToAssetId', () => {
+        it('returns Ethereum assetId when poolAssetId is ETH.ETH', () => {
+            const result = thorPoolAssetIdToAssetId('ETH.ETH');
+            expect(result).toEqual(ethAssetId);
+        });
+        it('returns Bitcoin assetId when poolAssetId is BTC.BTC', () => {
+            const result = thorPoolAssetIdToAssetId('BTC.BTC');
+            expect(result).toEqual(btcAssetId);
+        });
+        it('returns ERC20 assetId when poolAssetId is in ERC20 format', () => {
+            const result = thorPoolAssetIdToAssetId('ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48');
+            expect(result).toEqual(usdcAssetId);
+        });
+        it('returns undefined for an asset we dont support', () => {
+            const result = thorPoolAssetIdToAssetId('BNB.AVA-645');
+            expect(result).toEqual(undefined);
+        });
+        it('returns undefined for an asset that uses asset abbreviations', () => {
+            const result = thorPoolAssetIdToAssetId('ETH.USDT-ec7');
+            expect(result).toEqual(undefined);
+        });
+    });
+    describe('assetIdToThorPoolAssetId', () => {
+        it('returns Ethereum pool when assetId is ethAssetId', () => {
+            const assetId = ethAssetId;
+            const result = assetIdToThorPoolAssetId({ assetId });
+            const poolAssetId = 'ETH.ETH';
+            expect(result).toEqual(poolAssetId);
+        });
+        it('returns bitcoin pool when assetId is btcAssetId', () => {
+            const assetId = btcAssetId;
+            const result = assetIdToThorPoolAssetId({ assetId });
+            const poolAssetId = 'BTC.BTC';
+            expect(result).toEqual(poolAssetId);
+        });
+        it('returns USDC pool when assetId is usdc', () => {
+            const assetId = usdcAssetId;
+            const result = assetIdToThorPoolAssetId({ assetId });
+            const poolAssetId = 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48';
+            expect(result).toEqual(poolAssetId);
+        });
+        it('returns undefined for an unsupported asset', () => {
+            const assetId = 'foobar';
+            const result = assetIdToThorPoolAssetId({ assetId });
+            const poolAssetId = undefined;
+            expect(result).toEqual(poolAssetId);
+        });
+    });
+});

package/dist/esm/swappers/ThorchainSwapper/utils/test-data/responses.d.ts

@@ -0,0 +1,7 @@
+import type { InboundAddressResponse, ThornodePoolResponse } from '../../../../thorchain-utils/index.js';
+export declare const btcThornodePool: ThornodePoolResponse;
+export declare const ethThornodePool: ThornodePoolResponse;
+export declare const foxThornodePool: ThornodePoolResponse;
+export declare const usdcThornodePool: ThornodePoolResponse;
+export declare const thornodePools: ThornodePoolResponse[];
+export declare const mockInboundAddresses: InboundAddressResponse[];

package/dist/esm/swappers/ThorchainSwapper/utils/test-data/responses.js

@@ -0,0 +1,198 @@
+export const btcThornodePool = {
+    LP_units: '536055974608843',
+    asset: 'BTC.BTC',
+    balance_asset: '91027798705',
+    balance_rune: '935827756491105',
+    pending_inbound_asset: '0',
+    pending_inbound_rune: '0',
+    pool_units: '545894929144923',
+    savers_depth: '41416604834',
+    savers_units: '41128793233',
+    synth_mint_paused: false,
+    status: 'Available',
+    synth_supply: '44718623180',
+    synth_supply_remaining: '8963246519',
+    synth_units: '142965023220851',
+    loan_collateral: '8376774620',
+    loan_collateral_remaining: '8376774621',
+    loan_cr: '30776',
+    derived_depth_bps: '9484',
+    asset_tor_price: '424242',
+};
+export const ethThornodePool = {
+    LP_units: '273709963437801',
+    asset: 'ETH.ETH',
+    balance_asset: '915018987646',
+    balance_rune: '618746706022909',
+    pending_inbound_asset: '0',
+    pending_inbound_rune: '0',
+    pool_units: '274245264962453',
+    savers_depth: '167028916827',
+    savers_units: '165530383978',
+    status: 'Available',
+    synth_mint_paused: false,
+    synth_supply: '218601192670',
+    synth_supply_remaining: '183106737474',
+    synth_units: '36567637964216',
+    loan_collateral: '84066273112',
+    loan_collateral_remaining: '84066273113',
+    loan_cr: '31595',
+    derived_depth_bps: '9491',
+    asset_tor_price: '424242',
+};
+export const foxThornodePool = {
+    LP_units: '10015457121887',
+    asset: 'ETH.FOX-0XC770EEFAD204B5180DF6A14EE197D99D808EE52D',
+    balance_asset: '166650912393467',
+    balance_rune: '8838681437152',
+    pending_inbound_asset: '0',
+    pending_inbound_rune: '0',
+    pool_units: '10568061707512',
+    savers_depth: '0',
+    savers_units: '0',
+    status: 'Available',
+    synth_mint_paused: false,
+    synth_supply: '3126453386967',
+    synth_supply_remaining: '161390775916374',
+    synth_units: '50300400994',
+    loan_collateral: '0',
+    loan_collateral_remaining: '0',
+    loan_cr: '20000',
+    derived_depth_bps: '0',
+    asset_tor_price: '424242',
+};
+export const usdcThornodePool = {
+    LP_units: '30018075345020',
+    asset: 'ETH.USDC-0XA0B86991C6218B36C1D19D4A2E9EB0CE3606EB48',
+    balance_asset: '290355330190652994811',
+    balance_rune: '100000000000000000000',
+    pending_inbound_asset: '22020062300',
+    pending_inbound_rune: '0',
+    pool_units: '31954495292990',
+    savers_depth: '0',
+    savers_units: '0',
+    status: 'Available',
+    synth_mint_paused: false,
+    synth_supply: '20420358430864',
+    synth_supply_remaining: '102379864074658',
+    synth_units: '1423205664974',
+    loan_collateral: '0',
+    loan_collateral_remaining: '0',
+    loan_cr: '20000',
+    derived_depth_bps: '0',
+    asset_tor_price: '424242',
+};
+export const thornodePools = [
+    btcThornodePool,
+    ethThornodePool,
+    foxThornodePool,
+    usdcThornodePool,
+];
+export const mockInboundAddresses = [
+    {
+        chain: 'BCH',
+        pub_key: 'thorpub1addwnpepqfyppkehky2hn2gy26y8jqyj9fz0rnvau2r7yueawzvc662w0x9s7n4ypra',
+        address: 'qp5a6rn8zmamgmsyspqsl0p6ktk4hrheggdjdvntv0',
+        halted: false,
+        gas_rate: '3',
+        gas_rate_units: 'satsperbyte',
+        global_trading_paused: false,
+        chain_trading_paused: false,
+        chain_lp_actions_paused: false,
+        outbound_fee: '9000',
+        outbound_tx_size: '1500',
+    },
+    {
+        chain: 'BNB',
+        pub_key: 'thorpub1addwnpepqfyppkehky2hn2gy26y8jqyj9fz0rnvau2r7yueawzvc662w0x9s7n4ypra',
+        address: 'bnb1d8wsuecklw6xupyqgy8mcw4ja4dca72z7nvqzw',
+        halted: false,
+        gas_rate: '11250',
+        gas_rate_units: 'ubnb',
+        global_trading_paused: false,
+        chain_trading_paused: false,
+        chain_lp_actions_paused: false,
+        outbound_fee: '22500',
+        outbound_tx_size: '1',
+    },
+    {
+        chain: 'BTC',
+        pub_key: 'thorpub1addwnpepqfyppkehky2hn2gy26y8jqyj9fz0rnvau2r7yueawzvc662w0x9s7n4ypra',
+        address: 'bc1qd8wsuecklw6xupyqgy8mcw4ja4dca72z2dd88d',
+        halted: false,
+        gas_rate: '18',
+        gas_rate_units: 'satsperbyte',
+        global_trading_paused: false,
+        chain_trading_paused: false,
+        chain_lp_actions_paused: false,
+        outbound_fee: '33000',
+        outbound_tx_size: '1000',
+    },
+    {
+        chain: 'DOGE',
+        pub_key: 'thorpub1addwnpepqfyppkehky2hn2gy26y8jqyj9fz0rnvau2r7yueawzvc662w0x9s7n4ypra',
+        address: 'DEnrJfAjC4KMsLsGtoTGSmYaFZLPunWw9q',
+        halted: false,
+        gas_rate: '550384',
+        gas_rate_units: 'satsperbyte',
+        global_trading_paused: false,
+        chain_trading_paused: false,
+        chain_lp_actions_paused: false,
+        outbound_fee: '1500000000',
+        outbound_tx_size: '1000',
+    },
+    {
+        chain: 'ETH',
+        pub_key: 'thorpub1addwnpepqfyppkehky2hn2gy26y8jqyj9fz0rnvau2r7yueawzvc662w0x9s7n4ypra',
+        address: '0x78e4e10dcacb0a8261eb3d5e57ffb98ae8d4dff1',
+        router: '0x3624525075b88B24ecc29CE226b0CEc1fFcB6976',
+        halted: false,
+        gas_rate: '280',
+        gas_rate_units: 'gwei',
+        global_trading_paused: false,
+        chain_trading_paused: false,
+        chain_lp_actions_paused: false,
+        outbound_fee: '480000',
+        outbound_tx_size: '80000',
+    },
+    {
+        chain: 'LTC',
+        pub_key: 'thorpub1addwnpepqfyppkehky2hn2gy26y8jqyj9fz0rnvau2r7yueawzvc662w0x9s7n4ypra',
+        address: 'ltc1qd8wsuecklw6xupyqgy8mcw4ja4dca72zw3hrla',
+        halted: false,
+        gas_rate: '60',
+        gas_rate_units: 'satsperbyte',
+        global_trading_paused: false,
+        chain_trading_paused: false,
+        chain_lp_actions_paused: false,
+        outbound_fee: '99750',
+        outbound_tx_size: '250',
+    },
+    {
+        address: 'cosmos1euskj33zyqcysvn252qvwkkurkd72gvnv30h4d',
+        chain: 'GAIA',
+        chain_lp_actions_paused: false,
+        chain_trading_paused: false,
+        gas_rate: '450000',
+        gas_rate_units: 'uatom',
+        global_trading_paused: false,
+        halted: false,
+        outbound_fee: '900000',
+        outbound_tx_size: '1',
+        pub_key: 'sthorpub1addwnpepqdn3p3y3ctnr4sqdr0wswmn665asezx3c5yxags7y5ctxs5j42q278pj7fc',
+    },
+    {
+        address: '0x8d6ed3bcdafc38214af914b08bc47ce36802c87c',
+        chain: 'AVAX',
+        chain_lp_actions_paused: false,
+        chain_trading_paused: false,
+        gas_rate: '150',
+        gas_rate_units: 'nAVAX',
+        global_trading_paused: false,
+        halted: false,
+        outbound_fee: '2400000',
+        outbound_tx_size: '80000',
+        pub_key: 'sthorpub1addwnpepqdn3p3y3ctnr4sqdr0wswmn665asezx3c5yxags7y5ctxs5j42q278pj7fc',
+        router: '0xd6a6c0b3bb4150a98a379811934e440989209db6',
+    },
+];

package/dist/esm/swappers/ThorchainSwapper/utils/test-data/setupThorswapDeps.d.ts

@@ -0,0 +1,2 @@
+import type { EvmChainAdapter } from '@shapeshiftoss/chain-adapters';
+export declare const mockEvmChainAdapter: EvmChainAdapter;

package/dist/esm/swappers/ThorchainSwapper/utils/test-data/setupThorswapDeps.js

@@ -0,0 +1,34 @@
+import { ethAssetId } from '@shapeshiftoss/caip';
+import { FeeDataKey } from '@shapeshiftoss/chain-adapters';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { vi } from 'vitest';
+const feeData = {
+    fast: {
+        txFee: '1',
+        chainSpecific: { approvalFeeCryptoBaseUnit: '1', gasLimit: '1', gasPrice: '1' },
+        tradeFee: '2',
+    },
+};
+export const mockEvmChainAdapter = {
+    getAddress: vi.fn(() => Promise.resolve('0xthisIsMyAddress')),
+    getFeeData: vi.fn(() => feeData),
+    getFeeAssetId: vi.fn(() => ethAssetId),
+    getChainId: vi.fn(() => KnownChainIds.EthereumMainnet),
+    getGasFeeData: vi.fn(() => ({
+        [FeeDataKey.Slow]: {
+            gasPrice: '1',
+            maxFeePerGas: '2',
+            maxPriorityFeePerGas: '3',
+        },
+        [FeeDataKey.Average]: {
+            gasPrice: '4',
+            maxFeePerGas: '5',
+            maxPriorityFeePerGas: '6',
+        },
+        [FeeDataKey.Fast]: {
+            gasPrice: '7',
+            maxFeePerGas: '8',
+            maxPriorityFeePerGas: '9',
+        },
+    })),
+};

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

@@ -0,0 +1,2 @@
+import type { Swapper } from '../../types.js';
+export declare const zrxSwapper: Swapper;

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

@@ -0,0 +1,4 @@
+import { executeEvmTransaction } from '../../utils.js';
+export const zrxSwapper = {
+    executeEvmTransaction,
+};

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

@@ -0,0 +1,2 @@
+import type { SwapperApi } from '../../types.js';
+export declare const zrxApi: SwapperApi;

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

@@ -0,0 +1,72 @@
+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 { 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;
+    },
+    checkTradeStatus: checkEvmSwapStatus,
+};

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

@@ -0,0 +1,6 @@
+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>>;