@shapeshiftoss/swapper 17.7.3 → 18.1.0

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

@@ -0,0 +1,250 @@
+import { GatewayErrorCode, GatewaySDK, isGatewayError } from '@gobob/bob-sdk';
+import { ASSET_NAMESPACE, btcChainId, ethChainId, fromAssetId, toAssetId, tronChainId, } from '@shapeshiftoss/caip';
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { bnOrZero, chainIdToFeeAssetId, contractAddressOrUndefined, isToken, } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { TronWeb } from 'tronweb';
+import { getAddress, zeroAddress } from 'viem';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { createTradeAmountTooSmallErr, makeSwapErrorRight } from '../../../utils/index.js';
+import { getTreasuryAddressFromChainId } from '../../../utils/helpers.js';
+import { BOB_GATEWAY_BASE_URL, bobGatewayChainNameToChainId, chainIdToBobGatewayChainName, decimalSlippageToBobBps, DUMMY_BTC_ADDRESS, DUMMY_EVM_ADDRESS, DUMMY_TRON_ADDRESS, } from './constants.js';
+export const dummyAddressForChainId = (chainId) => {
+    if (chainId === btcChainId)
+        return DUMMY_BTC_ADDRESS;
+    if (chainId === tronChainId)
+        return DUMMY_TRON_ADDRESS;
+    return DUMMY_EVM_ADDRESS;
+};
+export const getBobGatewayClient = (config) => {
+    return new GatewaySDK({ basePath: BOB_GATEWAY_BASE_URL, apiKey: config.VITE_BOB_GATEWAY_API_KEY });
+};
+export const toTronBase58 = (address) => {
+    if (address.startsWith('T'))
+        return address;
+    if (address.startsWith('0x'))
+        return TronWeb.address.fromHex(address.slice(2));
+    return TronWeb.address.fromHex(address);
+};
+export const assetIdToBobGatewayToken = (assetId) => {
+    // BOB Gateway uses the zero address as the token address for native assets
+    if (!isToken(assetId))
+        return zeroAddress;
+    return fromAssetId(assetId).assetReference;
+};
+export const getBobGatewayAffiliates = (affiliateBps) => {
+    const bps = bnOrZero(affiliateBps);
+    if (!bps.isFinite() || bps.lte(0))
+        return undefined;
+    const affiliateAddress = getTreasuryAddressFromChainId(ethChainId);
+    return [{ address: getAddress(affiliateAddress), bps: bps.toNumber() }];
+};
+export const getBobGatewayQuote = async ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, amount, affiliateBps, slippageTolerancePercentageDecimal, }) => {
+    const slippage = decimalSlippageToBobBps(slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.BobGateway));
+    try {
+        const quote = await getBobGatewayClient(config).getQuote({
+            fromChain: sellChainName,
+            toChain: buyChainName,
+            fromToken: assetIdToBobGatewayToken(sellAsset.assetId),
+            toToken: assetIdToBobGatewayToken(buyAsset.assetId),
+            fromUserAddress: sender,
+            toUserAddress: recipient,
+            amount,
+            maxSlippage: Number(slippage),
+            ownerAddress: sellChainName === 'bitcoin' ? recipient : sender,
+            affiliates: getBobGatewayAffiliates(affiliateBps),
+        });
+        return Ok(quote);
+    }
+    catch (err) {
+        if (isGatewayError(err)) {
+            switch (err.code) {
+                case GatewayErrorCode.QuoteAmountTooLow:
+                    return Err(createTradeAmountTooSmallErr({
+                        minAmountCryptoBaseUnit: err.details.minimum,
+                        assetId: sellAsset.assetId,
+                    }));
+                case GatewayErrorCode.UnableToCoverFees:
+                    return Err(makeSwapErrorRight({
+                        message: '[BobGateway] sell amount does not cover fees',
+                        code: TradeQuoteError.SellAmountBelowTradeFee,
+                        cause: err,
+                    }));
+                case GatewayErrorCode.NoRoute:
+                    return Err(makeSwapErrorRight({
+                        message: '[BobGateway] no route found for trade pair',
+                        code: TradeQuoteError.NoRouteFound,
+                        cause: err,
+                    }));
+                case GatewayErrorCode.DisabledChain:
+                    return Err(makeSwapErrorRight({
+                        message: '[BobGateway] trading is temporarily halted for this chain',
+                        code: TradeQuoteError.TradingHalted,
+                        cause: err,
+                    }));
+                default:
+                    break;
+            }
+        }
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] failed to fetch quote',
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+export const createBobGatewayOrder = async (config, quote) => {
+    try {
+        const order = await getBobGatewayClient(config).api.createOrderV3({ gatewayQuoteV3: quote });
+        return Ok(order);
+    }
+    catch (err) {
+        if (isGatewayError(err) && err.code === GatewayErrorCode.InsufficientConfirmedFunds) {
+            return Err(makeSwapErrorRight({
+                message: '[BobGateway] insufficient confirmed balance',
+                code: TradeQuoteError.InsufficientFundsUnconfirmed,
+                cause: err,
+            }));
+        }
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] failed to create order',
+            code: TradeQuoteError.QueryFailed,
+            cause: err,
+        }));
+    }
+};
+export const registerBobGatewayTx = async ({ config, orderId, txHash, sellAsset, buyAsset, }) => {
+    const registerTxV3 = (() => {
+        const sellChainName = chainIdToBobGatewayChainName[sellAsset.chainId];
+        // BTC→EVM
+        if (sellChainName === 'bitcoin') {
+            return { onramp: { orderId, bitcoinTxid: txHash } };
+        }
+        // EVM→BTC
+        if (chainIdToBobGatewayChainName[buyAsset.chainId] === 'bitcoin') {
+            return { offramp: { orderId, srcChain: sellChainName, srcTxHash: txHash } };
+        }
+        // EVM→EVM
+        return { tokenSwap: { orderId, srcChain: sellChainName, srcTxHash: txHash } };
+    })();
+    await getBobGatewayClient(config).api.registerTxV3({ registerTxV3 });
+};
+export const mapBobGatewayOrderStatusToTxStatus = (status) => {
+    if ('inProgress' in status)
+        return TxStatus.Pending;
+    if ('success' in status)
+        return TxStatus.Confirmed;
+    if ('failed' in status)
+        return TxStatus.Failed;
+    if ('refunded' in status)
+        return TxStatus.Failed;
+    return TxStatus.Unknown;
+};
+const bobGatewayFeeToAssetId = (fee) => {
+    const chainId = bobGatewayChainNameToChainId[fee.chain];
+    if (!chainId)
+        return;
+    if (fee.address.toLowerCase() === zeroAddress)
+        return chainIdToFeeAssetId(chainId);
+    if (chainId === tronChainId) {
+        return toAssetId({
+            chainId,
+            assetNamespace: ASSET_NAMESPACE.trc20,
+            assetReference: toTronBase58(fee.address),
+        });
+    }
+    return toAssetId({
+        chainId,
+        assetNamespace: ASSET_NAMESPACE.erc20,
+        assetReference: fee.address,
+    });
+};
+export const parseBobGatewayQuote = (quote, buyAsset, assetsById) => {
+    const { outputAmount, estimatedTimeInSecs, fees } = (() => {
+        if ('onramp' in quote) {
+            const { outputAmount, estimatedTimeInSecs, fees } = quote.onramp;
+            return { outputAmount, estimatedTimeInSecs, fees: [fees] };
+        }
+        if ('offramp' in quote) {
+            const { outputAmount, estimatedTimeInSecs, feeBreakdown } = quote.offramp;
+            const { affiliateFee, inclusionFee, protocolFee, solverFee } = feeBreakdown;
+            return {
+                outputAmount,
+                estimatedTimeInSecs,
+                fees: [affiliateFee, inclusionFee, protocolFee, solverFee],
+            };
+        }
+        const { outputAmount, estimatedTimeInSecs, fees } = quote.tokenSwap;
+        return { outputAmount, estimatedTimeInSecs, fees: [fees] };
+    })();
+    const protocolFees = fees.reduce((acc, fee) => {
+        const amountCryptoBaseUnit = bnOrZero(fee.amount);
+        if (amountCryptoBaseUnit.lte(0))
+            return acc;
+        const assetId = bobGatewayFeeToAssetId(fee);
+        if (!assetId)
+            return acc;
+        const asset = assetId === buyAsset.assetId ? buyAsset : assetsById[assetId];
+        if (!asset)
+            return acc;
+        acc[assetId] = {
+            amountCryptoBaseUnit: bnOrZero(acc[assetId]?.amountCryptoBaseUnit)
+                .plus(amountCryptoBaseUnit)
+                .toFixed(),
+            asset,
+            requiresBalance: false,
+        };
+        return acc;
+    }, {});
+    // buyAmountBeforeFees is denominated in the buy asset, so only add back buy-asset-denominated fees
+    const buyAssetFeeCryptoBaseUnit = bnOrZero(protocolFees[buyAsset.assetId]?.amountCryptoBaseUnit);
+    return {
+        buyAmountBeforeFeesCryptoBaseUnit: buyAssetFeeCryptoBaseUnit
+            .plus(bnOrZero(outputAmount.amount))
+            .toFixed(),
+        buyAmountAfterFeesCryptoBaseUnit: outputAmount.amount,
+        protocolFees,
+        estimatedExecutionTimeMs: typeof estimatedTimeInSecs === 'number' ? estimatedTimeInSecs * 1000 : undefined,
+    };
+};
+export const getBobGatewayAllowanceContract = (quote, sellAsset) => {
+    const isTron = sellAsset.chainId === tronChainId;
+    if (!isEvmChainId(sellAsset.chainId) && !isTron)
+        return '';
+    if (!contractAddressOrUndefined(sellAsset.assetId))
+        return '';
+    const txTo = (() => {
+        if ('offramp' in quote)
+            return quote.offramp.txTo;
+        if ('tokenSwap' in quote)
+            return quote.tokenSwap.txTo;
+        return '';
+    })();
+    if (!txTo)
+        return '';
+    if (isTron)
+        return toTronBase58(txTo);
+    return txTo;
+};
+export const assertValidTrade = ({ sellAsset, buyAsset, }) => {
+    const sellChainName = chainIdToBobGatewayChainName[sellAsset.chainId];
+    const buyChainName = chainIdToBobGatewayChainName[buyAsset.chainId];
+    if (!sellChainName) {
+        return Err(makeSwapErrorRight({
+            message: `[BobGateway] unsupported sell chain: ${sellAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!buyChainName) {
+        return Err(makeSwapErrorRight({
+            message: `[BobGateway] unsupported buy chain: ${buyAsset.chainId}`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    return Ok({ sellChainName, buyChainName });
+};

package/dist/esm/swappers/ButterSwap/ButterSwap.js

@@ -1,4 +1,4 @@
-import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils.js';
+import { executeEvmTransaction, executeSolanaTransaction, executeTronTransaction, } from '../../utils/index.js';
 export const butterSwap = {
     executeEvmTransaction,
     executeSolanaTransaction,

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

@@ -1,123 +1,19 @@
-import { evm } from '@shapeshiftoss/chain-adapters';
-import BigNumber from 'bignumber.js';
-import { getSolanaTransactionFees } from '../../solana-utils/getSolanaTransactionFees.js';
-import { getUnsignedSolanaTransaction } from '../../solana-utils/getUnsignedSolanaTransaction.js';
-import { getTronTransactionFees } from '../../tron-utils/getTronTransactionFees.js';
-import { getUnsignedTronTransaction } from '../../tron-utils/getUnsignedTronTransaction.js';
-import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { getEvmTransactionFees, getUnsignedEvmTransaction } from '../../utils/evm/index.js';
+import { getSolanaTransactionFees } from '../../utils/solana/getSolanaTransactionFees.js';
+import { getUnsignedSolanaTransaction } from '../../utils/solana/getUnsignedSolanaTransaction.js';
+import { getTronTransactionFees, getUnsignedTronTransaction } from '../../utils/tron/index.js';
+import { getUnsignedUtxoTransaction, getUtxoTransactionFees } from '../../utils/utxo/index.js';
 import { checkTradeStatus } from './swapperApi/checkTradeStatus.js';
 import { getTradeQuote } from './swapperApi/getTradeQuote.js';
 import { getTradeRate } from './swapperApi/getTradeRate.js';
 export const butterSwapApi = {
-    getTradeQuote,
-    getTradeRate,
+    getTradeQuote: (input, deps) => getTradeQuote(input, deps),
+    getTradeRate: (input, deps) => getTradeRate(input, deps),
     checkTradeStatus,
-    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 { butterSwapTransactionMetadata, sellAsset } = step;
-        if (!butterSwapTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { to, data, gasLimit, value } = butterSwapTransactionMetadata;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({
-            adapter,
-            data,
-            to,
-            value: BigInt(value).toString(),
-            from,
-            supportsEIP1559,
-        });
-        const networkFeeCryptoBaseUnit = evm.calcNetworkFeeCryptoBaseUnit({
-            gasLimit,
-            gasPrice: feeData.gasPrice ?? '0',
-            maxFeePerGas: feeData.maxFeePerGas,
-            maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
-            supportsEIP1559,
-        });
-        return BigNumber.max(feeData.networkFeeCryptoBaseUnit, networkFeeCryptoBaseUnit).toFixed();
-    },
-    getUnsignedEvmTransaction: async (args) => {
-        const { from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter } = args;
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, butterSwapTransactionMetadata } = step;
-        if (!butterSwapTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { to, data, gasLimit, value } = butterSwapTransactionMetadata;
-        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
-        const feeData = await evm.getFees({
-            adapter,
-            data,
-            to,
-            value: BigInt(value).toString(),
-            from,
-            supportsEIP1559,
-        });
-        return adapter.buildCustomApiTx({
-            accountNumber,
-            data,
-            from,
-            to,
-            value: BigInt(value).toString(),
-            ...feeData,
-            gasLimit: BigNumber.max(feeData.gasLimit, gasLimit).toFixed(),
-        });
-    },
-    getUnsignedUtxoTransaction: async ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { accountNumber, sellAsset, butterSwapTransactionMetadata } = step;
-        if (!butterSwapTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { to, memo } = butterSwapTransactionMetadata;
-        if (!to)
-            throw new Error('Missing deposit address');
-        if (!memo)
-            throw new Error('Missing memo (opReturnData)');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub, opReturnData: memo },
-            sendMax: false,
-        });
-        return adapter.buildSendApiTransaction({
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            xpub,
-            to,
-            accountNumber,
-            chainSpecific: {
-                accountType,
-                opReturnData: memo,
-                satoshiPerByte: fast.chainSpecific.satoshiPerByte,
-            },
-        });
-    },
-    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
-        if (!isExecutableTradeQuote(tradeQuote))
-            throw new Error('Unable to execute a trade rate quote');
-        const step = getExecutableTradeStep(tradeQuote, stepIndex);
-        const { sellAsset, butterSwapTransactionMetadata } = step;
-        if (!butterSwapTransactionMetadata)
-            throw new Error('Transaction metadata is required');
-        const { to, memo } = butterSwapTransactionMetadata;
-        if (!to)
-            throw new Error('Missing deposit address');
-        if (!memo)
-            throw new Error('Missing memo (opReturnData)');
-        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
-        const { fast } = await adapter.getFeeData({
-            to,
-            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
-            chainSpecific: { pubkey: xpub, opReturnData: memo },
-            sendMax: false,
-        });
-        return fast.txFee;
-    },
+    getEvmTransactionFees,
+    getUnsignedEvmTransaction,
+    getUnsignedUtxoTransaction,
+    getUtxoTransactionFees,
     getUnsignedSolanaTransaction,
     getSolanaTransactionFees,
     getTronTransactionFees,

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

@@ -1 +1,2 @@
 export * from './endpoints.js';
+export { butterSwap } from './ButterSwap.js';

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

@@ -1 +1,2 @@
 export * from './endpoints.js';
+export { butterSwap } from './ButterSwap.js';

package/dist/esm/swappers/ButterSwap/swapperApi/checkTradeStatus.js

@@ -1,7 +1,7 @@
 import { solanaChainId, tronChainId } from '@shapeshiftoss/caip';
 import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
-import { checkEvmSwapStatus, checkSolanaSwapStatus, createDefaultStatusResponse, } from '../../../utils.js';
+import { checkEvmSwapStatus, checkSolanaSwapStatus, createDefaultStatusResponse, } from '../../../utils/index.js';
 import { getBridgeInfoBySourceHash } from '../xhr.js';
 // See: https://docs.butternetwork.io/butter-swap-integration/butter-api-for-swap-data/get-swap-history-by-source-hash
 // Example endpoint: https://bs-app-api.chainservice.io/api/queryBridgeInfoBySourceHash?hash=0x...
@@ -72,7 +72,7 @@ export const checkTradeStatus = async (input) => {
         // Use toHash as the destination chain tx hash if present
         const destinationTxHash = bridgeInfo.toHash ?? undefined;
         const relayerTxHash = bridgeInfo.relayerHash ?? undefined;
-        const relayerExplorerTxLink = bridgeInfo.relayerChain?.scanUrl ?? undefined;
+        const relayerScanUrl = bridgeInfo.relayerChain?.scanUrl ?? undefined;
         // State mapping: 0 = pending, 1 = complete, 6 = refunded/failed
         let status = (() => {
             // Optimistically return Confirmed if we have a destination tx hash, useful to chains with long block
@@ -93,8 +93,8 @@ export const checkTradeStatus = async (input) => {
         return {
             status,
             buyTxHash: destinationTxHash,
-            relayerTxHash,
-            relayerExplorerTxLink,
+            swapperTxId: relayerTxHash,
+            swapperTxLink: relayerTxHash && relayerScanUrl ? `${relayerScanUrl}tx/${relayerTxHash}` : undefined,
             message: undefined,
         };
     }

package/dist/esm/swappers/ButterSwap/swapperApi/checkTradeStatus.test.js

@@ -2,7 +2,7 @@ import { solanaChainId } from '@shapeshiftoss/caip';
 import { TxStatus } from '@shapeshiftoss/unchained-client';
 import { Ok } from '@sniptt/monads';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import * as utils from '../../../utils.js';
+import * as utils from '../../../utils/index.js';
 import * as xhr from '../xhr.js';
 import { checkTradeStatus } from './checkTradeStatus.js';
 // Mock the utility functions
@@ -123,7 +123,7 @@ describe('checkTradeStatus same-chain short-circuit', () => {
             state: 1,
             toHash: 'dest-tx',
             relayerHash: 'relayer-tx',
-            relayerChain: { scanUrl: 'https://scan.url' },
+            relayerChain: { scanUrl: 'https://scan.url/' },
         };
         vi.mocked(xhr.getBridgeInfoBySourceHash).mockResolvedValue(Ok(mockBridgeInfo));
         const input = {
@@ -149,8 +149,8 @@ describe('checkTradeStatus same-chain short-circuit', () => {
         expect(result).toEqual({
             status: TxStatus.Confirmed,
             buyTxHash: 'dest-tx',
-            relayerTxHash: 'relayer-tx',
-            relayerExplorerTxLink: 'https://scan.url',
+            swapperTxId: 'relayer-tx',
+            swapperTxLink: 'https://scan.url/tx/relayer-tx',
             message: undefined,
         });
     });

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