@shapeshiftoss/swapper 17.8.0 → 19.0.0

package/dist/esm/swappers/BebopSwapper/getBebopTradeRate/getBebopTradeRate.js

@@ -1,94 +1,35 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
-import { bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
-import { v4 as uuid } from 'uuid';
-import { isAddress } from 'viem';
-import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
-import { SwapperName, TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { buildAffiliateFee } from '../../utils/affiliateFee.js';
-import { isNativeEvmAsset } from '../../utils/helpers/helpers.js';
+import { getAddress } from 'viem';
 import { BEBOP_DUMMY_ADDRESS } from '../types.js';
-import { fetchBebopQuote } from '../utils/fetchFromBebop.js';
-import { assertValidTrade, calculateRate } from '../utils/helpers/helpers.js';
-export async function getBebopTradeRate(input, assertGetEvmChainAdapter, _assetsById, apiKey) {
-    const { sellAsset, buyAsset, accountNumber, receiveAddress, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit, } = input;
-    const assertion = assertValidTrade({ buyAsset, sellAsset });
-    if (assertion.isErr())
-        return Err(assertion.unwrapErr());
-    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
-        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Bebop);
-    const address = receiveAddress ?? BEBOP_DUMMY_ADDRESS;
-    const maybeBebopQuoteResponse = await fetchBebopQuote({
-        buyAsset,
-        sellAsset,
-        sellAmountIncludingProtocolFeesCryptoBaseUnit,
-        takerAddress: address,
-        receiverAddress: address,
-        slippageTolerancePercentageDecimal,
-        affiliateBps,
-        apiKey,
+import { getBebopStepData } from '../utils/getBebopStepData.js';
+import { getBebopTradeContext } from '../utils/getBebopTradeContext.js';
+export const getBebopTradeRate = async (input, deps) => {
+    const { accountNumber, receiveAddress } = input;
+    const address = getAddress(receiveAddress ?? BEBOP_DUMMY_ADDRESS);
+    const maybeContext = await getBebopTradeContext({
+        input,
+        deps,
+        from: address,
+        receiver: address,
     });
-    if (maybeBebopQuoteResponse.isErr())
-        return Err(maybeBebopQuoteResponse.unwrapErr());
-    const quote = maybeBebopQuoteResponse.unwrap();
-    const sellTokenAddress = Object.keys(quote.sellTokens)[0];
-    const buyTokenAddress = Object.keys(quote.buyTokens)[0];
-    if (!isAddress(sellTokenAddress) || !isAddress(buyTokenAddress)) {
-        return Err(makeSwapErrorRight({
-            message: 'Invalid token addresses in response',
-            code: TradeQuoteError.InvalidResponse,
-        }));
-    }
-    const sellAmount = quote.sellTokens[sellTokenAddress].amount;
-    const buyAmount = quote.buyTokens[buyTokenAddress].amount;
-    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
-    const buyTokenData = quote.buyTokens[buyTokenAddress];
-    const buyAmountBeforeFeesCryptoBaseUnit = buyTokenData.amountBeforeFee || buyAmount;
-    const buyAmountAfterFeesCryptoBaseUnit = buyAmount;
-    const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-    const { fast } = await adapter.getGasFeeData();
-    const gasLimit = bnOrZero(quote.tx.gas).toString();
-    const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
-        ...fast,
-        supportsEIP1559: Boolean(input.supportsEIP1559),
-        gasLimit,
-    });
-    return Ok({
-        id: uuid(),
+    if (maybeContext.isErr())
+        return Err(maybeContext.unwrapErr());
+    const { tradeCommon, stepCommon, stepDataArgs } = maybeContext.unwrap();
+    const maybeStepData = await getBebopStepData({ ...stepDataArgs, type: 'rate', input });
+    if (maybeStepData.isErr())
+        return Err(maybeStepData.unwrapErr());
+    const { networkFeeCryptoBaseUnit } = maybeStepData.unwrap();
+    const tradeRate = {
+        ...tradeCommon,
         quoteOrRate: 'rate',
-        accountNumber: undefined,
         receiveAddress,
-        affiliateBps,
-        slippageTolerancePercentageDecimal,
-        rate,
-        swapperName: SwapperName.Bebop,
         steps: [
             {
-                estimatedExecutionTimeMs: 0,
-                allowanceContract: isNativeEvmAsset(sellAsset.assetId) ? undefined : quote.approvalTarget,
-                buyAsset,
-                sellAsset,
+                ...stepCommon,
                 accountNumber,
-                rate,
-                feeData: {
-                    protocolFees: {},
-                    networkFeeCryptoBaseUnit,
-                },
-                buyAmountBeforeFeesCryptoBaseUnit,
-                buyAmountAfterFeesCryptoBaseUnit,
-                sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                source: SwapperName.Bebop,
-                affiliateFee: buildAffiliateFee({
-                    strategy: 'buy_asset',
-                    affiliateBps,
-                    sellAsset,
-                    buyAsset,
-                    sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
-                    buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
-                    isEstimate: true,
-                }),
+                feeData: { protocolFees: {}, networkFeeCryptoBaseUnit },
             },
         ],
-    });
-}
+    };
+    return Ok([tradeRate]);
+};

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

@@ -1,8 +1,15 @@
 import { KnownChainIds } from '@shapeshiftoss/types';
 import type { Address, Hex } from 'viem';
-export declare const bebopSupportedEvmChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet];
-export declare const bebopSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.SolanaMainnet];
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, GetSolanaTradeQuoteInput, GetSolanaTradeRateInput } from '../../types.js';
+export type BebopTradeQuoteInput = GetEvmTradeQuoteInput | GetSolanaTradeQuoteInput;
+export type BebopTradeRateInput = GetEvmTradeRateInput | GetSolanaTradeRateInput;
+export declare const bebopSupportedEvmChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.RobinhoodMainnet];
+export declare const bebopSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.PolygonMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BaseMainnet, KnownChainIds.AvalancheMainnet, KnownChainIds.OptimismMainnet, KnownChainIds.BnbSmartChainMainnet, KnownChainIds.RobinhoodMainnet, KnownChainIds.SolanaMainnet];
 export type BebopSupportedChainId = (typeof bebopSupportedChainIds)[number];
