@shapeshiftoss/swapper 17.6.9 → 17.6.10

package/dist/esm/constants.js

@@ -1,4 +1,6 @@
 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';
@@ -23,6 +25,8 @@ 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';
@@ -99,21 +103,30 @@ export const swappers = {
         ...avnuSwapper,
         ...avnuApi,
     },
+    [SwapperName.Stonfi]: {
+        ...stonfiSwapper,
+        ...stonfiApi,
+    },
+    [SwapperName.Across]: {
+        ...acrossSwapper,
+        ...acrossApi,
+    },
     [SwapperName.Test]: undefined,
 };
-// Slippage defaults. Don't export these to ensure the getDefaultSlippageDecimalPercentageForSwapper helper function is used.
-const DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.002'; // .2%
-const DEFAULT_COWSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
-const DEFAULT_NEAR_INTENTS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
-const DEFAULT_PORTALS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.025'; // 2.5%
-const DEFAULT_THOR_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01'; // 1%
-const DEFAULT_MAYA_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01'; // 1%
-const DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE = '0'; // no slippage for Arbitrum Bridge, so no slippage tolerance
-const DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.02'; // 2%
-const DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.015'; // 1.5%
-const DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
-const DEFAULT_SUNIO_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
-const DEFAULT_AVNU_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'; // .5%
+const DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.002';
+const DEFAULT_COWSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005';
+const DEFAULT_NEAR_INTENTS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005';
+const DEFAULT_PORTALS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.025';
+const DEFAULT_THOR_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01';
+const DEFAULT_MAYA_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01';
+const DEFAULT_ARBITRUM_BRIDGE_SLIPPAGE_DECIMAL_PERCENTAGE = '0';
+const DEFAULT_CHAINFLIP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.02';
+const DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE = '0.015';
+const DEFAULT_CETUS_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005';
+const DEFAULT_SUNIO_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005';
+// Starknet swaps can have more latency, so use higher default slippage
+const DEFAULT_AVNU_SLIPPAGE_DECIMAL_PERCENTAGE = '0.02';
+const DEFAULT_STONFI_SLIPPAGE_DECIMAL_PERCENTAGE = '0.01';
 export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
     if (swapperName === undefined)
         return DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE;
@@ -138,6 +151,8 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
             throw new Error('Default slippage not supported by Jupiter');
         case SwapperName.Relay:
             throw new Error('Default slippage not supported by Relay');
+        case SwapperName.Across:
+            throw new Error('Default slippage not supported by Across');
         case SwapperName.ButterSwap:
             return DEFAULT_BUTTERSWAP_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.NearIntents:
@@ -148,6 +163,8 @@ export const getDefaultSlippageDecimalPercentageForSwapper = (swapperName) => {
             return DEFAULT_SUNIO_SLIPPAGE_DECIMAL_PERCENTAGE;
         case SwapperName.Avnu:
             return DEFAULT_AVNU_SLIPPAGE_DECIMAL_PERCENTAGE;
+        case SwapperName.Stonfi:
+            return DEFAULT_STONFI_SLIPPAGE_DECIMAL_PERCENTAGE;
         default:
             return assertUnreachable(swapperName);
     }
