@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/esm/constants.js

@@ -1,42 +1,24 @@
 import { assertUnreachable } from '@shapeshiftoss/utils';
-import { acrossSwapper } from './swappers/AcrossSwapper/index.js';
-import { acrossApi } from './swappers/AcrossSwapper/endpoints.js';
-import { arbitrumBridgeSwapper } from './swappers/ArbitrumBridgeSwapper/ArbitrumBridgeSwapper.js';
-import { arbitrumBridgeApi } from './swappers/ArbitrumBridgeSwapper/endpoints.js';
-import { avnuSwapper } from './swappers/AvnuSwapper/AvnuSwapper.js';
-import { avnuApi } from './swappers/AvnuSwapper/endpoints.js';
-import { bebopSwapper } from './swappers/BebopSwapper/BebopSwapper.js';
-import { bebopApi } from './swappers/BebopSwapper/endpoints.js';
-import { bobGatewaySwapper } from './swappers/BobGatewaySwapper/BobGatewaySwapper.js';
-import { bobGatewayApi } from './swappers/BobGatewaySwapper/endpoints.js';
-import { butterSwap } from './swappers/ButterSwap/ButterSwap.js';
-import { butterSwapApi } from './swappers/ButterSwap/endpoints.js';
-import { cetusSwapper } from './swappers/CetusSwapper/CetusSwapper.js';
-import { cetusApi } from './swappers/CetusSwapper/endpoints.js';
-import { chainflipSwapper } from './swappers/ChainflipSwapper/ChainflipSwapper.js';
-import { chainflipApi } from './swappers/ChainflipSwapper/endpoints.js';
-import { cowSwapper } from './swappers/CowSwapper/CowSwapper.js';
-import { cowApi } from './swappers/CowSwapper/endpoints.js';
-import { debridgeSwapper } from './swappers/DebridgeSwapper/index.js';
-import { debridgeApi } from './swappers/DebridgeSwapper/endpoints.js';
-import { mayachainApi } from './swappers/MayachainSwapper/endpoints.js';
-import { mayachainSwapper } from './swappers/MayachainSwapper/MayachainSwapper.js';
-import { nearIntentsApi } from './swappers/NearIntentsSwapper/endpoints.js';
-import { nearIntentsSwapper } from './swappers/NearIntentsSwapper/NearIntentsSwapper.js';
-import { portalsApi } from './swappers/PortalsSwapper/endpoints.js';
-import { portalsSwapper } from './swappers/PortalsSwapper/PortalsSwapper.js';
-import { relaySwapper } from './swappers/RelaySwapper/index.js';
-import { relayApi } from './swappers/RelaySwapper/endpoints.js';
-import { stonfiApi } from './swappers/StonfiSwapper/endpoints.js';
-import { stonfiSwapper } from './swappers/StonfiSwapper/StonfiSwapper.js';
-import { sunioApi } from './swappers/SunioSwapper/endpoints.js';
-import { sunioSwapper } from './swappers/SunioSwapper/SunioSwapper.js';
-import { thorchainApi } from './swappers/ThorchainSwapper/endpoints.js';
-import { thorchainSwapper } from './swappers/ThorchainSwapper/ThorchainSwapper.js';
-import { zrxApi } from './swappers/ZrxSwapper/endpoints.js';
-import { zrxSwapper } from './swappers/ZrxSwapper/ZrxSwapper.js';
+import { acrossApi, acrossSwapper } from './swappers/AcrossSwapper/index.js';
+import { arbitrumBridgeApi, arbitrumBridgeSwapper } from './swappers/ArbitrumBridgeSwapper/index.js';
+import { avnuApi, avnuSwapper } from './swappers/AvnuSwapper/index.js';
+import { bebopApi, bebopSwapper } from './swappers/BebopSwapper/index.js';
+import { bobGatewayApi, bobGatewaySwapper } from './swappers/BobGatewaySwapper/index.js';
+import { butterSwap, butterSwapApi } from './swappers/ButterSwap/index.js';
+import { cetusApi, cetusSwapper } from './swappers/CetusSwapper/index.js';
+import { chainflipApi, chainflipSwapper } from './swappers/ChainflipSwapper/index.js';
+import { cowApi, cowSwapper } from './swappers/CowSwapper/index.js';
+import { debridgeApi, debridgeSwapper } from './swappers/DebridgeSwapper/index.js';
+import { mayachainApi, mayachainSwapper } from './swappers/MayachainSwapper/index.js';
+import { nearIntentsApi, nearIntentsSwapper } from './swappers/NearIntentsSwapper/index.js';
+import { portalsApi, portalsSwapper } from './swappers/PortalsSwapper/index.js';
+import { relayApi, relaySwapper } from './swappers/RelaySwapper/index.js';
+import { stonfiApi, stonfiSwapper } from './swappers/StonfiSwapper/index.js';
+import { sunioApi, sunioSwapper } from './swappers/SunioSwapper/index.js';
+import { thorchainApi, thorchainSwapper } from './swappers/ThorchainSwapper/index.js';
+import { zrxApi, zrxSwapper } from './swappers/ZrxSwapper/index.js';
 import { SwapperName, TradeQuoteError } from './types.js';
