@shapeshiftoss/swapper 17.6.3 → 17.6.4

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

@@ -0,0 +1,236 @@
+import type { Hex } from 'viem';
+export type ErrorType = {
+    errno: number;
+    message: string;
+    data?: unknown;
+};
+export type Token = {
+    address: string;
+    name: string;
+    decimals: number;
+    symbol: string;
+    icon: string;
+};
+export type RouteChain = {
+    chainId: string;
+    tokenIn: Token;
+    tokenOut: Token;
+    totalAmountIn: string;
+    totalAmountOut: string;
+    totalAmountOutUSD?: string;
+    route: {
+        amountIn: string;
+        amountOut: string;
+        dexName: string;
+        path: unknown[];
+        extra: string;
+    }[];
+    bridge?: string;
+};
+export type Affiliate = {
+    amount: string;
+    list: unknown[];
+    data: string;
+};
+export type BridgeFee = {
+    amount: string;
+    affiliate: Affiliate;
+    symbol?: string;
+    address?: string;
+    chainId?: number;
+    in?: number;
+    out?: number;
+};
+export type RouteSuccessItem = {
+    diff: string;
+    bridgeFee: BridgeFee;
+    tradeType: number;
+    gasFee: {
+        amount: string;
+        symbol: string;
+        inUSD: string;
+    };
+    swapFee: {
+        nativeFee: string;
+        tokenFee: string;
+    };
+    feeConfig: {
+        feeType: number;
+        referrer: string;
+        rateOrNativeFee: number;
+    };
+    gasEstimated: string;
+    gasEstimatedTarget: string;
+    timeEstimated: number;
+    hash: string;
+    entrance: string;
+    timestamp: number;
+    hasLiquidity: boolean;
+    srcChain: RouteChain;
+    bridgeChain?: RouteChain;
+    dstChain?: RouteChain;
+    totalAmountInUSD?: string;
+    totalAmountOutUSD?: string;
+    contract?: string;
+    minAmountOut?: {
+        amount: string;
+        symbol: string;
+    };
+    bridge?: string;
+};
+export type RouteResponse = {
+    errno: 0;
+    message: string;
+    data: RouteSuccessItem[];
+} | ErrorType;
+export type BuildTxSuccessItem = {
+    to: string;
+    data: string;
+    value: Hex;
+    chainId: string;
+    method?: string;
+    args?: {
+        type: string;
+        value: unknown;
+    }[];
+};
+export type BuildTxResponse = {
+    errno: 0;
+    message: string;
+    data: BuildTxSuccessItem[];
+} | ErrorType;
+export type TxParamArg = {
+    type: string;
+    value: string;
+};
+export type TxParamData = {
+    to: string;
+    data: string;
+    value: Hex;
+    chainId: string;
+    method: string;
+    args: TxParamArg[];
+};
+export type TxParam = {
+    errno: number;
+    message: string;
+    data: TxParamData[];
+};
+export type RouteAndSwapData = {
+    route: RouteSuccessItem;
+    txParam: TxParam;
+};
+export type RouteAndSwapResponse = {
+    errno: 0;
+    message: string;
+    data: RouteAndSwapData[];
+} | ErrorType;
+export type ChainInfo = {
+    id: number;
+    chainId: string;
+    chainName: string;
+    scanUrl: string;
+    chainImg: string;
+    mosContract: string;
+    color: string | null;
+    nativeCoin: string;
+    nativeDecimal: number;
+};
+export type TokenInfo = {
+    id: number;
+    chainId: number | string;
+    address: string;
+    name: string;
+    symbol: string;
+    icon: string | null;
+    decimal: number;
+    isMainCurrency: number;
+    showSymbol?: string;
+};
+export type BridgeInfo = {
+    id?: number;
+    fromChain: ChainInfo;
+    toChain: ChainInfo | null;
+    sourceAddress: string;
+    amount: string;
+    fromToken: TokenInfo;
+    sourceHash: string;
+    toHash: string | null;
+    receiveToken: TokenInfo | null;
+    receiveAmount: string | null;
+    toAddress: string | null;
+    destinationToken?: TokenInfo | null;
+    state: number;
+    timestamp: string;
+    timestampLong: number;
+    completeTime: string | null;
+    completeTimeLong: number;
+    relayerChain?: ChainInfo;
+    relayerHash?: string | null;
+};
+export type DetailedBridgeInfo = {
+    id?: number | null;
+    fromChain: ChainInfo;
+    relayerChain?: ChainInfo;
+    toChain: ChainInfo;
+    tokenAddress?: string;
+    tokenSymbol?: string;
+    sourceAddress: string;
+    amount: string | number;
+    inAmount?: string | number;
+    fee?: string;
+    fromToken: TokenInfo;
+    sourceHash: string;
+    relayerHash?: string | null;
+    toHash: string | null;
+    receiveToken: TokenInfo;
+    receiveAmount: string | number;
+    toAddress: string;
+    destinationToken?: TokenInfo | null;
+    sourceToken?: TokenInfo;
+    feeToken?: TokenInfo;
+    fromTokenDecimal?: number;
+    isMessageBridge?: number;
+    bridgeToken?: unknown | null;
+    bridgeAmount?: unknown | null;
+    chainPoolChainDict?: unknown | null;
+    chainPoolTokenDict?: unknown | null;
+    chainPoolAddress?: unknown | null;
+    chainPoolAmount?: unknown | null;
+    chainPoolAction?: unknown | null;
+    chainPoolHash?: unknown | null;
+    routerAmount?: number;
+    integratorAmount?: number;
+    nativeAmount?: number;
+    integratorNative?: number;
+    routerFeeToken?: string;
+    stage?: unknown | null;
+    status?: unknown | null;
+    state: number;
+    timestamp: string;
+    timestampLong: number;
+    completeTime: string;
+    completeTimeLong: number;
+};
+export type BridgeInfoNullResponse = {
+    code: number;
+    message: string;
+    data: {
+        info: null;
+    };
+};
+export type BridgeInfoResponse = BridgeInfo | BridgeInfo[] | ErrorType | BridgeInfoNullResponse;
+export type BridgeInfoApiResponse = {
+    code: number;
+    message: string;
+    data: {
+        info: BridgeInfo | null;
+    };
+};
+export type DetailedBridgeInfoApiResponse = {
+    code: number;
+    message: string;
+    data: {
+        info: DetailedBridgeInfo | null;
+    };
+};

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

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

