@shapeshiftoss/swapper 20.3.0 → 20.5.0

package/dist/esm/swappers/CetusSwapper/utils/constants.js

@@ -3,6 +3,5 @@ export const SUPPORTED_CETUS_CHAIN_IDS = [suiChainId];
 export const isSupportedChainId = (chainId) => {
     return SUPPORTED_CETUS_CHAIN_IDS.includes(chainId);
 };
-export const PYTH_DEPENDENT_PROVIDERS = ['HAEDALPMM', 'HAEDALHMMV2', 'METASTABLE'];
 // Placeholder sender for walletless rate fee estimation - dry-run needs a sender, real coins aren't required
 export const CETUS_FEE_ESTIMATE_DUMMY_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000';

package/dist/esm/swappers/CetusSwapper/utils/helpers.d.ts

@@ -1,11 +1,11 @@
 import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
 import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@mysten/sui/client';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
 import type { Asset } from '@shapeshiftoss/types';
 import type { Result } from '@sniptt/monads';
 import type { SwapErrorRight } from '../../../types.js';
-export declare const getAggregatorClient: (rpcUrl: string) => AggregatorClient;
-export declare const getSuiClient: (rpcUrl: string) => SuiClient;
+export declare const getSuiClient: (rpcUrl: string) => SuiGrpcClient;
+export declare const getAggregatorClient: (rpcUrl: string, signer?: string) => AggregatorClient;
 export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
     sellAsset: Asset;
     buyAsset: Asset;

package/dist/esm/swappers/CetusSwapper/utils/helpers.js

@@ -1,32 +1,21 @@
 import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
-import { SuiClient } from '@mysten/sui/client';
+import { SuiGrpcClient } from '@mysten/sui/grpc';
 import { fromAssetId } from '@shapeshiftoss/caip';
 import { Err, Ok } from '@sniptt/monads';
 import { TradeQuoteError } from '../../../types.js';
 import { makeSwapErrorRight } from '../../../utils/index.js';
 import { isSupportedChainId } from './constants.js';
 let suiClientInstance;
-let aggregatorClientInstance;
 let currentRpcUrl;
-export const getAggregatorClient = (rpcUrl) => {
-    if (!aggregatorClientInstance || !suiClientInstance || currentRpcUrl !== rpcUrl) {
-        suiClientInstance = new SuiClient({ url: rpcUrl });
-        aggregatorClientInstance = new AggregatorClient({
-            client: suiClientInstance,
-            env: Env.Mainnet,
-            signer: '0x0',
-        });
-        currentRpcUrl = rpcUrl;
-    }
-    return aggregatorClientInstance;
-};
 export const getSuiClient = (rpcUrl) => {
     if (!suiClientInstance || currentRpcUrl !== rpcUrl) {
-        suiClientInstance = new SuiClient({ url: rpcUrl });
+        suiClientInstance = new SuiGrpcClient({ network: 'mainnet', baseUrl: rpcUrl });
         currentRpcUrl = rpcUrl;
     }
     return suiClientInstance;
 };