-import { makeSwapErrorRight } from './utils.js';
+import { makeSwapErrorRight } from './utils/index.js';
 export const QUOTE_TIMEOUT_MS = 60_000;
 export const TRADE_STATUS_POLL_INTERVAL_MILLISECONDS = 5_000;
 export const QUOTE_TIMEOUT_ERROR = makeSwapErrorRight({

package/dist/esm/index.d.ts

@@ -1,7 +1,11 @@
 export * from './constants.js';
-export * from './cowswap-utils/index.js';
-export * from './safe-utils/index.js';
+export * from './utils/cosmossdk/index.js';
+export * from './utils/cowswap/index.js';
+export * from './utils/evm/index.js';
+export * from './utils/safe/index.js';
+export * from './utils/solana/index.js';
 export * from './swapper.js';
+export * from './utils/utxo/index.js';
 export * from './swappers/ArbitrumBridgeSwapper/index.js';
 export * from './swappers/BobGatewaySwapper/index.js';
 export * from './swappers/AvnuSwapper/index.js';
@@ -16,8 +20,8 @@ export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';
 export * from './swappers/ButterSwap/index.js';
 export * from './swappers/RelaySwapper/index.js';
-export * from './swappers/utils/helpers/helpers.js';
-export * from './thorchain-utils/index.js';
+export * from './utils/helpers.js';
+export * from './utils/thorchain/index.js';
 export * from './types.js';
-export * from './utils.js';
-export * as testData from './swappers/utils/test-data/index.js';
+export * from './utils/index.js';
+export * as testData from './utils/test-data/index.js';

package/dist/esm/index.js

@@ -1,7 +1,11 @@
 export * from './constants.js';
-export * from './cowswap-utils/index.js';
-export * from './safe-utils/index.js';
+export * from './utils/cosmossdk/index.js';
+export * from './utils/cowswap/index.js';
+export * from './utils/evm/index.js';
+export * from './utils/safe/index.js';
+export * from './utils/solana/index.js';
 export * from './swapper.js';
+export * from './utils/utxo/index.js';
 export * from './swappers/ArbitrumBridgeSwapper/index.js';
 export * from './swappers/BobGatewaySwapper/index.js';
 export * from './swappers/AvnuSwapper/index.js';
@@ -16,8 +20,8 @@ export * from './swappers/ThorchainSwapper/index.js';
 export * from './swappers/MayachainSwapper/index.js';
 export * from './swappers/ButterSwap/index.js';
 export * from './swappers/RelaySwapper/index.js';
-export * from './swappers/utils/helpers/helpers.js';
-export * from './thorchain-utils/index.js';
+export * from './utils/helpers.js';
+export * from './utils/thorchain/index.js';
 export * from './types.js';
-export * from './utils.js';
-export * as testData from './swappers/utils/test-data/index.js';
+export * from './utils/index.js';
+export * as testData from './utils/test-data/index.js';

package/dist/esm/swapper.d.ts

@@ -1,3 +1,3 @@
-import type { GetTradeQuoteInputWithWallet, GetTradeRateInput, QuoteResult, RateResult, SwapperDeps, SwapperName } from './types.js';
-export declare const getTradeQuotes: (getTradeQuoteInput: GetTradeQuoteInputWithWallet, swapperName: SwapperName, deps: SwapperDeps) => Promise<QuoteResult | undefined>;
+import type { GetTradeQuoteInput, GetTradeRateInput, QuoteResult, RateResult, SwapperDeps, SwapperName } from './types.js';
+export declare const getTradeQuotes: (getTradeQuoteInput: GetTradeQuoteInput, swapperName: SwapperName, deps: SwapperDeps) => Promise<QuoteResult | undefined>;
 export declare const getTradeRates: (getTradeRateInput: GetTradeRateInput, swapperName: SwapperName, deps: SwapperDeps, quoteTimeoutMs?: number) => Promise<RateResult | undefined>;

package/dist/esm/swapper.js

@@ -1,7 +1,7 @@
 import { bnOrZero, timeoutMonadic, timeoutMonadicWithOriginal } from '@shapeshiftoss/utils';
 import { QUOTE_TIMEOUT_ERROR, QUOTE_TIMEOUT_MS, swappers } from './constants.js';
 import { TradeQuoteError } from './types.js';
-import { makeSwapErrorRight } from './utils.js';
+import { makeSwapErrorRight } from './utils/index.js';
 export const getTradeQuotes = async (getTradeQuoteInput, swapperName, deps) => {
     if (bnOrZero(getTradeQuoteInput.affiliateBps).lt(0))
         return;

package/dist/esm/swappers/AcrossSwapper/AcrossSwapper.js

@@ -1,5 +1,7 @@
-import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+import { executeEvmTransaction } from '../../utils/index.js';
 export const acrossSwapper = {
     executeEvmTransaction,
-    executeSolanaTransaction,
+    executeSolanaMessage: ({ serializedTx }, { signAndBroadcastSerializedTransaction }) => {
+        return signAndBroadcastSerializedTransaction(serializedTx);
+    },
 };

package/dist/esm/swappers/AcrossSwapper/constant.js

@@ -1,7 +1,7 @@
-import { arbitrumChainId, baseChainId, blastChainId, bscChainId, ethChainId, hyperEvmChainId, inkChainId, lineaChainId, megaethChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, scrollChainId, solanaChainId, soneiumChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
+import { arbitrumChainId, baseChainId, blastChainId, bscChainId, ethChainId, hyperEvmChainId, inkChainId, lineaChainId, megaethChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, robinhoodChainId, scrollChainId, solanaChainId, soneiumChainId, unichainChainId, worldChainChainId, zkSyncEraChainId, } from '@shapeshiftoss/caip';
 import invert from 'lodash/invert';
 import { zeroAddress } from 'viem';
-import { arbitrum, base, blast, bsc, hyperEvm, ink, linea, mainnet as ethereum, mode, monad, optimism, plasma, polygon, scroll, soneium, unichain, worldchain, zksync, } from 'viem/chains';
+import { arbitrum, base, blast, bsc, hyperEvm, ink, linea, mainnet as ethereum, megaeth, mode, monad, optimism, plasma, polygon, robinhood, scroll, soneium, unichain, worldchain, zksync, } from 'viem/chains';
 import { TradeQuoteError } from '../../types.js';
 import { AcrossErrorCode } from './utils/types.js';
 export const chainIdToAcrossChainId = {
@@ -25,7 +25,8 @@ export const chainIdToAcrossChainId = {
     // Across uses a custom Solana chain ID
     [solanaChainId]: 34268394551451,
     [scrollChainId]: scroll.id,
-    [megaethChainId]: 4326,
+    [megaethChainId]: megaeth.id,
+    [robinhoodChainId]: robinhood.id,
 };
 export const acrossChainIdToChainId = invert(chainIdToAcrossChainId);
 export const ACROSS_SUPPORTED_CHAIN_IDS = Object.keys(chainIdToAcrossChainId);

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

@@ -1,47 +1,24 @@
-import { evm, isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import BigNumber from 'bignumber.js';
-import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
-import { getUnsignedSolanaTransaction } from '../../solana-utils/getUnsignedSolanaTransaction.js';
-import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { checkEvmSwapStatus, getExecutableTradeStep, isExecutableTradeQuote } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
 import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
 import { getTradeRate } from './getTradeRate/getTradeRate.js';
-import { acrossService } from './utils/acrossService.js';
+import { acrossService, getAcrossRequestConfig } from './utils/acrossService.js';
 export const acrossApi = {
     getTradeQuote: (input, deps) => getTradeQuote(input, deps),
     getTradeRate: (input, deps) => getTradeRate(input, deps),
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+    getEvmTransactionFees,
+    getUnsignedEvmTransaction,
+    getUnsignedSolanaMessage: ({ tradeQuote, stepIndex }) => {
         if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
+            throw new Error('unable to execute a trade rate');
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { acrossTransactionMetadata, sellAsset } = step;
-        if (!acrossTransactionMetadata)
-            throw new Error('Missing Across transaction metadata');
-        const { to, value, data } = acrossTransactionMetadata;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        return feeData.networkFeeCryptoBaseUnit;
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, acrossTransactionMetadata, sellAsset } = step;
-        if (!acrossTransactionMetadata)
-            throw new Error('Missing Across transaction metadata');
-        const { to, value, data, gasLimit: gasLimitFromApi } = acrossTransactionMetadata;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        const unsignedTx = await adapter.buildCustomApiTx({
-            accountNumber,
-            data,
-            from,
-            to,
-            value,
-            ...feeData,
-            gasLimit: BigNumber.max(gasLimitFromApi ?? '0', feeData.gasLimit).toFixed(),
-        });
-        return unsignedTx;
+        const { transactionData } = step;
+        if (transactionData?.type !== 'solana_serialized_tx') {
+            throw new Error('invalid solana transaction');
+        }
+        return Promise.resolve({ serializedTx: transactionData.serializedTx });
     },
     checkTradeStatus: async ({ txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
         if (isEvmChainId(chainId)) {
@@ -56,7 +33,7 @@ export const acrossApi = {
                 return sourceTxStatus;
             txHash = sourceTxStatus.buyTxHash ?? txHash;
         }
-        const maybeStatusResponse = await acrossService.get(`${config.VITE_ACROSS_API_URL}/deposit/status?depositTxnRef=${txHash}`);
+        const maybeStatusResponse = await acrossService.get(`${config.VITE_ACROSS_API_URL}/deposit/status?depositTxnRef=${txHash}`, getAcrossRequestConfig(config));
         if (maybeStatusResponse.isErr()) {
             return {
                 buyTxHash: undefined,
@@ -102,6 +79,4 @@ export const acrossApi = {
             message,
         };
     },
-    getUnsignedSolanaTransaction,
-    getSolanaTransactionFees,
 };

package/dist/esm/swappers/AcrossSwapper/getTradeQuote/getTradeQuote.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
-export declare const getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { AcrossTradeQuoteInput } from '../utils/types.js';
+export declare const getTradeQuote: (input: AcrossTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

package/dist/esm/swappers/AcrossSwapper/getTradeQuote/getTradeQuote.js

@@ -1,27 +1,39 @@
-import { Err } from '@sniptt/monads';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { getTrade } from '../utils/getTrade.js';
-export const getTradeQuote = (input, deps) => {
-    if (!input.sendAddress) {
-        return Promise.resolve(Err(makeSwapErrorRight({
-            message: 'sendAddress is required',
-        })));
-    }
-    if (!input.receiveAddress) {
-        return Promise.resolve(Err(makeSwapErrorRight({
-            message: 'receiveAddress is required',
-        })));
-    }
-    const args = {
-        buyAsset: input.buyAsset,
-        receiveAddress: input.receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        sellAsset: input.sellAsset,
-        sendAddress: input.sendAddress,
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getAcrossStepData } from '../utils/getAcrossStepData.js';
+import { getAcrossTradeContext } from '../utils/getAcrossTradeContext.js';
+export const getTradeQuote = async (input, deps) => {
+    const { accountNumber } = input;
+    const maybeAddresses = assertQuoteAddresses(input);
+    if (maybeAddresses.isErr())
+        return Err(maybeAddresses.unwrapErr());
+    const { sendAddress, receiveAddress } = maybeAddresses.unwrap();
+    const maybeContext = await getAcrossTradeContext({
+        input,
+        deps,
+        depositor: sendAddress,
+        recipient: receiveAddress,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs, deadline } = maybeContext.unwrap();
+    const maybeStepData = await getAcrossStepData({ ...stepDataArgs, type: 'quote', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
         quoteOrRate: 'quote',
-        accountNumber: input.accountNumber,
-        affiliateBps: input.affiliateBps,
-        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        deadline,
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
     };
-    return getTrade({ input: args, deps });
+    return Ok([tradeQuote]);
 };

package/dist/esm/swappers/AcrossSwapper/getTradeRate/getTradeRate.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@sniptt/monads';
-import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
-export declare const getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeRate } from '../../../types.js';
+import type { AcrossTradeRateInput } from '../utils/types.js';
+export declare const getTradeRate: (input: AcrossTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

package/dist/esm/swappers/AcrossSwapper/getTradeRate/getTradeRate.js

@@ -1,15 +1,30 @@
-import { getTrade } from '../utils/getTrade.js';
-export const getTradeRate = (input, deps) => {
-    const args = {
+import { Err, Ok } from '@sniptt/monads';
+import { getAcrossStepData } from '../utils/getAcrossStepData.js';
+import { getAcrossTradeContext } from '../utils/getAcrossTradeContext.js';
+import { getDefaultUserAddress } from '../utils/helpers.js';
+export const getTradeRate = async (input, deps) => {
+    const { accountNumber, sellAsset, buyAsset, sendAddress, receiveAddress } = input;
+    const depositor = sendAddress ?? getDefaultUserAddress(sellAsset.chainId);
+    const recipient = receiveAddress ?? getDefaultUserAddress(buyAsset.chainId);
+    const maybeContext = await getAcrossTradeContext({ input, deps, depositor, recipient });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getAcrossStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
         quoteOrRate: 'rate',
-        buyAsset: input.buyAsset,
-        receiveAddress: input.receiveAddress,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        sellAsset: input.sellAsset,
-        sendAddress: input.sendAddress,
-        accountNumber: input.accountNumber,
-        affiliateBps: input.affiliateBps,
-        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+        receiveAddress: recipient,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
     };
-    return getTrade({ input: args, deps });
+    return Ok([tradeRate]);
 };

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

@@ -1 +1,2 @@
 export { acrossSwapper } from './AcrossSwapper.js';
+export { acrossApi } from './endpoints.js';

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

@@ -1 +1,2 @@
 export { acrossSwapper } from './AcrossSwapper.js';
+export { acrossApi } from './endpoints.js';

package/dist/esm/swappers/AcrossSwapper/utils/acrossService.d.ts

@@ -1,5 +1,8 @@
+import type { AxiosRequestConfig } from 'axios';
+import type { SwapperConfig } from '../../../types.js';
 export declare const acrossService: {
-    get: <T = any>(url: string, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
-    post: <T_1 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
-    delete: <T_2 = any>(url: string, data: any, config?: import("axios").AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    get: <T = any>(url: string, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../types.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../types.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../types.js").SwapErrorRight>>;
 };
+export declare const getAcrossRequestConfig: (config: SwapperConfig) => AxiosRequestConfig | undefined;

package/dist/esm/swappers/AcrossSwapper/utils/acrossService.js

@@ -1,5 +1,5 @@
 import axios from 'axios';
-import { makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
 const axiosConfig = {
     timeout: 10000,
     headers: {
@@ -9,3 +9,6 @@ const axiosConfig = {
 };
 const acrossServiceBase = axios.create(axiosConfig);
 export const acrossService = makeSwapperAxiosServiceMonadic(acrossServiceBase);
+export const getAcrossRequestConfig = (config) => config.VITE_ACROSS_API_KEY
+    ? { headers: { Authorization: `Bearer ${config.VITE_ACROSS_API_KEY}` } }
+    : undefined;

package/dist/esm/swappers/AcrossSwapper/utils/fetchAcrossTrade.js

@@ -1,4 +1,4 @@
-import { acrossService } from './acrossService.js';
+import { acrossService, getAcrossRequestConfig } from './acrossService.js';
 export const fetchAcrossTrade = (params, config) => {
     const searchParams = new URLSearchParams();
     searchParams.set('tradeType', params.tradeType);
@@ -19,5 +19,5 @@ export const fetchAcrossTrade = (params, config) => {
     if (params.slippage)
         searchParams.set('slippage', params.slippage);
     const url = `${config.VITE_ACROSS_API_URL}/swap/approval?${searchParams.toString()}`;
-    return acrossService.get(url);
+    return acrossService.get(url, getAcrossRequestConfig(config));
 };

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossStepData.d.ts

@@ -0,0 +1,25 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { AcrossSwapTx } from './types.js';
+type BaseArgs = {
+    swapTx: AcrossSwapTx;
+    spenderAddress: string;
+    fallbackNetworkFeeCryptoBaseUnit: string;
+};
+export type GetAcrossStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type AcrossRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type AcrossQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getAcrossStepData(args: Extract<GetAcrossStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<AcrossRateStepData, SwapErrorRight>>;
+export declare function getAcrossStepData(args: Extract<GetAcrossStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<AcrossQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossStepData.js

@@ -0,0 +1,135 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { AddressLookupTableAccount, PublicKey, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
+import { TradeQuoteError } from '../../../types.js';
+import { makeNetworkFeeEstimationFailedErr, makeSwapErrorRight, makeTradeStepBuildFailedErr, } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+import { getSolanaNetworkFeeCryptoBaseUnit } from '../../../utils/solana/index.js';
+export async function getAcrossStepData(args) {
+    const { swapTx, sellAsset, spenderAddress, from, type, input, fallbackNetworkFeeCryptoBaseUnit, deps, } = args;
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    switch (swapTx.ecosystem) {
+        case 'evm': {
+            const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+            const transactionData = {
+                type: 'evm',
+                chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+                to: swapTx.to,
+                data: swapTx.data,
+                value: swapTx.value ?? '0',
+                gasLimit: swapTx.gas,
+            };
+            const stateOverride = {
+                sellAsset,
+                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                spenderAddress,
+            };
+            if (type === 'rate') {
+                const networkFeeCryptoBaseUnit = await (async () => {
+                    try {
+                        return await getEvmNetworkFeeCryptoBaseUnit({
+                            adapter,
+                            transactionData,
+                            from,
+                            supportsEIP1559,
+                            stateOverride,
+                        });
+                    }
+                    catch {
+                        return fallbackNetworkFeeCryptoBaseUnit;
+                    }
+                })();
+                const stepData = { networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            try {
+                const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    transactionData,
+                    from,
+                    supportsEIP1559,
+                    stateOverride,
+                });
+                const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                return Ok(stepData);
+            }
+            catch (error) {
+                return Err(makeNetworkFeeEstimationFailedErr('getAcrossStepData', error));
+            }
+        }
+        case 'svm': {
+            try {
+                const txBytes = Buffer.from(swapTx.data, 'base64');
+                const versionedTransaction = VersionedTransaction.deserialize(new Uint8Array(txBytes));
+                const adapter = deps.assertGetSolanaChainAdapter(sellAsset.chainId);
+                const addressLookupTableAddresses = versionedTransaction.message.addressTableLookups.map(lookup => lookup.accountKey.toString());
+                const addressLookupTableAccountsInfos = await adapter.getAddressLookupTableAccounts(addressLookupTableAddresses);
+                const addressLookupTableAccounts = addressLookupTableAccountsInfos.map(info => new AddressLookupTableAccount({
+                    key: new PublicKey(info.key),
+                    state: AddressLookupTableAccount.deserialize(new Uint8Array(info.data)),
+                }));
+                const instructions = TransactionMessage.decompile(versionedTransaction.message, {
+                    addressLookupTableAccounts,
+                }).instructions;
+                if (type === 'rate') {
+                    // No placeholder estimation for provider built routes - best effort with provider fee fallback
+                    const networkFeeCryptoBaseUnit = await (async () => {
+                        try {
+                            const { networkFeeCryptoBaseUnit } = await getSolanaNetworkFeeCryptoBaseUnit({
+                                adapter,
+                                from,
+                                instructions,
+                                addressLookupTableAddresses,
+                                tokenId: contractAddressOrUndefined(sellAsset.assetId),
+                            });
+                            return networkFeeCryptoBaseUnit;
+                        }
+                        catch {
+                            return fallbackNetworkFeeCryptoBaseUnit;
+                        }
+                    })();
+                    const stepData = { networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                try {
+                    const { networkFeeCryptoBaseUnit } = await getSolanaNetworkFeeCryptoBaseUnit({
+                        adapter,
+                        from,
+                        instructions,
+                        addressLookupTableAddresses,
+                        tokenId: contractAddressOrUndefined(sellAsset.assetId),
+                    });
+                    // Across pre-signs the CCTP message event account slot and pins the blockhash, so the
+                    // tx is sealed - it must be co-signed and broadcast as-is, never decompiled and rebuilt
+                    // (the instructions above are estimation-only)
+                    const transactionData = {
+                        type: 'solana_serialized_tx',
+                        serializedTx: swapTx.data,
+                    };
+                    const stepData = { transactionData, networkFeeCryptoBaseUnit };
+                    return Ok(stepData);
+                }
+                catch (e) {
+                    return Err(makeNetworkFeeEstimationFailedErr('getAcrossStepData', e));
+                }
+            }
+            catch (e) {
+                // Rates degrade to the provider fee, quotes can't be built from an undecodable payload
+                if (type === 'rate') {
+                    const stepData = {
+                        networkFeeCryptoBaseUnit: fallbackNetworkFeeCryptoBaseUnit,
+                    };
+                    return Ok(stepData);
+                }
+                return Err(makeTradeStepBuildFailedErr('getAcrossStepData', e));
+            }
+        }
+        default: {
+            return Err(makeSwapErrorRight({
+                message: `[getAcrossStepData] unsupported ecosystem: ${swapTx.ecosystem}`,
+                code: TradeQuoteError.UnsupportedChain,
+            }));
+        }
+    }
+}

package/dist/esm/swappers/AcrossSwapper/utils/getAcrossTradeContext.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { GetAcrossStepDataArgs } from './getAcrossStepData.js';
+import type { AcrossTradeQuoteInput, AcrossTradeRateInput } from './types.js';
+type AcrossTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    stepDataArgs: Omit<GetAcrossStepDataArgs, 'type' | 'input'>;
+    deadline: number;
+};
+export declare const getAcrossTradeContext: ({ input, deps, depositor, recipient, }: {
+    input: AcrossTradeQuoteInput | AcrossTradeRateInput;
+    deps: SwapperDeps;
+    depositor: string;
+    recipient: string;
+}) => Promise<Result<AcrossTradeContext, SwapErrorRight>>;
+export {};