@shapeshiftoss/swapper 17.6.2 → 17.6.4

package/dist/cjs/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/cjs/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("../../..").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("../../..").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("../../..").SwapErrorRight>>;
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.butterHistoryService = void 0;
+const utils_1 = require("../../../utils");
+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 = (0, utils_1.createCache)(maxAge, cachedUrls, axiosConfig);
+exports.butterHistoryService = (0, utils_1.makeSwapperAxiosServiceMonadic)(butterHistoryServiceBase);

package/dist/cjs/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("../../..").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("../../..").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("../../..").SwapErrorRight>>;
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.butterService = void 0;
+const utils_1 = require("../../../utils");
+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 = (0, utils_1.createCache)(maxAge, cachedUrls, axiosConfig);
+exports.butterService = (0, utils_1.makeSwapperAxiosServiceMonadic)(butterServiceBase);

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeButterSwapAffiliate = void 0;
+const BUTTERSWAP_AFFILIATE = 'shapeshift';
+const makeButterSwapAffiliate = (affiliateBps) => {
+    if (!BUTTERSWAP_AFFILIATE)
+        return undefined;
+    return `${BUTTERSWAP_AFFILIATE}:${affiliateBps}`;
+};
+exports.makeButterSwapAffiliate = makeButterSwapAffiliate;

package/dist/cjs/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/cjs/swappers/ButterSwap/utils/helpers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chainIdToButterSwapChainId = exports.butterSwapChainIdToChainId = void 0;
+const types_1 = require("@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: types_1.KnownChainIds.EthereumMainnet,
+    137: types_1.KnownChainIds.PolygonMainnet,
+    56: types_1.KnownChainIds.BnbSmartChainMainnet,
+    42161: types_1.KnownChainIds.ArbitrumMainnet,
+    10: types_1.KnownChainIds.OptimismMainnet,
+    8453: types_1.KnownChainIds.BaseMainnet,
+    1360108768460801: types_1.KnownChainIds.SolanaMainnet,
+    1360095883558913: types_1.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;
+}, {});
+const butterSwapChainIdToChainId = (butterSwapChainId) => {
+    return BUTTERSWAP_CHAIN_ID_TO_CHAIN_ID[butterSwapChainId];
+};
+exports.butterSwapChainIdToChainId = butterSwapChainIdToChainId;
+const chainIdToButterSwapChainId = (chainId) => {
+    return CHAIN_ID_TO_BUTTERSWAP_CHAIN_ID[chainId];
+};
+exports.chainIdToButterSwapChainId = chainIdToButterSwapChainId;

