@shapeshiftoss/swapper 17.6.6 → 17.6.7

package/dist/cjs/swappers/CetusSwapper/swapperApi/getTradeQuote.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeQuote = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const constants_1 = require("../utils/constants");
+const helpers_1 = require("../utils/helpers");
+const getTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { assetsById } = deps;
+    if (accountNumber === undefined) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `accountNumber is required`,
+            code: types_1.TradeQuoteError.InternalError,
+        }));
+    }
+    if (!(0, constants_1.isSupportedChainId)(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, constants_1.isSupportedChainId)(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const suiAsset = assetsById[caip_1.suiAssetId];
+    if (!suiAsset) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `suiAsset is required`,
+            code: types_1.TradeQuoteError.InternalError,
+        }));
+    }
+    try {
+        const sdk = await (0, helpers_1.getCetusSDK)();
+        const sellCoinType = (0, helpers_1.getCoinType)(sellAsset);
+        const buyCoinType = (0, helpers_1.getCoinType)(buyAsset);
+        const pool = await (0, helpers_1.findBestPool)(sdk, sellCoinType, buyCoinType);
+        if (!pool) {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `No liquidity pool found for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const swapResult = await (0, helpers_1.calculateSwapAmounts)(sdk, pool, sellAsset, buyAsset, sellAmount);
+        if (!swapResult) {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `Failed to calculate swap for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: types_1.TradeQuoteError.QueryFailed,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = swapResult.estimatedAmountOut;
+        const rate = (0, utils_1.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: sellAmount,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const adapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+        const dummyAddress = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        const addressForFeeEstimate = receiveAddress ?? dummyAddress;
+        const getFeeDataInput = {
+            to: addressForFeeEstimate,
+            value: sellAmount,
+            chainSpecific: {
+                from: addressForFeeEstimate,
+                tokenId: (0, helpers_1.getCoinType)(sellAsset),
+            },
+        };
+        const feeData = await adapter.getFeeData(getFeeDataInput);
+        const protocolFees = {};
+        const quotes = [];
+        const tradeQuote = {
+            id: (0, uuid_1.v4)(),
+            quoteOrRate: 'quote',
+            rate,
+            affiliateBps,
+            receiveAddress,
+            slippageTolerancePercentageDecimal,
+            swapperName: types_1.SwapperName.Cetus,
+            steps: [
+                {
+                    accountNumber,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: feeData.fast.txFee,
+                        chainSpecific: {
+                            gasBudget: feeData.fast.chainSpecific.gasBudget,
+                            gasPrice: feeData.fast.chainSpecific.gasPrice,
+                        },
+                    },
+                    rate,
+                    source: types_1.SwapperName.Cetus,
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: undefined,
+                },
+            ],
+        };
+        quotes.push(tradeQuote);
+        return (0, monads_1.Ok)(quotes);
+    }
+    catch (error) {
+        console.error(error);
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus quote',
+            code: types_1.TradeQuoteError.QueryFailed,
+        }));
+    }
+};
+exports.getTradeQuote = getTradeQuote;

package/dist/cjs/swappers/CetusSwapper/swapperApi/getTradeRate.d.ts

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