package/dist/esm/swappers/ButterSwap/utils/butterSwapHistoryService.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosRequestConfig } from 'axios';
+export declare const butterHistoryService: {
+    get: <T = any>(url: string, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
+};

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

@@ -0,0 +1,13 @@
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const maxAge = 5 * 1000; // 5 seconds
+const cachedUrls = [];
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+    baseURL: 'https://bs-app-api.chainservice.io',
+};
+const butterHistoryServiceBase = createCache(maxAge, cachedUrls, axiosConfig);
+export const butterHistoryService = makeSwapperAxiosServiceMonadic(butterHistoryServiceBase);

package/dist/esm/swappers/ButterSwap/utils/butterSwapService.d.ts

@@ -0,0 +1,6 @@
+import type { AxiosRequestConfig } from 'axios';
+export declare const butterService: {
+    get: <T = any>(url: string, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    post: <T_1 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_1, any, {}>, import("../../../index.js").SwapErrorRight>>;
+    delete: <T_2 = any>(url: string, data: any, config?: AxiosRequestConfig<any> | undefined) => Promise<import("@sniptt/monads").Result<import("axios").AxiosResponse<T_2, any, {}>, import("../../../index.js").SwapErrorRight>>;
+};

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

@@ -0,0 +1,13 @@
+import { createCache, makeSwapperAxiosServiceMonadic } from '../../../utils.js';
+const maxAge = 5 * 1000; // 5 seconds
+const cachedUrls = [];
+const axiosConfig = {
+    timeout: 10000,
+    headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json',
+    },
+    baseURL: 'https://bs-router-v3.chainservice.io',
+};
+const butterServiceBase = createCache(maxAge, cachedUrls, axiosConfig);
+export const butterService = makeSwapperAxiosServiceMonadic(butterServiceBase);

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

@@ -0,0 +1 @@
+export declare const makeButterSwapAffiliate: (affiliateBps: string) => string | undefined;

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

@@ -0,0 +1,6 @@
+const BUTTERSWAP_AFFILIATE = 'shapeshift';
+export const makeButterSwapAffiliate = (affiliateBps) => {
+    if (!BUTTERSWAP_AFFILIATE)
+        return undefined;
+    return `${BUTTERSWAP_AFFILIATE}:${affiliateBps}`;
+};

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

@@ -0,0 +1,3 @@
+import type { ChainId } from '@shapeshiftoss/caip';
+export declare const butterSwapChainIdToChainId: (butterSwapChainId: number) => ChainId | undefined;
+export declare const chainIdToButterSwapChainId: (chainId: ChainId) => number | undefined;

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