+// Cetus merges the swap output into an existing coin owned by signer, so it must be the tx sender
+export const getAggregatorClient = (rpcUrl, signer) => new AggregatorClient({ client: getSuiClient(rpcUrl), env: Env.Mainnet, signer });
 export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
     if (!isSupportedChainId(sellAsset.chainId)) {
         return Err(makeSwapErrorRight({

package/dist/esm/swappers/ChainflipSwapper/swapperApi/getTradeQuote.js

@@ -73,8 +73,7 @@ export const getTradeQuote = async (input, deps) => {
                 {
                     ...stepCommon,
                     accountNumber,
-                    chainflipSpecific: { depositAddress },
-                    swapperMetadata: { name: 'chainflip', swapId },
+                    swapperMetadata: { name: 'chainflip', swapId, depositAddress },
                     transactionData,
                     feeData: { networkFeeCryptoBaseUnit, protocolFees },
                 },

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

@@ -6,6 +6,7 @@ export type ChainflipTradeRateInput = GetEvmTradeRateInput | GetUtxoTradeRateInp
 export type ChainflipMetadata = {
     name: 'chainflip';
     swapId: number | string;
+    depositAddress: string;
 };
 export type ChainFlipStatus = {
     status: {

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

@@ -1,6 +1,5 @@
 import { Err, Ok } from '@sniptt/monads';
 import { assertQuoteAddresses } from '../../../utils/index.js';
-import { FALLBACK_QUOTE_DEADLINE_MS } from '../../../utils/helpers.js';
 import { getDebridgeStepData } from '../utils/getDebridgeStepData.js';
 import { getDebridgeTradeContext } from '../utils/getDebridgeTradeContext.js';
 export const getTradeQuote = async (input, deps) => {
@@ -24,7 +23,6 @@ export const getTradeQuote = async (input, deps) => {
     const tradeQuote = {
         ...tradeCommon,
         quoteOrRate: 'quote',
-        deadline: Date.now() + FALLBACK_QUOTE_DEADLINE_MS,
         receiveAddress,
         steps: [
             {

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.d.ts

@@ -4,7 +4,6 @@ import type { DebridgeTx } from './types.js';
 type BaseArgs = {
     tx: DebridgeTx;
     sellAmountCryptoBaseUnit: string;
-    gasLimit: string | undefined;
     spenderAddress: string;
     fallbackNetworkFeeCryptoBaseUnit: string | undefined;
 };

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeStepData.js

@@ -3,7 +3,7 @@ import { Err, Ok } from '@sniptt/monads';
 import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
 import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
 export async function getDebridgeStepData(args) {
-    const { tx, sellAmountCryptoBaseUnit, gasLimit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
+    const { tx, sellAmountCryptoBaseUnit, spenderAddress, fallbackNetworkFeeCryptoBaseUnit, sellAsset, from, type, input, deps, } = args;
     const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
     const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
     const transactionData = {
@@ -12,7 +12,6 @@ export async function getDebridgeStepData(args) {
         to: tx.to,
         data: tx.data,
         value: tx.value,
-        gasLimit,
     };
     const stateOverride = {
         sellAsset,
@@ -20,20 +19,14 @@ export async function getDebridgeStepData(args) {
         spenderAddress,
     };
     if (type === 'rate') {
-        const networkFeeCryptoBaseUnit = await (async () => {
-            try {
-                return await getEvmNetworkFeeCryptoBaseUnit({
-                    adapter,
-                    transactionData,
-                    from,
-                    supportsEIP1559,
-                    stateOverride,
-                });
-            }
-            catch {
-                return fallbackNetworkFeeCryptoBaseUnit;
-            }
-        })();
+        // deBridge returns a flat gas limit far above actual usage, so rates simulate instead
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride,
+        }).catch(() => fallbackNetworkFeeCryptoBaseUnit);
         const stepData = { networkFeeCryptoBaseUnit };
         return Ok(stepData);
     }

package/dist/esm/swappers/DebridgeSwapper/utils/getDebridgeTradeContext.js

@@ -82,7 +82,6 @@ export const getDebridgeTradeContext = async ({ input, deps, senderAddress, reci
         stepDataArgs: {
             tx: quote.tx,
             sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            gasLimit: quote.gasLimit,
             fallbackNetworkFeeCryptoBaseUnit: quote.fallbackNetworkFeeCryptoBaseUnit,
             sellAsset,
             spenderAddress: allowanceContract,
@@ -135,7 +134,6 @@ const fetchCrossChainQuote = async ({ input, deps, sellDebridgeChainId, buyDebri
         isSameChainSwap: false,
         slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal,
         tx: quote.tx,
-        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
         fallbackNetworkFeeCryptoBaseUnit: quote.estimatedTransactionFee?.total,
     });
 };
@@ -191,7 +189,6 @@ const fetchSameChainQuote = async ({ input, deps, sellDebridgeChainId, senderAdd
         slippageTolerancePercentageDecimal: input.slippageTolerancePercentageDecimal ??
             (quote.slippage ? bnOrZero(quote.slippage).div(100).toString() : undefined),
         tx: quote.tx,
-        gasLimit: quote.estimatedTransactionFee?.details.gasLimit,
         fallbackNetworkFeeCryptoBaseUnit: quote.estimatedTransactionFee?.total,
     });
 };

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

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

package/dist/esm/swappers/FyndSwapper/FyndSwapper.js

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

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

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

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

@@ -0,0 +1,11 @@
+import { checkEvmSwapStatus } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getTradeQuote } from './getTradeQuote/getTradeQuote.js';
+import { getTradeRate } from './getTradeRate/getTradeRate.js';
+export const fyndApi = {
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    checkTradeStatus: checkEvmSwapStatus,
+};

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

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

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

@@ -0,0 +1,39 @@
+import { Err, Ok } from '@sniptt/monads';
+import { assertQuoteAddresses } from '../../../utils/index.js';
+import { getFyndStepData } from '../utils/getFyndStepData.js';
+import { getFyndTradeContext } from '../utils/getFyndTradeContext.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 getFyndTradeContext({
+        input,
+        deps,
+        from: sendAddress,
+        to: receiveAddress,
+    });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, deadline, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getFyndStepData({ ...stepDataArgs, type: 'quote', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { transactionData, networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeQuote = {
+        ...tradeCommon,
+        quoteOrRate: 'quote',
+        receiveAddress,
+        deadline,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                transactionData,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeQuote]);
+};

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

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

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

@@ -0,0 +1,30 @@
+import { Err, Ok } from '@sniptt/monads';
+import { EVM_PLACEHOLDER_ADDRESS } from '../../../utils/evm/constants.js';
+import { getFyndStepData } from '../utils/getFyndStepData.js';
+import { getFyndTradeContext } from '../utils/getFyndTradeContext.js';
+export const getTradeRate = async (input, deps) => {
+    const { accountNumber, sendAddress, receiveAddress } = input;
+    const from = sendAddress ?? EVM_PLACEHOLDER_ADDRESS;
+    const to = receiveAddress ?? from;
+    const maybeContext = await getFyndTradeContext({ input, deps, from, to });
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, protocolFees, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getFyndStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
+        quoteOrRate: 'rate',
+        receiveAddress,
+        steps: [
+            {
+                ...stepCommon,
+                accountNumber,
+                feeData: { networkFeeCryptoBaseUnit, protocolFees },
+            },
+        ],
+    };
+    return Ok([tradeRate]);
+};

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

@@ -0,0 +1,2 @@
+export { fyndApi } from './endpoints.js';
+export { fyndSwapper } from './FyndSwapper.js';

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

@@ -0,0 +1,2 @@
+export { fyndApi } from './endpoints.js';
+export { fyndSwapper } from './FyndSwapper.js';

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

@@ -0,0 +1,41 @@
+import type { Address, Hex } from 'viem';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput } from '../../types.js';
+export type FyndTradeQuoteInput = GetEvmTradeQuoteInput;
+export type FyndTradeRateInput = GetEvmTradeRateInput;
+export type FyndTransaction = {
+    to: Address;
+    value: string;
+    data: Hex;
+    client_fee_signature_offset?: number | null;
+};
+export type FyndFeeBreakdown = {
+    router_fee: string;
+    client_fee: string;
+    max_slippage: string;
+    min_amount_received: string;
+};
+export type FyndErrorResponse = {
+    error: string;
+    code: string;
+};
+export type FyndRouteSwap = {
+    protocol: string;
+};
+export type FyndEncodedQuote = {
+    status: 'success';
+    amount_in: string;
+    amount_out: string;
+    gas_estimate: string;
+    route?: {
+        swaps: FyndRouteSwap[];
+    } | null;
+    transaction: FyndTransaction;
+    fee_breakdown: FyndFeeBreakdown;
+    client_fee_deadline?: number | null;
+};
+export type FyndFailedOrder = {
+    status: 'no_route_found' | 'insufficient_liquidity' | 'timeout' | 'not_ready' | 'price_check_failed' | 'encoding_failed';
+};
+export type FyndQuoteResponse = {
+    orders: (FyndEncodedQuote | FyndFailedOrder)[];
+};

package/dist/esm/swappers/FyndSwapper/types.js

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

package/dist/esm/swappers/FyndSwapper/utils/constants.d.ts

@@ -0,0 +1,33 @@
+export declare const FYND_CHAINS: {
+    readonly "eip155:1": {
+        readonly name: "ethereum";
+        readonly routerAddress: "0x1644d2477f809cc2c71bccfd6dc9497e3f83210d";
+    };
+    readonly "eip155:8453": {
+        readonly name: "base";
+        readonly routerAddress: "0xaba5b53b03eafad1c5fc8bd5fc765fc85bb3de67";
+    };
+    readonly "eip155:42161": {
+        readonly name: "arbitrum";
+        readonly routerAddress: "0x924f147c50ea59f5180a26031a8b65b2aa1e81cd";
+    };
+    readonly "eip155:56": {
+        readonly name: "bsc";
+        readonly routerAddress: "0x7f3d12bbafb8955e51b3ab9588b34c8ad95bda4e";
+    };
+    readonly "eip155:137": {
+        readonly name: "polygon";
+        readonly routerAddress: "0xbd4e6011f03355c2a377fd9af939322a7d0a1bc1";
+    };
+    readonly "eip155:130": {
+        readonly name: "unichain";
+        readonly routerAddress: "0xcba5574597ad00ea250fd106dab4fc7461949635";
+    };
+    readonly "eip155:4663": {
+        readonly name: "robinhood";
+        readonly routerAddress: "0x09215a470bd585e59eb3f4b612fbd2678131ff9e";
+    };
+};
+export type FyndSupportedChainId = keyof typeof FYND_CHAINS;
+export declare const FYND_CLIENT_FEE_SHARE = 0.8;
+export declare const FYND_CLIENT_FEE_SIGNATURE_BYTES = 65;

package/dist/esm/swappers/FyndSwapper/utils/constants.js

@@ -0,0 +1,35 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+// Fynd Router Registry: https://docs.propellerheads.xyz/tycho/for-solvers/execution/contract-addresses
+export const FYND_CHAINS = {
+    [KnownChainIds.EthereumMainnet]: {
+        name: 'ethereum',
+        routerAddress: '0x1644d2477f809cc2c71bccfd6dc9497e3f83210d',
+    },
+    [KnownChainIds.BaseMainnet]: {
+        name: 'base',
+        routerAddress: '0xaba5b53b03eafad1c5fc8bd5fc765fc85bb3de67',
+    },
+    [KnownChainIds.ArbitrumMainnet]: {
+        name: 'arbitrum',
+        routerAddress: '0x924f147c50ea59f5180a26031a8b65b2aa1e81cd',
+    },
+    [KnownChainIds.BnbSmartChainMainnet]: {
+        name: 'bsc',
+        routerAddress: '0x7f3d12bbafb8955e51b3ab9588b34c8ad95bda4e',
+    },
+    [KnownChainIds.PolygonMainnet]: {
+        name: 'polygon',
+        routerAddress: '0xbd4e6011f03355c2a377fd9af939322a7d0a1bc1',
+    },
+    [KnownChainIds.UnichainMainnet]: {
+        name: 'unichain',
+        routerAddress: '0xcba5574597ad00ea250fd106dab4fc7461949635',
+    },
+    [KnownChainIds.RobinhoodMainnet]: {
+        name: 'robinhood',
+        routerAddress: '0x09215a470bd585e59eb3f4b612fbd2678131ff9e',
+    },
+};
+// Fynd keeps 20% of the client fee, so request the gross bps that nets affiliateBps
+export const FYND_CLIENT_FEE_SHARE = 0.8;
+export const FYND_CLIENT_FEE_SIGNATURE_BYTES = 65;

package/dist/esm/swappers/FyndSwapper/utils/fetchFromFynd.d.ts

@@ -0,0 +1,13 @@
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../../types.js';
+import type { FyndEncodedQuote, FyndTradeQuoteInput, FyndTradeRateInput } from '../types.js';
+import type { FyndSupportedChainId } from './constants.js';
+export declare const fetchFromFynd: ({ input, chainId, sender, receiver, slippageTolerancePercentageDecimal, clientFeeBps, baseUrl, }: {
+    input: FyndTradeQuoteInput | FyndTradeRateInput;
+    chainId: FyndSupportedChainId;
+    sender: string;
+    receiver: string;
+    slippageTolerancePercentageDecimal: string;
+    clientFeeBps: number;
+    baseUrl: string;
+}) => Promise<Result<FyndEncodedQuote, SwapErrorRight>>;

package/dist/esm/swappers/FyndSwapper/utils/fetchFromFynd.js

@@ -0,0 +1,38 @@
+import { Err } from '@sniptt/monads';
+import { FYND_CHAINS } from './constants.js';
+import { fyndService } from './fyndService.js';
+import { convertAssetIdToFyndToken, getFyndRequestError, validateFyndQuoteResponse, } from './helpers.js';
+export const fetchFromFynd = async ({ input, chainId, sender, receiver, slippageTolerancePercentageDecimal, clientFeeBps, baseUrl, }) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const maybeResponse = await fyndService.post(`${baseUrl}/${FYND_CHAINS[chainId].name}/quote`, {
+        orders: [
+            {
+                token_in: convertAssetIdToFyndToken(sellAsset.assetId),
+                token_out: convertAssetIdToFyndToken(buyAsset.assetId),
+                amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                side: 'sell',
+                sender,
+                receiver,
+            },
+        ],
+        options: {
+            timeout_ms: 5_000,
+            min_responses: 1,
+            encoding_options: {
+                slippage: slippageTolerancePercentageDecimal,
+                transfer_type: 'transfer_from',
+                // The proxy sets the fee receiver and deadline and signs the quote
+                ...(clientFeeBps > 0 ? { client_fee_params: { bps: clientFeeBps } } : {}),
+            },
+        },
+    });
+    if (maybeResponse.isErr())
+        return Err(getFyndRequestError(maybeResponse.unwrapErr()));
+    return validateFyndQuoteResponse(maybeResponse.unwrap().data, {
+        chainId,
+        sellAsset,
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        slippageTolerancePercentageDecimal,
+        clientFeeBps,
+    });
+};

package/dist/esm/swappers/FyndSwapper/utils/fyndService.d.ts

@@ -0,0 +1,5 @@
+export declare const fyndService: {
+    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/FyndSwapper/utils/fyndService.js

@@ -0,0 +1,3 @@
+import axios from 'axios';
+import { makeSwapperAxiosServiceMonadic } from '../../../utils/index.js';
+export const fyndService = makeSwapperAxiosServiceMonadic(axios.create({ timeout: 10_000 }));

package/dist/esm/swappers/FyndSwapper/utils/getFyndStepData.d.ts

@@ -0,0 +1,25 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { FyndEncodedQuote } from '../types.js';
+type BaseArgs = {
+    quote: FyndEncodedQuote;
+    sellAmountCryptoBaseUnit: string;
+    spenderAddress: string;
+};
+export type GetFyndStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type FyndRateStepData = {
+    networkFeeCryptoBaseUnit: string | undefined;
+};
+type FyndQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getFyndStepData(args: Extract<GetFyndStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<FyndRateStepData, SwapErrorRight>>;
+export declare function getFyndStepData(args: Extract<GetFyndStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<FyndQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/FyndSwapper/utils/getFyndStepData.js

@@ -0,0 +1,42 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit, getEvmRateNetworkFeeCryptoBaseUnit, } from '../../../utils/evm/index.js';
+export async function getFyndStepData(args) {
+    const { quote, sellAsset, sellAmountCryptoBaseUnit, spenderAddress, from, type, input, deps } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    const transactionData = {
+        type: 'evm',
+        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+        to: quote.transaction.to,
+        data: quote.transaction.data,
+        value: quote.transaction.value,
+    };
+    const stateOverride = { sellAsset, sellAmountCryptoBaseUnit, spenderAddress };
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await getEvmRateNetworkFeeCryptoBaseUnit({
+            adapter,
+            supportsEIP1559,
+            providerGasLimit: quote.gas_estimate,
+            simulation: { transactionData, from, stateOverride },
+        }).catch(() => undefined);
+        const stepData = { networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    try {
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride,
+            providerGasLimit: quote.gas_estimate,
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getFyndStepData', error));
+    }
+}

package/dist/esm/swappers/FyndSwapper/utils/getFyndTradeContext.d.ts

@@ -0,0 +1,18 @@
+import type { Result } from '@sniptt/monads';
+import type { QuoteFeeData, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { FyndTradeQuoteInput, FyndTradeRateInput } from '../types.js';
+import type { GetFyndStepDataArgs } from './getFyndStepData.js';
+type FyndTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    protocolFees: QuoteFeeData['protocolFees'];
+    deadline: number | undefined;
+    stepDataArgs: Omit<GetFyndStepDataArgs, 'type' | 'input'>;
+};
+export declare const getFyndTradeContext: ({ input, deps, from, to, }: {
+    input: FyndTradeQuoteInput | FyndTradeRateInput;
+    deps: SwapperDeps;
+    from: string;
+    to: string;
+}) => Promise<Result<FyndTradeContext, SwapErrorRight>>;
+export {};