package/dist/cjs/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';
+import { TradeQuoteError } from '../../types';
+import type { BridgeInfo, BuildTxResponse, RouteResponse } from './types';
+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/cjs/swappers/ButterSwap/xhr.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.butterSwapErrorToTradeQuoteError = exports.getBridgeInfoBySourceHash = exports.isBuildTxSuccess = exports.isRouteSuccess = exports.fetchTxData = exports.getButterRoute = exports.ButterSwapErrorCode = void 0;
+const caip_1 = require("@shapeshiftoss/caip");
+const utils_1 = require("@shapeshiftoss/utils");
+const monads_1 = require("@sniptt/monads");
+const viem_1 = require("viem");
+const types_1 = require("../../types");
+const utils_2 = require("../../utils");
+const helpers_1 = require("../utils/helpers/helpers");
+const butterSwapHistoryService_1 = require("./utils/butterSwapHistoryService");
+const butterSwapService_1 = require("./utils/butterSwapService");
+const helpers_2 = require("./utils/helpers");
+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 || (exports.ButterSwapErrorCode = ButterSwapErrorCode = {}));
+const SOLANA_NATIVE_ADDRESS = 'So11111111111111111111111111111111111111112';
+const getButterRoute = async ({ sellAsset, buyAsset, sellAmountCryptoBaseUnit, slippage, affiliate, }) => {
+    const butterFromChainId = (0, helpers_2.chainIdToButterSwapChainId)(sellAsset.chainId);
+    const butterToChainId = (0, helpers_2.chainIdToButterSwapChainId)(buyAsset.chainId);
+    if (!butterFromChainId || !butterToChainId) {
+        return (0, monads_1.Err)((0, utils_2.makeSwapErrorRight)({
+            message: '[getButterRoute] Unsupported chainId',
+            code: types_1.TradeQuoteError.UnsupportedChain,
+        }));
+    }
+    const feeAssetId = (0, utils_1.chainIdToFeeAssetId)(sellAsset.chainId);
+    const sellAssetIsNative = sellAsset.assetId === feeAssetId;
+    const buyAssetIsNative = buyAsset.assetId === (0, utils_1.chainIdToFeeAssetId)(buyAsset.chainId);
+    const { assetReference: sellAssetAddressRaw } = (0, caip_1.fromAssetId)(sellAsset.assetId);
+    const { assetReference: buyAssetAddressRaw } = (0, caip_1.fromAssetId)(buyAsset.assetId);
+    const sellAssetAddress = (() => {
+        if (sellAsset.chainId === caip_1.solanaChainId && sellAssetIsNative)
+            return SOLANA_NATIVE_ADDRESS;
+        if (sellAssetIsNative)
+            return viem_1.zeroAddress;
+        return sellAssetAddressRaw;
+    })();
+    const buyAssetAddress = (() => {
+        if (buyAsset.chainId === caip_1.solanaChainId && buyAssetIsNative)
+            return SOLANA_NATIVE_ADDRESS;
+        if (buyAssetIsNative)
+            return viem_1.zeroAddress;
+        return buyAssetAddressRaw;
+    })();
+    const isSameChainSolanaSwap = sellAsset.chainId === caip_1.solanaChainId && buyAsset.chainId === caip_1.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: (0, helpers_1.getTreasuryAddressFromChainId)(caip_1.solanaChainId) }),
+    };
+    const result = await butterSwapService_1.butterService.get('/route', { params });
+    if (result.isErr())
+        return (0, monads_1.Err)(result.unwrapErr());
+    const data = result.unwrap().data;
+    return (0, monads_1.Ok)(data);
+};
+exports.getButterRoute = getButterRoute;
+const fetchTxData = async ({ hash, slippage, from, receiver, }) => {
+    const result = await butterSwapService_1.butterService.get('/swap', {
+        params: { hash, slippage, from, receiver },
+    });
+    if (result.isErr())
+        return (0, monads_1.Err)(result.unwrapErr());
+    const data = result.unwrap().data;
+    return (0, monads_1.Ok)(data);
+};
+exports.fetchTxData = fetchTxData;
+function isRouteSuccess(response) {
+    return response.errno === 0;
+}
+exports.isRouteSuccess = isRouteSuccess;
+function isBuildTxSuccess(response) {
+    return response.errno === 0;
+}
+exports.isBuildTxSuccess = isBuildTxSuccess;
+/**
+ * @see https://docs.butternetwork.io/butter-swap-integration/butter-api-for-swap-data/get-swap-history-by-source-hash
+ */
+const getBridgeInfoBySourceHash = async (hash) => {
+    try {
+        const result = await butterSwapHistoryService_1.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 (0, monads_1.Ok)(undefined);
+        }
+        return (0, monads_1.Ok)(data.data.info);
+    }
+    catch (e) {
+        return (0, monads_1.Ok)(undefined);
+    }
+};
+exports.getBridgeInfoBySourceHash = getBridgeInfoBySourceHash;
+/**
+ * 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
+ */
+function butterSwapErrorToTradeQuoteError(errno) {
+    switch (errno) {
+        case ButterSwapErrorCode.ParameterError:
+            return types_1.TradeQuoteError.QueryFailed;
+        case ButterSwapErrorCode.ChainNotSupported:
+            return types_1.TradeQuoteError.UnsupportedChain;
+        case ButterSwapErrorCode.TokenNotSupported:
+            return types_1.TradeQuoteError.UnsupportedTradePair;
+        case ButterSwapErrorCode.NoRouteFound:
+            return types_1.TradeQuoteError.NoRouteFound;
+        case ButterSwapErrorCode.InsufficientLiquidity:
+            return types_1.TradeQuoteError.NoRouteFound;
+        case ButterSwapErrorCode.SlippageOutOfRange:
+            return types_1.TradeQuoteError.FinalQuoteMaxSlippageExceeded;
+        case ButterSwapErrorCode.InsufficientAmount:
+            return types_1.TradeQuoteError.SellAmountBelowMinimum;
+        case ButterSwapErrorCode.InvalidAddress:
+            return types_1.TradeQuoteError.QueryFailed;
+        default:
+            return types_1.TradeQuoteError.QueryFailed;
+    }
+}
+exports.butterSwapErrorToTradeQuoteError = butterSwapErrorToTradeQuoteError;

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;