@@ -0,0 +1,22 @@
+import { KnownChainIds } from '@shapeshiftoss/types';
+// https://docs.butternetwork.io/butter-swap-integration/butter-api-for-routing/get-supportedchainlist#butter-chain-id-explanation
+const BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID = {
+    1: KnownChainIds.EthereumMainnet,
+    137: KnownChainIds.PolygonMainnet,
+    56: KnownChainIds.BnbSmartChainMainnet,
+    42161: KnownChainIds.ArbitrumMainnet,
+    10: KnownChainIds.OptimismMainnet,
+    8453: KnownChainIds.BaseMainnet,
+    1360108768460801: KnownChainIds.SolanaMainnet,
+    1360095883558913: KnownChainIds.BitcoinMainnet,
+};
+const CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID = Object.entries(BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID).reduce((acc, [butterSwapChainId, chainId]) => {
+    acc[chainId] = Number(butterSwapChainId);
+    return acc;
+}, {});
+export const butterSwapChainIdToChainId = (butterSwapChainId) => {
+    return BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID[butterSwapChainId];
+};
+export const chainIdToButterSwapChainId = (chainId) => {
+    return CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID[chainId];
+};

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

@@ -0,0 +1,50 @@
+import type { Asset } from '@shapeshiftoss/types';
+import type { Result } from '@sniptt/monads';
+import type { SwapErrorRight } from '../../types.js';
+import { TradeQuoteError } from '../../types.js';
+import type { BridgeInfo, BuildTxResponse, RouteResponse } from './types.js';
+export declare enum ButterSwapErrorCode {
+    ParameterError = 2000,
+    ChainNotSupported = 2001,
+    TokenNotSupported = 2002,
+    NoRouteFound = 2003,
+    InsufficientLiquidity = 2004,
+    SlippageOutOfRange = 2005,
+    InsufficientAmount = 2006,
+    InvalidAddress = 2007
+}
+type ButterSwapPromise<T> = Promise<Result<T, SwapErrorRight>>;
+/**
+ * @see https://docs.butternetwork.io/butter-swap-integration/butter-api-for-routing/get-route
+ */
+export type GetButterRouteArgs = {
+    sellAsset: Asset;
+    buyAsset: Asset;
+    sellAmountCryptoBaseUnit: string;
+    slippage: string;
+    affiliate?: string;
+};
+export declare const getButterRoute: ({ sellAsset, buyAsset, sellAmountCryptoBaseUnit, slippage, affiliate, }: GetButterRouteArgs) => ButterSwapPromise<RouteResponse>;
+export type ButterBuildTxArgs = {
+    hash: string;
+    slippage: string;
+    from: string;
+    receiver: string;
+};
+export declare const fetchTxData: ({ hash, slippage, from, receiver, }: ButterBuildTxArgs) => ButterSwapPromise<BuildTxResponse>;
+export declare function isRouteSuccess(response: RouteResponse): response is Extract<RouteResponse, {
+    errno: 0;
+}>;
+export declare function isBuildTxSuccess(response: BuildTxResponse): response is Extract<BuildTxResponse, {
+    errno: 0;
+}>;
+/**
+ * @see https://docs.butternetwork.io/butter-swap-integration/butter-api-for-swap-data/get-swap-history-by-source-hash
+ */
+export declare const getBridgeInfoBySourceHash: (hash: string) => ButterSwapPromise<BridgeInfo | undefined>;
+/**
+ * Maps ButterSwap API error codes to human-readable error types.
+ * @see https://docs.butternetwork.io/butter-swap-integration/butter-api-for-routing/error-code-list
+ */
+export declare function butterSwapErrorToTradeQuoteError(errno: number): TradeQuoteError;
+export {};

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

