@shapeshiftoss/swapper 17.7.3 → 17.8.0

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

@@ -0,0 +1,140 @@
+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 { getBobGatewayTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getBobGatewayTradeRate } from './swapperApi/getTradeRate.js';
+import { getBobGatewayClient, mapBobGatewayOrderStatusToTxStatus, registerBobGatewayTx, } 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 }) => {
+        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);
+        return adapter.buildCustomApiTx({
+            accountNumber,
+            from,
+            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;
+    },
+    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');
+        if (txHash && !registeredSwapIds.has(swap.id)) {
+            try {
+                await registerBobGatewayTx({
+                    config,
+                    orderId,
+                    txHash,
+                    sellAsset: swap.sellAsset,
+                    buyAsset: swap.buyAsset,
+                });
+                registeredSwapIds.add(swap.id);
+            }
+            catch { }
+        }
+        let orderInfo;
+        try {
+            orderInfo = await getBobGatewayClient(config).getOrder(orderId);
+        }
+        catch (err) {
+            if (isGatewayError(err)) {
+                if (err.code === 'ORDER_NOT_FOUND') {
+                    return {
+                        buyTxHash: undefined,
+                        status: TxStatus.Unknown,
+                        message: 'Waiting for deposit...',
+                    };
+                }
+            }
+            throw err;
+        }
+        const status = mapBobGatewayOrderStatusToTxStatus(orderInfo.status);
+        const buyTxHash = 'success' in orderInfo.status ? orderInfo.status.success.receivedTokens[0]?.txHash : undefined;
+        const refundTxHash = 'refunded' in orderInfo.status
+            ? orderInfo.status.refunded.refundedTokens[0]?.txHash
+            : undefined;
+        return {
+            status,
+            buyTxHash,
+            message: refundTxHash ? 'Trade refunded' : undefined,
+        };
+    },
+};

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

@@ -0,0 +1,3 @@
+export { bobGatewayApi } from './endpoints.js';
+export { bobGatewaySwapper } from './BobGatewaySwapper.js';
+export * from './utils/constants.js';

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

@@ -0,0 +1,3 @@
+export { bobGatewayApi } from './endpoints.js';
+export { bobGatewaySwapper } from './BobGatewaySwapper.js';
+export * from './utils/constants.js';

package/dist/esm/swappers/BobGatewaySwapper/swapperApi/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 getBobGatewayTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote, SwapErrorRight>>;

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