+export type BebopMetadata = {
+    name: 'bebop';
+    quoteId: string;
+};
 export type BebopQuoteResponse = {
     requestId: string;
     type: string;

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

@@ -7,6 +7,7 @@ export const bebopSupportedEvmChainIds = [
     KnownChainIds.AvalancheMainnet,
     KnownChainIds.OptimismMainnet,
     KnownChainIds.BnbSmartChainMainnet,
+    KnownChainIds.RobinhoodMainnet,
 ];
 export const bebopSupportedChainIds = [
     ...bebopSupportedEvmChainIds,
@@ -20,6 +21,7 @@ export const chainIdToBebopChain = {
     [KnownChainIds.AvalancheMainnet]: 'avalanche',
     [KnownChainIds.OptimismMainnet]: 'optimism',
     [KnownChainIds.BnbSmartChainMainnet]: 'bsc',
+    [KnownChainIds.RobinhoodMainnet]: 'robinhood',
     [KnownChainIds.SolanaMainnet]: 'solana',
 };
 export const BEBOP_NATIVE_MARKER = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

package/dist/esm/swappers/BebopSwapper/utils/bebopService.js

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

package/dist/esm/swappers/BebopSwapper/utils/fetchFromBebop.js

@@ -3,11 +3,11 @@ import { bn, bnOrZero } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { getAddress } from 'viem';
 import { TradeQuoteError } from '../../../types.js';
-import { makeSwapErrorRight } from '../../../utils.js';
-import { getTreasuryAddressFromChainId } from '../../utils/helpers/helpers.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
 import { chainIdToBebopChain } from '../types.js';
 import { bebopServiceFactory } from './bebopService.js';
-import { assetIdToBebopSolanaToken, assetIdToBebopToken } from './helpers/helpers.js';
+import { assetIdToBebopSolanaToken, assetIdToBebopToken } from './helpers.js';
 export const fetchBebopQuote = async ({ buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, takerAddress, receiverAddress, slippageTolerancePercentageDecimal, affiliateBps, apiKey, }) => {
     try {
         const sellToken = assetIdToBebopToken(sellAsset.assetId);

package/dist/esm/swappers/BebopSwapper/utils/getBebopSolanaTradeContext.d.ts

@@ -0,0 +1,15 @@
+import type { Result } from '@sniptt/monads';
+import type { GetSolanaTradeQuoteInput, GetSolanaTradeRateInput, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { BebopSolanaQuoteResponse } from '../types.js';
+type BebopSolanaTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    response: BebopSolanaQuoteResponse;
+};
+export declare const getBebopSolanaTradeContext: ({ input, deps, takerAddress, receiverAddress, }: {
+    input: GetSolanaTradeQuoteInput | GetSolanaTradeRateInput;
+    deps: SwapperDeps;
+    takerAddress: string;
+    receiverAddress: string;
+}) => Promise<Result<BebopSolanaTradeContext, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/BebopSwapper/utils/getBebopSolanaTradeContext.js

@@ -0,0 +1,63 @@
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { fetchBebopSolanaQuote } from './fetchFromBebop.js';
+import { assertValidTrade, calculateRate } from './helpers.js';
+export const getBebopSolanaTradeContext = async ({ input, deps, takerAddress, receiverAddress, }) => {
+    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const assertion = assertValidTrade({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Bebop);
+    const maybeBebopQuoteResponse = await fetchBebopSolanaQuote({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        takerAddress,
+        receiverAddress,
+        slippageTolerancePercentageDecimal,
+        affiliateBps,
+        apiKey: deps.config.VITE_BEBOP_API_KEY,
+    });
+    if (maybeBebopQuoteResponse.isErr())
+        return Err(maybeBebopQuoteResponse.unwrapErr());
+    const response = maybeBebopQuoteResponse.unwrap();
+    const sellTokenAddress = Object.keys(response.sellTokens)[0];
+    const buyTokenAddress = Object.keys(response.buyTokens)[0];
+    if (!sellTokenAddress || !buyTokenAddress) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid token addresses in response',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const sellAmount = response.sellTokens[sellTokenAddress].amount;
+    const buyAmount = response.buyTokens[buyTokenAddress].amount;
+    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyTokenData = response.buyTokens[buyTokenAddress];
+    const buyAmountBeforeFeesCryptoBaseUnit = buyTokenData.amountBeforeFee || buyAmount;
+    const buyAmountAfterFeesCryptoBaseUnit = buyAmount;
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate,
+            swapperName: SwapperName.Bebop,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            allowanceContract: '',
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: SwapperName.Bebop,
+            estimatedExecutionTimeMs: 0,
+        },
+        response,
+    });
+};

package/dist/esm/swappers/BebopSwapper/utils/getBebopStepData.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from '@sniptt/monads';
+import type { StepDataArgs, SwapErrorRight, TxBuildData } from '../../../types.js';
+import type { BebopQuoteResponse } from '../types.js';
+type BaseArgs = {
+    tx: BebopQuoteResponse['tx'];
+    spenderAddress: string;
+};
+export type GetBebopStepDataArgs = StepDataArgs<BaseArgs, {
+    from: string;
+}>;
+type BebopRateStepData = {
+    networkFeeCryptoBaseUnit: string;
+};
+type BebopQuoteStepData = {
+    transactionData: TxBuildData;
+    networkFeeCryptoBaseUnit: string;
+};
+export declare function getBebopStepData(args: Extract<GetBebopStepDataArgs, {
+    type: 'rate';
+}>): Promise<Result<BebopRateStepData, SwapErrorRight>>;
+export declare function getBebopStepData(args: Extract<GetBebopStepDataArgs, {
+    type: 'quote';
+}>): Promise<Result<BebopQuoteStepData, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/BebopSwapper/utils/getBebopStepData.js

@@ -0,0 +1,53 @@
+import { fromChainId } from '@shapeshiftoss/caip';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { fromHex } from 'viem';
+import { makeNetworkFeeEstimationFailedErr } from '../../../utils/index.js';
+import { getEvmNetworkFeeCryptoBaseUnit } from '../../../utils/evm/index.js';
+export async function getBebopStepData(args) {
+    const { tx, spenderAddress, sellAsset, type, input, from, deps } = args;
+    const adapter = deps.assertGetEvmChainAdapter(sellAsset.chainId);
+    const supportsEIP1559 = 'supportsEIP1559' in input ? input.supportsEIP1559 : false;
+    if (type === 'rate') {
+        const networkFeeCryptoBaseUnit = await (async () => {
+            try {
+                return await getEvmNetworkFeeCryptoBaseUnit({
+                    adapter,
+                    supportsEIP1559,
+                    gasLimit: bnOrZero(tx.gas).toString(),
+                });
+            }
+            catch {
+                return bnOrZero(tx.gas).times(bnOrZero(tx.gasPrice)).toFixed(0);
+            }
+        })();
+        const stepData = { networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    const transactionData = {
+        type: 'evm',
+        chainId: Number(fromChainId(sellAsset.chainId).chainReference),
+        to: tx.to,
+        data: tx.data,
+        value: fromHex(tx.value, 'bigint').toString(),
+        gasLimit: tx.gas?.toString(),
+    };
+    try {
+        const networkFeeCryptoBaseUnit = await getEvmNetworkFeeCryptoBaseUnit({
+            adapter,
+            transactionData,
+            from,
+            supportsEIP1559,
+            stateOverride: {
+                sellAsset,
+                sellAmountCryptoBaseUnit: input.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                spenderAddress,
+            },
+        });
+        const stepData = { transactionData, networkFeeCryptoBaseUnit };
+        return Ok(stepData);
+    }
+    catch (error) {
+        return Err(makeNetworkFeeEstimationFailedErr('getBebopStepData', error));
+    }
+}

package/dist/esm/swappers/BebopSwapper/utils/getBebopTradeContext.d.ts

@@ -0,0 +1,17 @@
+import type { Result } from '@sniptt/monads';
+import type { Address } from 'viem';
+import type { GetEvmTradeQuoteInput, GetEvmTradeRateInput, SwapErrorRight, SwapperDeps, TradeCommon, TradeStepCommon } from '../../../types.js';
+import type { GetBebopStepDataArgs } from './getBebopStepData.js';
+type BebopTradeContext = {
+    tradeCommon: TradeCommon;
+    stepCommon: Omit<TradeStepCommon, 'feeData'>;
+    stepDataArgs: Omit<GetBebopStepDataArgs, 'type' | 'input'>;
+    deadline: number;
+};
+export declare const getBebopTradeContext: ({ input, deps, from, receiver, }: {
+    input: GetEvmTradeQuoteInput | GetEvmTradeRateInput;
+    deps: SwapperDeps;
+    from: Address;
+    receiver: Address;
+}) => Promise<Result<BebopTradeContext, SwapErrorRight>>;
+export {};

package/dist/esm/swappers/BebopSwapper/utils/getBebopTradeContext.js

@@ -0,0 +1,83 @@
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { isAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { buildAffiliateFee } from '../../../utils/affiliateFee.js';
+import { isNativeEvmAsset, normalizeEpochToMs } from '../../../utils/helpers.js';
+import { fetchBebopQuote } from './fetchFromBebop.js';
+import { assertValidTrade, calculateRate } from './helpers.js';
+export const getBebopTradeContext = async ({ input, deps, from, receiver, }) => {
+    const { sellAsset, buyAsset, affiliateBps, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const assertion = assertValidTrade({ buyAsset, sellAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const slippageTolerancePercentageDecimal = input.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Bebop);
+    const maybeBebopQuoteResponse = await fetchBebopQuote({
+        buyAsset,
+        sellAsset,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        takerAddress: from,
+        receiverAddress: receiver,
+        slippageTolerancePercentageDecimal,
+        affiliateBps,
+        apiKey: deps.config.VITE_BEBOP_API_KEY,
+    });
+    if (maybeBebopQuoteResponse.isErr())
+        return Err(maybeBebopQuoteResponse.unwrapErr());
+    const quote = maybeBebopQuoteResponse.unwrap();
+    const sellTokenAddress = Object.keys(quote.sellTokens)[0];
+    const buyTokenAddress = Object.keys(quote.buyTokens)[0];
+    if (!isAddress(sellTokenAddress) || !isAddress(buyTokenAddress)) {
+        return Err(makeSwapErrorRight({
+            message: 'Invalid token addresses in response',
+            code: TradeQuoteError.InvalidResponse,
+        }));
+    }
+    const sellAmount = quote.sellTokens[sellTokenAddress].amount;
+    const buyAmount = quote.buyTokens[buyTokenAddress].amount;
+    const rate = calculateRate({ buyAmount, sellAmount, buyAsset, sellAsset });
+    const buyTokenData = quote.buyTokens[buyTokenAddress];
+    const buyAmountBeforeFeesCryptoBaseUnit = buyTokenData.amountBeforeFee || buyAmount;
+    const buyAmountAfterFeesCryptoBaseUnit = buyAmount;
+    const allowanceContract = isNativeEvmAsset(sellAsset.assetId) ? '' : quote.approvalTarget;
+    return Ok({
+        tradeCommon: {
+            id: uuid(),
+            rate,
+            swapperName: SwapperName.Bebop,
+            affiliateBps,
+            slippageTolerancePercentageDecimal,
+        },
+        stepCommon: {
+            allowanceContract,
+            rate,
+            buyAmountBeforeFeesCryptoBaseUnit,
+            buyAmountAfterFeesCryptoBaseUnit,
+            sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAsset,
+            sellAsset,
+            source: SwapperName.Bebop,
+            estimatedExecutionTimeMs: 0,
+            affiliateFee: buildAffiliateFee({
+                strategy: 'buy_asset',
+                affiliateBps,
+                sellAsset,
+                buyAsset,
+                sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                isEstimate: true,
+            }),
+        },
+        stepDataArgs: {
+            tx: quote.tx,
+            spenderAddress: allowanceContract,
+            sellAsset,
+            from,
+            deps,
+        },
+        deadline: normalizeEpochToMs(quote.expiry),
+    });
+};

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

@@ -1,13 +1,12 @@
 import type { AssetId, ChainId } from '@shapeshiftoss/caip';
 import type { Asset } from '@shapeshiftoss/types';
-export declare const isSolanaChainId: (chainId: ChainId) => boolean;
 export declare const assetIdToBebopToken: (assetId: AssetId) => string;
 export declare const assetIdToBebopSolanaToken: (assetId: AssetId) => string;
-export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.AvalancheMainnet | import("@shapeshiftoss/types").KnownChainIds.OptimismMainnet | import("@shapeshiftoss/types").KnownChainIds.BnbSmartChainMainnet | import("@shapeshiftoss/types").KnownChainIds.PolygonMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BaseMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet;
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is import("@shapeshiftoss/types").KnownChainIds.EthereumMainnet | import("@shapeshiftoss/types").KnownChainIds.AvalancheMainnet | import("@shapeshiftoss/types").KnownChainIds.OptimismMainnet | import("@shapeshiftoss/types").KnownChainIds.BnbSmartChainMainnet | import("@shapeshiftoss/types").KnownChainIds.PolygonMainnet | import("@shapeshiftoss/types").KnownChainIds.ArbitrumMainnet | import("@shapeshiftoss/types").KnownChainIds.BaseMainnet | import("@shapeshiftoss/types").KnownChainIds.SolanaMainnet | import("@shapeshiftoss/types").KnownChainIds.RobinhoodMainnet;
 export declare const assertValidTrade: ({ buyAsset, sellAsset, }: {
     buyAsset: Asset;
     sellAsset: Asset;
-}) => import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../../types.js").SwapErrorRight> | import("@sniptt/monads/build/result/result").ResOk<boolean, never>;
+}) => import("@sniptt/monads/build/result/result").ResOk<boolean, never> | import("@sniptt/monads/build/result/result").ResErr<unknown, import("../../../types.js").SwapErrorRight>;
 /**
  * Bebop's /order endpoint has a bug where it hardcodes the taker signature placement
  * at the last signer index. When the taker's pubkey bytes sort before the maker's,

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

@@ -3,12 +3,9 @@ import { bn, convertPrecision, isToken } from '@shapeshiftoss/utils';
 import { Err, Ok } from '@sniptt/monads';
 import { PublicKey, VersionedTransaction } from '@solana/web3.js';
 import { getAddress } from 'viem';
-import { TradeQuoteError } from '../../../../types.js';
-import { makeSwapErrorRight } from '../../../../utils.js';
-import { BEBOP_NATIVE_MARKER, bebopSupportedChainIds } from '../../types.js';
-export const isSolanaChainId = (chainId) => {
-    return chainId === solanaChainId;
-};
+import { TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils/index.js';
+import { BEBOP_NATIVE_MARKER, bebopSupportedChainIds } from '../types.js';
 export const assetIdToBebopToken = (assetId) => {
     if (!isToken(assetId))
         return BEBOP_NATIVE_MARKER;

package/dist/esm/swappers/BobGatewaySwapper/BobGatewaySwapper.js

@@ -1,5 +1,6 @@
-import { executeEvmTransaction } from '../../utils.js';
+import { executeEvmTransaction, executeTronTransaction } from '../../utils/index.js';
 export const bobGatewaySwapper = {
     executeEvmTransaction,
     executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => signAndBroadcastTransaction(txToSign),
+    executeTronTransaction,
 };

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

@@ -1,102 +1,43 @@
 import { isGatewayError } from '@gobob/bob-sdk';
-import { evm } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { bnOrZero } from '@shapeshiftoss/utils';
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getExecutableTradeStep, getSwapMetadata, isExecutableTradeQuote } from '../../utils/index.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getTronTransactionFees } from '../../utils/tron/index.js';
+import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { getBobGatewayTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getBobGatewayTradeRate } from './swapperApi/getTradeRate.js';
-import { getBobGatewayClient, mapBobGatewayOrderStatusToTxStatus, registerBobGatewayTx, } from './utils/helpers.js';
+import { getBobGatewayClient, mapBobGatewayOrderStatusToTxStatus, registerBobGatewayTx, toTronBase58, } from './utils/helpers.js';
 const registeredSwapIds = new Set();
 export const bobGatewayApi = {
-    getTradeRate: async (input, deps) => {
-        return (await getBobGatewayTradeRate(input, deps)).map(tradeRate => [tradeRate]);
-    },
-    getTradeQuote: async (input, deps) => {
-        return (await getBobGatewayTradeQuote(input, deps)).map(tradeQuote => [tradeQuote]);
-    },
-    getUnsignedUtxoTransaction: ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote)) {
-            throw new Error('[BobGateway] unable to execute a trade rate');
-        }
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { bobSpecific, sellAsset } = step;
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        if (!bobSpecific?.utxoTx)
-            throw new Error('[BobGateway] invalid utxo transaction');
-        const { depositAddress, opReturnData } = bobSpecific.utxoTx;
-        return adapter.buildSendApiTransaction({
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            xpub,
-            to: depositAddress,
-            accountNumber: step.accountNumber,
-            skipToAddressValidation: true,
-            chainSpecific: {
-                accountType,
-                opReturnData,
-                satoshiPerByte: step.feeData.chainSpecific.satsPerByte,
-            },
-        });
-    },
-    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
+    getTradeRate: (input, deps) => getBobGatewayTradeRate(input, deps),
+    getTradeQuote: (input, deps) => getBobGatewayTradeQuote(input, deps),
+    getUnsignedUtxoTransaction,
+    getUtxoTransactionFees,
+    getUnsignedEvmTransaction,
+    getEvmTransactionFees,
+    getUnsignedTronTransaction: ({ from, stepIndex, tradeQuote, assertGetTronChainAdapter }) => {
         if (!isExecutableTradeQuote(tradeQuote)) {
             throw new Error('[BobGateway] unable to execute a trade rate');
         }
         const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { bobSpecific, sellAsset } = step;
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        if (!bobSpecific?.utxoTx)
-            throw new Error('[BobGateway] invalid utxo transaction');
-        const { depositAddress, opReturnData } = bobSpecific.utxoTx;
-        const { fast } = await adapter.getFeeData({
-            to: depositAddress,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub, opReturnData },
-            sendMax: false,
-        });
-        return fast.txFee;
-    },
-    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, assertGetEvmChainAdapter, supportsEIP1559, }) => {
-        if (!isExecutableTradeQuote(tradeQuote)) {
-            throw new Error('[BobGateway] unable to execute a trade rate');
-        }
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, bobSpecific, sellAsset } = step;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        if (!bobSpecific?.evmTx)
-            throw new Error('[BobGateway] invalid evm transaction');
-        const { to, data, value } = bobSpecific.evmTx;
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        // Pad the gas limit of the tx we actually broadcast to reduce the risk of out-of-gas reverts.
-        const gasLimit = bnOrZero(feeData.gasLimit).times(1.2).toFixed(0);
+        const { accountNumber, sellAsset, transactionData } = step;
+        if (transactionData?.type !== 'tron')
+            throw new Error('[BobGateway] invalid tron transaction');
+        const adapter = assertGetTronChainAdapter(sellAsset.chainId);
+        const { to, data, value } = transactionData;
         return adapter.buildCustomApiTx({
             accountNumber,
             from,
-            to,
+            to: toTronBase58(to),
             value,
             data,
-            ...feeData,
-            gasLimit,
         });
     },
-    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote)) {
-            throw new Error('[BobGateway] unable to execute a trade rate');
-        }
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { bobSpecific, sellAsset } = step;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        if (!bobSpecific?.evmTx)
-            throw new Error('[BobGateway] invalid evm transaction');
-        const { to, data, value } = bobSpecific.evmTx;
-        const feeData = await evm.getFees({ adapter, data, to, value, from, supportsEIP1559 });
-        return feeData.networkFeeCryptoBaseUnit;
-    },
+    getTronTransactionFees,
     checkTradeStatus: async ({ swap, config, txHash }) => {
         if (!swap)
             throw new Error('[BobGateway] swap is required for status check');
-        const orderId = swap.metadata.bobSpecific?.orderId;
-        if (!orderId)
-            throw new Error('[BobGateway] orderId is required for status check');
+        const { orderId } = getSwapMetadata(swap.metadata.swapperMetadata, 'bob');
         if (txHash && !registeredSwapIds.has(swap.id)) {
             try {
                 await registerBobGatewayTx({

package/dist/esm/swappers/BobGatewaySwapper/swapperApi/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 getBobGatewayTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;
+import type { SwapErrorRight, SwapperDeps, TradeQuote } from '../../../types.js';
+import type { BobGatewayTradeQuoteInput } from '../types.js';
+export declare const getBobGatewayTradeQuote: (input: BobGatewayTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;