@@ -0,0 +1,132 @@
+import { fromAssetId, solanaChainId } from '@shapeshiftoss/caip';
+import { chainIdToFeeAssetId } from '@shapeshiftoss/utils';
+import { Err, Ok } from '@sniptt/monads';
+import { zeroAddress } from 'viem';
+import { TradeQuoteError } from '../../types.js';
+import { makeSwapErrorRight } from '../../utils.js';
+import { getTreasuryAddressFromChainId } from '../utils/helpers/helpers.js';
+import { butterHistoryService } from './utils/butterSwapHistoryService.js';
+import { butterService } from './utils/butterSwapService.js';
+import { chainIdToButterSwapChainId } from './utils/helpers.js';
+export var ButterSwapErrorCode;
+(function (ButterSwapErrorCode) {
+    ButterSwapErrorCode[ButterSwapErrorCode["ParameterError"] = 2000] = "ParameterError";
+    ButterSwapErrorCode[ButterSwapErrorCode["ChainNotSupported"] = 2001] = "ChainNotSupported";
+    ButterSwapErrorCode[ButterSwapErrorCode["TokenNotSupported"] = 2002] = "TokenNotSupported";
+    ButterSwapErrorCode[ButterSwapErrorCode["NoRouteFound"] = 2003] = "NoRouteFound";
+    ButterSwapErrorCode[ButterSwapErrorCode["InsufficientLiquidity"] = 2004] = "InsufficientLiquidity";
+    ButterSwapErrorCode[ButterSwapErrorCode["SlippageOutOfRange"] = 2005] = "SlippageOutOfRange";
+    ButterSwapErrorCode[ButterSwapErrorCode["InsufficientAmount"] = 2006] = "InsufficientAmount";
+    ButterSwapErrorCode[ButterSwapErrorCode["InvalidAddress"] = 2007] = "InvalidAddress";
+})(ButterSwapErrorCode || (ButterSwapErrorCode = {}));
+const SOLANA_NATIVE_ADDRESS = 'So11111111111111111111111111111111111111112';
+export const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoBaseUnit, slippage, affiliate, }) => {
+    const butterFromChainId = chainIdToButterSwapChainId(sellAsset.chainId);
+    const butterToChainId = chainIdToButterSwapChainId(buyAsset.chainId);
+    if (!butterFromChainId || !butterToChainId) {
+        return Err(makeSwapErrorRight({
+            message: '[getButterRoute] Unsupported chainId',
+            code: TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const feeAssetId = chainIdToFeeAssetId(sellAsset.chainId);
+    const sellAssetIsNative = sellAsset.assetId === feeAssetId;
+    const buyAssetIsNative = buyAsset.assetId === chainIdToFeeAssetId(buyAsset.chainId);
+    const { assetReference: sellAssetAddressRaw } = fromAssetId(sellAsset.assetId);
+    const { assetReference: buyAssetAddressRaw } = fromAssetId(buyAsset.assetId);
+    const sellAssetAddress = (() => {
+        if (sellAsset.chainId === solanaChainId && sellAssetIsNative)
+            return SOLANA_NATIVE_ADDRESS;
+        if (sellAssetIsNative)
+            return zeroAddress;
+        return sellAssetAddressRaw;
+    })();
+    const buyAssetAddress = (() => {
+        if (buyAsset.chainId === solanaChainId && buyAssetIsNative)
+            return SOLANA_NATIVE_ADDRESS;
+        if (buyAssetIsNative)
+            return zeroAddress;
+        return buyAssetAddressRaw;
+    })();
+    const isSameChainSolanaSwap = sellAsset.chainId === solanaChainId && buyAsset.chainId === solanaChainId;
+    const params = {
+        fromChainId: butterFromChainId,
+        tokenInAddress: sellAssetAddress,
+        toChainId: butterToChainId,
+        tokenOutAddress: buyAssetAddress,
+        amount: sellAmountCryptoBaseUnit,
+        type: 'exactIn',
+        slippage,
+        entrance: 'shapeshift',
+        affiliate,
+        // This is only required to collect affiliate fees for same-chain Solana swaps. For EVM swaps the default referrer address (EVM) of the affiliate code is used.
+        ...(isSameChainSolanaSwap && { referrer: getTreasuryAddressFromChainId(solanaChainId) }),
+    };
+    const result = await butterService.get('/route', { params });
+    if (result.isErr())
+        return Err(result.unwrapErr());
+    const data = result.unwrap().data;
+    return Ok(data);
+};
+export const fetchTxData = async ({ hash, slippage, from, receiver, }) => {
+    const result = await butterService.get('/swap', {
+        params: { hash, slippage, from, receiver },
+    });
+    if (result.isErr())
+        return Err(result.unwrapErr());
+    const data = result.unwrap().data;
+    return Ok(data);
+};
+export function isRouteSuccess(response) {
+    return response.errno === 0;
+}
+export function isBuildTxSuccess(response) {
+    return response.errno === 0;
+}
+/**
+ * @see https://docs.butternetwork.io/butter-swap-integration/butter-api-for-swap-data/get-swap-history-by-source-hash
+ */
+export const getBridgeInfoBySourceHash = async (hash) => {
+    try {
+        const result = await butterHistoryService.get('/api/queryBridgeInfoBySourceHash', {
+            params: { hash },
+        });
+        if (result.isErr()) {
+            throw result.unwrapErr();
+        }
+        const data = result.unwrap().data;
+        if (!data || !data.data || !data.data.info) {
+            return Ok(undefined);
+        }
+        return Ok(data.data.info);
+    }
+    catch (e) {
+        return Ok(undefined);
+    }
+};
+/**
+ * Maps ButterSwap API error codes to human-readable error types.
+ * @see https://docs.butternetwork.io/butter-swap-integration/butter-api-for-routing/error-code-list
+ */
+export function butterSwapErrorToTradeQuoteError(errno) {
+    switch (errno) {
+        case ButterSwapErrorCode.ParameterError:
+            return TradeQuoteError.QueryFailed;
+        case ButterSwapErrorCode.ChainNotSupported:
+            return TradeQuoteError.UnsupportedChain;
+        case ButterSwapErrorCode.TokenNotSupported:
+            return TradeQuoteError.UnsupportedTradePair;
+        case ButterSwapErrorCode.NoRouteFound:
+            return TradeQuoteError.NoRouteFound;
+        case ButterSwapErrorCode.InsufficientLiquidity:
+            return TradeQuoteError.NoRouteFound;
+        case ButterSwapErrorCode.SlippageOutOfRange:
+            return TradeQuoteError.FinalQuoteMaxSlippageExceeded;
+        case ButterSwapErrorCode.InsufficientAmount:
+            return TradeQuoteError.SellAmountBelowMinimum;
+        case ButterSwapErrorCode.InvalidAddress:
+            return TradeQuoteError.QueryFailed;
+        default:
+            return TradeQuoteError.QueryFailed;
+    }
+}

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

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

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

@@ -0,0 +1,8 @@
+import { executeEvmTransaction, executeSolanaTransaction } from '../../utils.js';
+export const chainflipSwapper = {
+    executeEvmTransaction,
+    executeSolanaTransaction,
+    executeUtxoTransaction: (txToSign, { signAndBroadcastTransaction }) => {
+        return signAndBroadcastTransaction(txToSign);
+    },
+};

package/dist/esm/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.js';
+import { ChainflipNetwork } from './types.js';
+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/esm/swappers/ChainflipSwapper/constants.js

@@ -0,0 +1,52 @@
+import { arbitrumAssetId, btcAssetId, ethAssetId, flipAssetId, solAssetId, usdcAssetId, usdcOnArbitrumOneAssetId, usdcOnSolanaAssetId, usdtAssetId, } from '@shapeshiftoss/caip';
+import { KnownChainIds } from '@shapeshiftoss/types';
+import { SwapperName } from '../../types.js';
+import { ChainflipNetwork } from './types.js';
+export const CHAINFLIP_REGULAR_QUOTE = 'regular';
+export const CHAINFLIP_DCA_QUOTE = 'dca';
+export const ChainflipSupportedChainIds = [
+    KnownChainIds.EthereumMainnet,
+    KnownChainIds.ArbitrumMainnet,
+    KnownChainIds.BitcoinMainnet,
+    KnownChainIds.SolanaMainnet,
+];
+export const ChainflipSupportedAssetIdsByChainId = {
+    [KnownChainIds.EthereumMainnet]: [ethAssetId, flipAssetId, usdcAssetId, usdtAssetId],
+    [KnownChainIds.ArbitrumMainnet]: [arbitrumAssetId, usdcOnArbitrumOneAssetId],
+    [KnownChainIds.BitcoinMainnet]: [btcAssetId],
+    [KnownChainIds.SolanaMainnet]: [solAssetId, usdcOnSolanaAssetId],
+};
+export const chainIdToChainflipNetwork = {
+    [KnownChainIds.EthereumMainnet]: ChainflipNetwork.Ethereum,
+    [KnownChainIds.ArbitrumMainnet]: ChainflipNetwork.Arbitrum,
+    [KnownChainIds.BitcoinMainnet]: ChainflipNetwork.Bitcoin,
+    [KnownChainIds.SolanaMainnet]: ChainflipNetwork.Solana,
+};
+export const CHAINFLIP_SWAP_SOURCE = SwapperName.Chainflip;
+export const CHAINFLIP_BOOST_SWAP_SOURCE = `${SwapperName.Chainflip} • Boost`;
+export const CHAINFLIP_DCA_SWAP_SOURCE = `${SwapperName.Chainflip} • DCA`;
+export const CHAINFLIP_DCA_BOOST_SWAP_SOURCE = `${SwapperName.Chainflip} • DCA • Boost`;
+export const usdcAsset = {
+    assetId: 'eip155:1/erc20:0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
+    chainId: 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',
+};
+export 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 || (ChainflipStatusMessage = {}));

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

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