@@ -0,0 +1,86 @@
+import { isEvmChainId } from '@shapeshiftoss/chain-adapters';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { assertValidTrade, createBobGatewayOrderMetadata, getBobGatewayAllowanceContract, getBobGatewayQuote, getBobGatewayQuoteFeeData, parseBobGatewayQuote, } from '../utils/helpers.js';
+export const getBobGatewayTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, sendAddress, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { config } = deps;
+    if (!sendAddress) {
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] sendAddress is required for quote',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    if (!receiveAddress) {
+        return Err(makeSwapErrorRight({
+            message: '[BobGateway] receiveAddress is required for quote',
+            code: TradeQuoteError.UnknownError,
+        }));
+    }
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellChainName, buyChainName } = assertion.unwrap();
+    // omit the sender for utxo sells so order creation does not enforce a per-address confirmed
+    // funds check (deposits are matched via op_return, not the sending address)
+    const sender = isEvmChainId(sellAsset.chainId) ? sendAddress : undefined;
+    const maybeQuote = await getBobGatewayQuote({
+        config,
+        sellAsset,
+        buyAsset,
+        sellChainName,
+        buyChainName,
+        sender,
+        recipient: receiveAddress,
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    if (maybeQuote.isErr())
+        return Err(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const maybeOrderMetadata = await createBobGatewayOrderMetadata(config, quote);
+    if (maybeOrderMetadata.isErr())
+        return Err(maybeOrderMetadata.unwrapErr());
+    const orderMetadata = maybeOrderMetadata.unwrap();
+    const maybeFeeData = await getBobGatewayQuoteFeeData(input, deps, orderMetadata);
+    if (maybeFeeData.isErr())
+        return Err(maybeFeeData.unwrapErr());
+    const feeData = maybeFeeData.unwrap();
+    const { buyAmountBeforeFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, protocolFees, estimatedExecutionTimeMs, } = parseBobGatewayQuote(quote, buyAsset, deps.assetsById);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = getBobGatewayAllowanceContract(quote, sellAsset);
+    const tradeQuote = {
+        id: uuid(),
+        quoteOrRate: 'quote',
+        rate,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        swapperName: SwapperName.BobGateway,
+        steps: [
+            {
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                feeData: { ...feeData, protocolFees },
+                rate,
+                source: SwapperName.BobGateway,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                allowanceContract,
+                estimatedExecutionTimeMs,
+                bobSpecific: orderMetadata,
+            },
+        ],
+    };
+    return Ok(tradeQuote);
+};

package/dist/esm/swappers/BobGatewaySwapper/swapperApi/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 getBobGatewayTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate, SwapErrorRight>>;

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

@@ -0,0 +1,69 @@
+import { btcChainId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { SwapperName } from '../../../types.js';
+import { getInputOutputRate } from '../../../utils.js';
+import { DUMMY_BTC_ADDRESS, DUMMY_EVM_ADDRESS } from '../utils/constants.js';
+import { assertValidTrade, getBobGatewayAllowanceContract, getBobGatewayQuote, getBobGatewayRateNetworkFeeCryptoBaseUnit, parseBobGatewayQuote, } from '../utils/helpers.js';
+export const getBobGatewayTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit, receiveAddress, accountNumber, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { config } = deps;
+    const assertion = assertValidTrade({ sellAsset, buyAsset });
+    if (assertion.isErr())
+        return Err(assertion.unwrapErr());
+    const { sellChainName, buyChainName } = assertion.unwrap();
+    const recipient = receiveAddress ?? (buyAsset.chainId === btcChainId ? DUMMY_BTC_ADDRESS : DUMMY_EVM_ADDRESS);
+    const sender = sellAsset.chainId === btcChainId ? undefined : DUMMY_EVM_ADDRESS;
+    const maybeQuote = await getBobGatewayQuote({
+        config,
+        sellAsset,
+        buyAsset,
+        sellChainName,
+        buyChainName,
+        sender,
+        recipient,
+        amount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+    });
+    if (maybeQuote.isErr())
+        return Err(maybeQuote.unwrapErr());
+    const quote = maybeQuote.unwrap();
+    const { buyAmountBeforeFeesCryptoBaseUnit, buyAmountAfterFeesCryptoBaseUnit, protocolFees, estimatedExecutionTimeMs, } = parseBobGatewayQuote(quote, buyAsset, deps.assetsById);
+    const rate = getInputOutputRate({
+        sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+        buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+        sellAsset,
+        buyAsset,
+    });
+    const allowanceContract = getBobGatewayAllowanceContract(quote, sellAsset);
+    const networkFeeCryptoBaseUnit = await getBobGatewayRateNetworkFeeCryptoBaseUnit(quote, sellAsset, deps);
+    const tradeRate = {
+        id: uuid(),
+        quoteOrRate: 'rate',
+        rate,
+        receiveAddress,
+        affiliateBps,
+        slippageTolerancePercentageDecimal,
+        swapperName: SwapperName.BobGateway,
+        steps: [
+            {
+                buyAmountBeforeFeesCryptoBaseUnit,
+                buyAmountAfterFeesCryptoBaseUnit,
+                sellAmountIncludingProtocolFeesCryptoBaseUnit,
+                feeData: {
+                    networkFeeCryptoBaseUnit,
+                    protocolFees,
+                },
+                rate,
+                source: SwapperName.BobGateway,
+                buyAsset,
+                sellAsset,
+                accountNumber,
+                allowanceContract,
+                estimatedExecutionTimeMs,
+            },
+        ],
+    };
+    return Ok(tradeRate);
+};

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

@@ -0,0 +1,20 @@
+type BobGatewayEvmTxMetadata = {
+    to: string;
+    data: string;
+    value: string;
+    chain: string;
+};
+type BobGatewayUtxoTxMetadata = {
+    depositAddress: string;
+    opReturnData?: string;
+};
+export type BobGatewayMetadata = {
+    orderId: string;
+} & ({
+    evmTx: BobGatewayEvmTxMetadata;
+    utxoTx?: never;
+} | {
+    utxoTx: BobGatewayUtxoTxMetadata;
+    evmTx?: never;
+});
+export {};

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

@@ -0,0 +1,13 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const BOB_GATEWAY_BASE_URL = "https://gateway-api-mainnet.gobob.xyz";
+export declare const chainIdToBobGatewayChainName: {
+    readonly [x: string]: "arbitrum" | "avalanche" | "base" | "bera" | "bitcoin" | "bob" | "bsc" | "ethereum" | "sei" | "sonic" | "unichain";
+};
+export declare const bobGatewayChainNameToChainId: Record<BobGatewayChainName, ChainId>;
+export type BobGatewayChainName = (typeof chainIdToBobGatewayChainName)[keyof typeof chainIdToBobGatewayChainName];
+export declare const DUMMY_EVM_ADDRESS: `0x${string}`;
+export declare const DUMMY_BTC_ADDRESS = "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq";
+export declare const BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT = "350000";
+export declare const BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT = "550000";
+export declare const BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE = "200";
+export declare const decimalSlippageToBobBps: (slippageDecimal: string) => string;

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

@@ -0,0 +1,27 @@
+import { arbitrumChainId, avalancheChainId, baseChainId, berachainChainId, bobChainId, bscChainId, btcChainId, ethChainId, seiChainId, sonicChainId, unichainChainId, } from '@shapeshiftoss/caip';
+export const BOB_GATEWAY_BASE_URL = 'https://gateway-api-mainnet.gobob.xyz';
+// Chain name strings expected by the BOB Gateway API
+// https://gateway-api-mainnet.gobob.xyz/v2/get-routes
+export const chainIdToBobGatewayChainName = {
+    [arbitrumChainId]: 'arbitrum',
+    [avalancheChainId]: 'avalanche',
+    [baseChainId]: 'base',
+    [berachainChainId]: 'bera',
+    [btcChainId]: 'bitcoin',
+    [bobChainId]: 'bob',
+    [bscChainId]: 'bsc',
+    [ethChainId]: 'ethereum',
+    [seiChainId]: 'sei',
+    [sonicChainId]: 'sonic',
+    [unichainChainId]: 'unichain',
+};
+export const bobGatewayChainNameToChainId = Object.fromEntries(Object.entries(chainIdToBobGatewayChainName).map(([chainId, chainName]) => [chainName, chainId]));
+export const DUMMY_EVM_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045';
+export const DUMMY_BTC_ADDRESS = 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq';
+export const BOB_GATEWAY_TOKENSWAP_DEFAULT_GAS_LIMIT = '350000'; // EVM→EVM
+export const BOB_GATEWAY_OFFRAMP_DEFAULT_GAS_LIMIT = '550000'; // EVM→BTC
+export const BOB_GATEWAY_ONRAMP_DEFAULT_TX_VSIZE = '200'; // BTC→EVM
+// https://docs.gobob.xyz/api-reference/v2/get-a-gateway-quote#parameter-slippage
+export const decimalSlippageToBobBps = (slippageDecimal) => {
+    return String(Math.round(parseFloat(slippageDecimal) * 10_000));
+};

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

@@ -0,0 +1,49 @@
+import type { GatewayOrderStatusV2, GatewayQuoteV2, GetQuoteParams } from '@gobob/bob-sdk';
+import { GatewaySDK } from '@gobob/bob-sdk';
+import type { AssetId } from '@shapeshiftoss/caip';
+import type { Asset, AssetsByIdPartial } from '@shapeshiftoss/types';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import type { Result } from '@sniptt/monads';
+import type { GetTradeQuoteInput, QuoteFeeData, SwapErrorRight, SwapperConfig, SwapperDeps } from '../../../types.js';
+import type { BobGatewayMetadata } from '../types.js';
+import type { BobGatewayChainName } from './constants.js';
+export declare const getBobGatewayClient: (config: SwapperConfig) => GatewaySDK;
+export declare const assetIdToBobGatewayToken: (assetId: string) => string;
+export declare const getBobGatewayAffiliates: (affiliateBps: string) => GetQuoteParams['affiliates'];
+export declare const getBobGatewayQuote: ({ config, sellAsset, buyAsset, sellChainName, buyChainName, sender, recipient, amount, affiliateBps, slippageTolerancePercentageDecimal, }: {
+    config: SwapperConfig;
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sellChainName: BobGatewayChainName;
+    buyChainName: BobGatewayChainName;
+    sender: string | undefined;
+    recipient: string;
+    amount: string;
+    affiliateBps: string;
+    slippageTolerancePercentageDecimal: string | undefined;
+}) => Promise<Result<GatewayQuoteV2, SwapErrorRight>>;
+export declare const createBobGatewayOrderMetadata: (config: SwapperConfig, gatewayQuote: GatewayQuoteV2) => Promise<Result<BobGatewayMetadata, SwapErrorRight>>;
+export declare const registerBobGatewayTx: ({ config, orderId, txHash, sellAsset, buyAsset, }: {
+    config: SwapperConfig;
+    orderId: string;
+    txHash: string;
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Promise<void>;
+export declare const getBobGatewayQuoteFeeData: (input: GetTradeQuoteInput, { assertGetUtxoChainAdapter, assertGetEvmChainAdapter }: SwapperDeps, orderMetadata: BobGatewayMetadata) => Promise<Result<Omit<QuoteFeeData, 'protocolFees'>, SwapErrorRight>>;
+export declare const getBobGatewayRateNetworkFeeCryptoBaseUnit: (quote: GatewayQuoteV2, sellAsset: Asset, { assertGetEvmChainAdapter, assertGetUtxoChainAdapter }: SwapperDeps) => Promise<string | undefined>;
+export declare const mapBobGatewayOrderStatusToTxStatus: (status: GatewayOrderStatusV2) => TxStatus;
+export declare const parseBobGatewayQuote: (quote: GatewayQuoteV2, buyAsset: Asset, assetsById: AssetsByIdPartial) => {
+    buyAmountBeforeFeesCryptoBaseUnit: string;
+    buyAmountAfterFeesCryptoBaseUnit: string;
+    protocolFees: Partial<Record<AssetId, import("../../../types.js").ProtocolFee>>;
+    estimatedExecutionTimeMs: number | undefined;
+};
+export declare const getBobGatewayAllowanceContract: (quote: GatewayQuoteV2, sellAsset: Asset) => string;
+export declare const assertValidTrade: ({ sellAsset, buyAsset, }: {
+    sellAsset: Asset;
+    buyAsset: Asset;
+}) => Result<{
+    sellChainName: BobGatewayChainName;
+    buyChainName: BobGatewayChainName;
+}, SwapErrorRight>;