@@ -157,6 +174,7 @@ export const isAutoSlippageSupportedBySwapper = (swapperName) => {
         case SwapperName.Jupiter:
             return true;
         case SwapperName.Relay:
+        case SwapperName.Across:
             return true;
         default:
             return false;

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

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

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

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

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

@@ -0,0 +1,9 @@
+import { TradeQuoteError } from '../../types.js';
+export declare const chainIdToAcrossChainId: Record<string, number>;
+export declare const acrossChainIdToChainId: import("lodash").Dictionary<string>;
+export declare const ACROSS_SUPPORTED_CHAIN_IDS: string[];
+export declare const DEFAULT_ACROSS_EVM_TOKEN_ADDRESS: "0x0000000000000000000000000000000000000000";
+export declare const ACROSS_SOLANA_TOKEN_ADDRESS = "11111111111111111111111111111111";
+export declare const DEFAULT_ACROSS_EVM_USER_ADDRESS = "0x000000000000000000000000000000000000dead";
+export declare const DEFAULT_ACROSS_SOLANA_USER_ADDRESS = "CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr";
+export declare const acrossErrorCodeToTradeQuoteError: Partial<Record<string, TradeQuoteError>>;

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

@@ -0,0 +1,42 @@
+import { arbitrumChainId, baseChainId, blastChainId, bscChainId, ethChainId, hyperEvmChainId, inkChainId, lineaChainId, modeChainId, monadChainId, optimismChainId, plasmaChainId, polygonChainId, 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, soneium, unichain, worldchain, zksync, } from 'viem/chains';
+import { TradeQuoteError } from '../../types.js';
+import { AcrossErrorCode } from './utils/types.js';
+export const chainIdToAcrossChainId = {
+    [ethChainId]: ethereum.id,
+    [arbitrumChainId]: arbitrum.id,
+    [baseChainId]: base.id,
+    [optimismChainId]: optimism.id,
+    [polygonChainId]: polygon.id,
+    [bscChainId]: bsc.id,
+    [monadChainId]: monad.id,
+    [hyperEvmChainId]: hyperEvm.id,
+    [inkChainId]: ink.id,
+    [lineaChainId]: linea.id,
+    [modeChainId]: mode.id,
+    [plasmaChainId]: plasma.id,
+    [zkSyncEraChainId]: zksync.id,
+    [blastChainId]: blast.id,
+    [worldChainChainId]: worldchain.id,
+    [unichainChainId]: unichain.id,
+    [soneiumChainId]: soneium.id,
+    // Across uses a custom Solana chain ID
+    [solanaChainId]: 34268394551451,
+};
+export const acrossChainIdToChainId = invert(chainIdToAcrossChainId);
+export const ACROSS_SUPPORTED_CHAIN_IDS = Object.keys(chainIdToAcrossChainId);
+export const DEFAULT_ACROSS_EVM_TOKEN_ADDRESS = zeroAddress;
+export const ACROSS_SOLANA_TOKEN_ADDRESS = '11111111111111111111111111111111';
+export const DEFAULT_ACROSS_EVM_USER_ADDRESS = '0x000000000000000000000000000000000000dead';
+export const DEFAULT_ACROSS_SOLANA_USER_ADDRESS = 'CbKGgVKLJFb8bBrf58DnAkdryX6ubewVytn7X957YwNr';
+export const acrossErrorCodeToTradeQuoteError = {
+    [AcrossErrorCode.AmountTooLow]: TradeQuoteError.SellAmountBelowMinimum,
+    [AcrossErrorCode.RouteNotFound]: TradeQuoteError.NoRouteFound,
+    [AcrossErrorCode.NoBridgeRoutes]: TradeQuoteError.NoRouteFound,
+    [AcrossErrorCode.UnsupportedToken]: TradeQuoteError.UnsupportedTradePair,
+    [AcrossErrorCode.InsufficientLiquidity]: TradeQuoteError.SellAmountBelowTradeFee,
+    [AcrossErrorCode.InvalidParam]: TradeQuoteError.UnknownError,
+    [AcrossErrorCode.InternalError]: TradeQuoteError.InternalError,
+};

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

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

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

@@ -0,0 +1,107 @@
+import { evm, 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 { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
+import { getTradeRate } from './getTradeRate/getTradeRate.js';
+import { acrossService } 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, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        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;
+    },
+    checkTradeStatus: async ({ txHash, chainId, address, config, fetchIsSmartContractAddressQuery, assertGetEvmChainAdapter, }) => {
+        if (isEvmChainId(chainId)) {
+            const sourceTxStatus = await checkEvmSwapStatus({
+                txHash,
+                chainId,
+                address,
+                assertGetEvmChainAdapter,
+                fetchIsSmartContractAddressQuery,
+            });
+            if (sourceTxStatus.status !== TxStatus.Confirmed)
+                return sourceTxStatus;
+            txHash = sourceTxStatus.buyTxHash ?? txHash;
+        }
+        const maybeStatusResponse = await acrossService.get(`${config.VITE_ACROSS_API_URL}/deposit/status?depositTxnRef=${txHash}`);
+        if (maybeStatusResponse.isErr()) {
+            return {
+                buyTxHash: undefined,
+                status: TxStatus.Unknown,
+                message: undefined,
+            };
+        }
+        const { data: statusResponse } = maybeStatusResponse.unwrap();
+        const status = (() => {
+            switch (statusResponse.status) {
+                case 'filled':
+                    return TxStatus.Confirmed;
+                case 'pending':
+                    return TxStatus.Pending;
+                case 'slowFillRequested':
+                    return TxStatus.Pending;
+                case 'expired':
+                    return TxStatus.Failed;
+                case 'refunded':
+                    return TxStatus.Failed;
+                default:
+                    return TxStatus.Unknown;
+            }
+        })();
+        const message = (() => {
+            switch (statusResponse.status) {
+                case 'pending':
+                    return 'Deposit detected, processing...';
+                case 'slowFillRequested':
+                    return 'Taking longer than usual, waiting for fill...';
+                case 'expired':
+                    return 'Deposit expired';
+                case 'refunded':
+                    return 'Deposit refunded on origin chain';
+                default:
+                    return undefined;
+            }
+        })();
+        const buyTxHash = statusResponse.fillTxnRef;
+        return {
+            status,
+            buyTxHash,
+            message,
+        };
+    },
+    getUnsignedSolanaTransaction,
+    getSolanaTransactionFees,
+};

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

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

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

@@ -0,0 +1,27 @@
+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,
+        quoteOrRate: 'quote',
+        accountNumber: input.accountNumber,
+        affiliateBps: input.affiliateBps,
+        slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
+    };
+    return getTrade({ input: args, deps });
+};

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

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

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