package/dist/cjs/swappers/CetusSwapper/swapperApi/getTradeRate.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTradeRate = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const monads_1 = require("@sniptt/monads");
+const uuid_1 = require("uuid");
+const types_1 = require("../../../types");
+const utils_1 = require("../../../utils");
+const constants_1 = require("../utils/constants");
+const helpers_1 = require("../utils/helpers");
+const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const { assetsById } = deps;
+    if (!(0, constants_1.isSupportedChainId)(sellAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!(0, constants_1.isSupportedChainId)(buyAsset.chainId)) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `unsupported chainId`,
+            code: types_1.TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const suiAsset = assetsById[caip_1.suiAssetId];
+    if (!suiAsset) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: `suiAsset is required`,
+            code: types_1.TradeQuoteError.UnknownError,
+        }));
+    }
+    try {
+        const sdk = await (0, helpers_1.getCetusSDK)();
+        const sellCoinType = (0, helpers_1.getCoinType)(sellAsset);
+        const buyCoinType = (0, helpers_1.getCoinType)(buyAsset);
+        const pool = await (0, helpers_1.findBestPool)(sdk, sellCoinType, buyCoinType);
+        if (!pool) {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `No liquidity pool found for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: types_1.TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const swapResult = await (0, helpers_1.calculateSwapAmounts)(sdk, pool, sellAsset, buyAsset, sellAmount);
+        if (!swapResult) {
+            return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+                message: `Failed to calculate swap for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: types_1.TradeQuoteError.QueryFailed,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = swapResult.estimatedAmountOut;
+        const rate = (0, utils_1.getInputOutputRate)({
+            sellAmountCryptoBaseUnit: sellAmount,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const adapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+        const dummyAddress = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        const addressForFeeEstimate = receiveAddress ?? dummyAddress;
+        const { fast: feeDataFast } = await adapter.getFeeData({
+            to: addressForFeeEstimate,
+            value: sellAmount,
+            chainSpecific: {
+                from: addressForFeeEstimate,
+                tokenId: (0, helpers_1.getCoinType)(sellAsset),
+            },
+        });
+        const protocolFees = {};
+        const rates = [];
+        const tradeRate = {
+            id: (0, uuid_1.v4)(),
+            quoteOrRate: 'rate',
+            rate,
+            affiliateBps,
+            receiveAddress,
+            slippageTolerancePercentageDecimal,
+            swapperName: types_1.SwapperName.Cetus,
+            steps: [
+                {
+                    accountNumber: undefined,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: feeDataFast.txFee,
+                    },
+                    rate,
+                    source: types_1.SwapperName.Cetus,
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: undefined,
+                },
+            ],
+        };
+        rates.push(tradeRate);
+        return (0, monads_1.Ok)(rates);
+    }
+    catch (error) {
+        return (0, monads_1.Err)((0, utils_1.makeSwapErrorRight)({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus rate',
+            code: types_1.TradeQuoteError.QueryFailed,
+        }));
+    }
+};
+exports.getTradeRate = getTradeRate;

package/dist/cjs/swappers/CetusSwapper/utils/constants.d.ts

@@ -0,0 +1,3 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const SUPPORTED_CETUS_CHAIN_IDS: readonly ChainId[];
+export declare const isSupportedChainId: (chainId: ChainId) => chainId is ChainId;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupportedChainId = exports.SUPPORTED_CETUS_CHAIN_IDS = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+exports.SUPPORTED_CETUS_CHAIN_IDS = [caip_1.suiChainId];
+const isSupportedChainId = (chainId) => {
+    return exports.SUPPORTED_CETUS_CHAIN_IDS.includes(chainId);
+};
+exports.isSupportedChainId = isSupportedChainId;

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

@@ -0,0 +1,13 @@
+import type { CetusClmmSDK, Pool } from '@cetusprotocol/cetus-sui-clmm-sdk';
+import type { Asset } from '@shapeshiftoss/types';
+export declare const getCetusSDK: () => Promise<CetusClmmSDK>;
+export declare const getCoinType: (asset: Asset) => string;
+export declare const determineSwapDirection: (pool: Pool, sellCoinType: string, buyCoinType: string) => boolean;
+export declare const calculateAmountLimit: (estimatedAmount: string, slippageTolerancePercentageDecimal: string | undefined, isBuyAmount: boolean) => string;
+export declare const findBestPool: (sdk: CetusClmmSDK, sellCoinType: string, buyCoinType: string) => Promise<Pool | undefined>;
+export type CalculateSwapResult = {
+    estimatedAmountOut: string;
+    estimatedAmountIn: string;
+    estimatedFeeAmount: string;
+};
+export declare const calculateSwapAmounts: (sdk: CetusClmmSDK, pool: Pool, sellAsset: Asset, buyAsset: Asset, sellAmount: string) => Promise<CalculateSwapResult | undefined>;

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

@@ -0,0 +1,118 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateSwapAmounts = exports.findBestPool = exports.calculateAmountLimit = exports.determineSwapDirection = exports.getCoinType = exports.getCetusSDK = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+let sdkInstance;
+const getCetusSDK = async () => {
+    if (!sdkInstance) {
+        const { initMainnetSDK } = await Promise.resolve().then(() => __importStar(require('@cetusprotocol/cetus-sui-clmm-sdk')));
+        sdkInstance = initMainnetSDK();
+    }
+    return sdkInstance;
+};
+exports.getCetusSDK = getCetusSDK;
+const getCoinType = (asset) => {
+    const { assetReference, assetNamespace } = (0, caip_1.fromAssetId)(asset.assetId);
+    // For native SUI token, the assetReference is 'slip44:784' but Cetus expects '0x2::sui::SUI'
+    if (assetNamespace === 'slip44') {
+        return '0x2::sui::SUI';
+    }
+    // For other tokens, the assetReference should be the full coin type
+    return assetReference;
+};
+exports.getCoinType = getCoinType;
+const determineSwapDirection = (pool, sellCoinType, buyCoinType) => {
+    if (pool.coinTypeA === sellCoinType && pool.coinTypeB === buyCoinType) {
+        return true;
+    }
+    if (pool.coinTypeA === buyCoinType && pool.coinTypeB === sellCoinType) {
+        return false;
+    }
+    throw new Error('Pool does not match the swap pair');
+};
+exports.determineSwapDirection = determineSwapDirection;
+const calculateAmountLimit = (estimatedAmount, slippageTolerancePercentageDecimal, isBuyAmount) => {
+    if (!slippageTolerancePercentageDecimal) {
+        return estimatedAmount;
+    }
+    const slippageFactor = (0, utils_1.bn)(1).minus(slippageTolerancePercentageDecimal);
+    if (isBuyAmount) {
+        return (0, utils_1.bnOrZero)(estimatedAmount).times(slippageFactor).toFixed(0);
+    }
+    const maxSlippageFactor = (0, utils_1.bn)(1).plus(slippageTolerancePercentageDecimal);
+    return (0, utils_1.bnOrZero)(estimatedAmount).times(maxSlippageFactor).toFixed(0);
+};
+exports.calculateAmountLimit = calculateAmountLimit;
+const findBestPool = async (sdk, sellCoinType, buyCoinType) => {
+    const pools = await sdk.Pool.getPoolByCoins([sellCoinType, buyCoinType]);
+    if (!pools || pools.length === 0) {
+        return undefined;
+    }
+    const poolWithLiquidity = pools.find(pool => {
+        const hasLiquidity = pool.liquidity && (0, utils_1.bnOrZero)(pool.liquidity).gt(0);
+        return hasLiquidity;
+    });
+    if (!poolWithLiquidity) {
+        console.warn('[Cetus] No pools with liquidity found for', sellCoinType, buyCoinType, {
+            totalPools: pools.length,
+            pools: pools.map(p => ({ id: p.poolAddress, liquidity: p.liquidity })),
+        });
+    }
+    return poolWithLiquidity;
+};
+exports.findBestPool = findBestPool;
+const calculateSwapAmounts = async (sdk, pool, sellAsset, buyAsset, sellAmount) => {
+    const sellCoinType = (0, exports.getCoinType)(sellAsset);
+    const buyCoinType = (0, exports.getCoinType)(buyAsset);
+    const a2b = (0, exports.determineSwapDirection)(pool, sellCoinType, buyCoinType);
+    const decimalsA = pool.coinTypeA === sellCoinType ? sellAsset.precision : buyAsset.precision;
+    const decimalsB = pool.coinTypeA === sellCoinType ? buyAsset.precision : sellAsset.precision;
+    const preSwapParams = {
+        pool,
+        currentSqrtPrice: pool.current_sqrt_price,
+        coinTypeA: pool.coinTypeA,
+        coinTypeB: pool.coinTypeB,
+        decimalsA,
+        decimalsB,
+        a2b,
+        byAmountIn: true,
+        amount: sellAmount,
+    };
+    const preSwapResult = await sdk.Swap.preswap(preSwapParams);
+    if (!preSwapResult) {
+        return undefined;
+    }
+    if (preSwapResult.estimatedAmountOut === '0' || preSwapResult.estimatedAmountOut === '') {
+        return undefined;
+    }
+    return {
+        estimatedAmountOut: preSwapResult.estimatedAmountOut,
+        estimatedAmountIn: preSwapResult.estimatedAmountIn,
+        estimatedFeeAmount: preSwapResult.estimatedFeeAmount,
+    };
+};
+exports.calculateSwapAmounts = calculateSwapAmounts;

package/dist/cjs/swappers/ChainflipSwapper/ChainflipSwapper.d.ts

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

package/dist/cjs/swappers/ChainflipSwapper/ChainflipSwapper.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainflipSwapper = void 0;
+const utils_1 = require("../../utils");
+exports.chainflipSwapper = {
+    executeEvmTransaction: utils_1.executeEvmTransaction,
+    executeSolanaTransaction: utils_1.executeSolanaTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/cjs/swappers/ChainflipSwapper/constants.d.ts

@@ -0,0 +1,26 @@
+import type { AssetId, ChainId } from '@shapeshiftoss/caip';
+import type { Asset } from '@shapeshiftoss/types';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import type { SwapSource } from '../../types';
+import { ChainflipNetwork } from './types';
+export declare const CHAINFLIP_REGULAR_QUOTE: "regular";
+export declare const CHAINFLIP_DCA_QUOTE: "dca";
+export declare const ChainflipSupportedChainIds: readonly [KnownChainIds.EthereumMainnet, KnownChainIds.ArbitrumMainnet, KnownChainIds.BitcoinMainnet, KnownChainIds.SolanaMainnet];
+export type ChainflipSupportedChainId = (typeof ChainflipSupportedChainIds)[number];
+export declare const ChainflipSupportedAssetIdsByChainId: Partial<Record<KnownChainIds, AssetId[]>>;
+export declare const chainIdToChainflipNetwork: Partial<Record<ChainId, ChainflipNetwork>>;
+export declare const CHAINFLIP_SWAP_SOURCE: SwapSource;
+export declare const CHAINFLIP_BOOST_SWAP_SOURCE: SwapSource;
+export declare const CHAINFLIP_DCA_SWAP_SOURCE: SwapSource;
+export declare const CHAINFLIP_DCA_BOOST_SWAP_SOURCE: SwapSource;
+export declare const usdcAsset: Asset;
+export declare enum ChainflipStatusMessage {
+    WaitingForDeposit = "Waiting for deposit...",
+    DepositDetected = "Deposit detected, waiting for confirmation...",
+    ProcessingSwap = "Processing swap...",
+    OutboundTransactionInitiated = "Outbound transaction initiated...",
+    PreparingOutboundTransaction = "Preparing outbound transaction...",
+    TransactionSent = "Transaction sent, waiting for confirmation...",
+    SwapComplete = "Swap complete",
+    SwapFailed = "Swap failed"
+}

package/dist/cjs/swappers/ChainflipSwapper/constants.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChainflipStatusMessage = exports.usdcAsset = exports.CHAINFLIP_DCA_BOOST_SWAP_SOURCE = exports.CHAINFLIP_DCA_SWAP_SOURCE = exports.CHAINFLIP_BOOST_SWAP_SOURCE = exports.CHAINFLIP_SWAP_SOURCE = exports.chainIdToChainflipNetwork = exports.ChainflipSupportedAssetIdsByChainId = exports.ChainflipSupportedChainIds = exports.CHAINFLIP_DCA_QUOTE = exports.CHAINFLIP_REGULAR_QUOTE = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const types_1 = require("@shapeshiftoss/types");
+const types_2 = require("../../types");
+const types_3 = require("./types");
+exports.CHAINFLIP_REGULAR_QUOTE = 'regular';
+exports.CHAINFLIP_DCA_QUOTE = 'dca';
+exports.ChainflipSupportedChainIds = [
+    types_1.KnownChainIds.EthereumMainnet,
+    types_1.KnownChainIds.ArbitrumMainnet,
+    types_1.KnownChainIds.BitcoinMainnet,
+    types_1.KnownChainIds.SolanaMainnet,
+];
+exports.ChainflipSupportedAssetIdsByChainId = {
+    [types_1.KnownChainIds.EthereumMainnet]: [caip_1.ethAssetId, caip_1.flipAssetId, caip_1.usdcAssetId, caip_1.usdtAssetId],
+    [types_1.KnownChainIds.ArbitrumMainnet]: [caip_1.arbitrumAssetId, caip_1.usdcOnArbitrumOneAssetId],
+    [types_1.KnownChainIds.BitcoinMainnet]: [caip_1.btcAssetId],
+    [types_1.KnownChainIds.SolanaMainnet]: [caip_1.solAssetId, caip_1.usdcOnSolanaAssetId],
+};
+exports.chainIdToChainflipNetwork = {
+    [types_1.KnownChainIds.EthereumMainnet]: types_3.ChainflipNetwork.Ethereum,
+    [types_1.KnownChainIds.ArbitrumMainnet]: types_3.ChainflipNetwork.Arbitrum,
+    [types_1.KnownChainIds.BitcoinMainnet]: types_3.ChainflipNetwork.Bitcoin,
+    [types_1.KnownChainIds.SolanaMainnet]: types_3.ChainflipNetwork.Solana,
+};
+exports.CHAINFLIP_SWAP_SOURCE = types_2.SwapperName.Chainflip;
+exports.CHAINFLIP_BOOST_SWAP_SOURCE = `${types_2.SwapperName.Chainflip} • Boost`;
+exports.CHAINFLIP_DCA_SWAP_SOURCE = `${types_2.SwapperName.Chainflip} • DCA`;
+exports.CHAINFLIP_DCA_BOOST_SWAP_SOURCE = `${types_2.SwapperName.Chainflip} • DCA • Boost`;
+exports.usdcAsset = {
+    assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    chainId: types_1.KnownChainIds.EthereumMainnet,
+    color: '#2373CB',
+    explorer: 'https://etherscan.io',
+    explorerAddressLink: 'https://etherscan.io/address/',
+    explorerTxLink: 'https://etherscan.io/tx/',
+    icon: 'https://rawcdn.githack.com/trustwallet/assets/master/blockchains/ethereum/assets/0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48/logo.png',
+    name: 'USDC',
+    precision: 6,
+    relatedAssetKey: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    symbol: 'USDC',
+};
+var ChainflipStatusMessage;
+(function (ChainflipStatusMessage) {
+    ChainflipStatusMessage["WaitingForDeposit"] = "Waiting for deposit...";
+    ChainflipStatusMessage["DepositDetected"] = "Deposit detected, waiting for confirmation...";
+    ChainflipStatusMessage["ProcessingSwap"] = "Processing swap...";
+    ChainflipStatusMessage["OutboundTransactionInitiated"] = "Outbound transaction initiated...";
+    ChainflipStatusMessage["PreparingOutboundTransaction"] = "Preparing outbound transaction...";
+    ChainflipStatusMessage["TransactionSent"] = "Transaction sent, waiting for confirmation...";
+    ChainflipStatusMessage["SwapComplete"] = "Swap complete";
+    ChainflipStatusMessage["SwapFailed"] = "Swap failed";
+})(ChainflipStatusMessage || (exports.ChainflipStatusMessage = ChainflipStatusMessage = {}));

package/dist/cjs/swappers/ChainflipSwapper/endpoints.d.ts

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