@@ -0,0 +1,15 @@
+import { getTrade } from '../utils/getTrade.js';
+export const getTradeRate = (input, deps) => {
+    const args = {
+        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,
+    };
+    return getTrade({ input: args, deps });
+};

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+import axios from 'axios';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+};
+const acrossServiceBase = axios.create(axiosConfig);
+export const acrossService = makeSwapperAxiosServiceMonadic(acrossServiceBase);

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

@@ -0,0 +1,19 @@
+import type { Result } from '@sniptt/monads';
+import type { AxiosResponse } from 'axios';
+import type { SwapErrorRight, SwapperConfig } from '../../../types.js';
+import type { AcrossSwapApprovalResponse } from './types.js';
+export type AcrossFetchQuoteParams = {
+    tradeType: 'exactInput';
+    amount: string;
+    inputToken: string;
+    outputToken: string;
+    originChainId: number;
+    destinationChainId: number;
+    depositor: string;
+    recipient?: string;
+    appFee?: number;
+    appFeeRecipient?: string;
+    integratorId?: string;
+    slippage?: string;
+};
+export declare const fetchAcrossTrade: (params: AcrossFetchQuoteParams, config: SwapperConfig) => Promise<Result<AxiosResponse<AcrossSwapApprovalResponse>, SwapErrorRight>>;

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

@@ -0,0 +1,23 @@
+import { acrossService } from './acrossService.js';
+export const fetchAcrossTrade = (params, config) => {
+    const searchParams = new URLSearchParams();
+    searchParams.set('tradeType', params.tradeType);
+    searchParams.set('amount', params.amount);
+    searchParams.set('inputToken', params.inputToken);
+    searchParams.set('outputToken', params.outputToken);
+    searchParams.set('originChainId', params.originChainId.toString());
+    searchParams.set('destinationChainId', params.destinationChainId.toString());
+    searchParams.set('depositor', params.depositor);
+    if (params.recipient)
+        searchParams.set('recipient', params.recipient);
+    if (params.appFee !== undefined && params.appFee > 0 && params.appFeeRecipient) {
+        searchParams.set('appFee', params.appFee.toString());
+        searchParams.set('appFeeRecipient', params.appFeeRecipient);
+    }
+    if (params.integratorId)
+        searchParams.set('integratorId', params.integratorId);
+    if (params.slippage)
+        searchParams.set('slippage', params.slippage);
+    const url = `${config.VITE_ACROSS_API_URL}/swap/approval?${searchParams.toString()}`;
+    return acrossService.get(url);
+};

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

@@ -0,0 +1,11 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight, SwapperDeps, TradeQuote, TradeRate } from '../../../types.js';
+import type { AcrossTradeInputParams } from './types.js';
+export declare function getTrade(args: {
+    input: AcrossTradeInputParams<'quote'>;
+    deps: SwapperDeps;
+}): Promise<Result<TradeQuote[], SwapErrorRight>>;
+export declare function getTrade(args: {
+    input: AcrossTradeInputParams<'rate'>;
+    deps: SwapperDeps;
+}): Promise<Result<TradeRate[], SwapErrorRight>>;