@shapeshiftoss/swapper 17.6.6 → 17.6.8

package/dist/esm/swappers/CetusSwapper/swapperApi/getCetusTradeData.js

@@ -0,0 +1,75 @@
+import { getProvidersExcluding } from '@cetusprotocol/aggregator-sdk';
+import { suiAssetId } from '@shapeshiftoss/caip';
+import { Err, Ok } from '@sniptt/monads';
+import { TradeQuoteError } from '../../../types.js';
+import { getInputOutputRate, makeSwapErrorRight } from '../../../utils.js';
+import { isSupportedChainId, PYTH_DEPENDENT_PROVIDERS } from '../utils/constants.js';
+import { findBestRoute, getAggregatorClient, getCoinType } from '../utils/helpers.js';
+export const getCetusTradeData = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit } = input;
+    const { assetsById } = deps;
+    if (!isSupportedChainId(sellAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: sellAsset.chainId },
+        }));
+    }
+    if (!isSupportedChainId(buyAsset.chainId)) {
+        return Err(makeSwapErrorRight({
+            message: `unsupported chainId`,
+            code: TradeQuoteError.UnsupportedChain,
+            details: { chainId: buyAsset.chainId },
+        }));
+    }
+    const suiAsset = assetsById[suiAssetId];
+    if (!suiAsset) {
+        return Err(makeSwapErrorRight({
+            message: `suiAsset is required`,
+            code: TradeQuoteError.InternalError,
+        }));
+    }
+    try {
+        const adapter = deps.assertGetSuiChainAdapter(sellAsset.chainId);
+        const rpcUrl = deps.config.VITE_SUI_NODE_URL;
+        const client = getAggregatorClient(rpcUrl);
+        const sellCoinType = getCoinType(sellAsset);
+        const buyCoinType = getCoinType(buyAsset);
+        // Exclude Pyth-dependent providers to avoid oracle failures
+        const providersWithoutPyth = getProvidersExcluding(PYTH_DEPENDENT_PROVIDERS);
+        const routerData = await findBestRoute(client, sellCoinType, buyCoinType, sellAmountIncludingProtocolFeesCryptoBaseUnit, providersWithoutPyth);
+        if (!routerData) {
+            return Err(makeSwapErrorRight({
+                message: `No route found for ${sellAsset.symbol}/${buyAsset.symbol}`,
+                code: TradeQuoteError.NoRouteFound,
+            }));
+        }
+        const buyAmountAfterFeesCryptoBaseUnit = routerData.amountOut.toString();
+        const rate = getInputOutputRate({
+            sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            buyAmountCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+            sellAsset,
+            buyAsset,
+        });
+        const dummyAddress = '0x0000000000000000000000000000000000000000000000000000000000000000';
+        const addressForFeeEstimate = receiveAddress ?? dummyAddress;
+        const protocolFees = {};
+        return Ok({
+            buyAmountAfterFeesCryptoBaseUnit,
+            rate,
+            addressForFeeEstimate,
+            sellCoinType,
+            buyCoinType,
+            routerData,
+            protocolFees,
+            adapter,
+            rpcUrl,
+        });
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus data',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};

package/dist/esm/swappers/CetusSwapper/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 getTradeQuote: (input: CommonTradeQuoteInput, deps: SwapperDeps) => Promise<Result<TradeQuote[], SwapErrorRight>>;

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

@@ -0,0 +1,93 @@
+import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
+import { getCetusTradeData } from './getCetusTradeData.js';
+export const getTradeQuote = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, accountNumber, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    if (accountNumber === undefined) {
+        return Err(makeSwapErrorRight({
+            message: `accountNumber is required`,
+            code: TradeQuoteError.InternalError,
+        }));
+    }
+    const tradeDataResult = await getCetusTradeData({
+        sellAsset,
+        buyAsset,
+        receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+    }, deps);
+    if (tradeDataResult.isErr())
+        return Err(tradeDataResult.unwrapErr());
+    const { buyAmountAfterFeesCryptoBaseUnit, rate, addressForFeeEstimate, routerData, protocolFees, rpcUrl, } = tradeDataResult.unwrap();
+    try {
+        // Build the actual Cetus swap transaction to get accurate gas estimation
+        const client = getAggregatorClient(rpcUrl);
+        const suiClient = getSuiClient(rpcUrl);
+        const slippage = bnOrZero(slippageTolerancePercentageDecimal ??
+            getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Cetus)).toNumber();
+        const txb = new Transaction();
+        txb.setSender(addressForFeeEstimate);
+        await client.fastRouterSwap({
+            router: routerData,
+            slippage,
+            txb,
+            refreshAllCoins: true,
+        });
+        const transactionBytes = await txb.build({ client: suiClient });
+        const dryRunResult = await suiClient.dryRunTransactionBlock({
+            transactionBlock: transactionBytes,
+        });
+        const computationCost = BigInt(dryRunResult.effects.gasUsed.computationCost);
+        const storageCost = BigInt(dryRunResult.effects.gasUsed.storageCost);
+        const storageRebate = BigInt(dryRunResult.effects.gasUsed.storageRebate);
+        const netStorageCost = storageCost > storageRebate ? storageCost - storageRebate : 0n;
+        const estimatedGas = computationCost + netStorageCost;
+        const txFee = estimatedGas.toString();
+        const gasBudget = ((estimatedGas * 120n) / 100n).toString();
+        const gasPrice = await suiClient.getReferenceGasPrice();
+        const tradeQuote = {
+            id: uuid(),
+            quoteOrRate: 'quote',
+            rate,
+            affiliateBps,
+            receiveAddress,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.Cetus,
+            steps: [
+                {
+                    accountNumber,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: txFee,
+                        chainSpecific: {
+                            gasBudget,
+                            gasPrice: gasPrice.toString(),
+                        },
+                    },
+                    rate,
+                    source: SwapperName.Cetus,
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: undefined,
+                },
+            ],
+        };
+        return tradeDataResult.map(() => [tradeQuote]);
+    }
+    catch (error) {
+        console.error(error);
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus quote',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};

package/dist/esm/swappers/CetusSwapper/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 getTradeRate: (input: GetTradeRateInput, deps: SwapperDeps) => Promise<Result<TradeRate[], SwapErrorRight>>;

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

@@ -0,0 +1,90 @@
+import { Transaction } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/transactions';
+import { bnOrZero } from '@shapeshiftoss/utils';
+import { Err } from '@sniptt/monads';
+import { v4 as uuid } from 'uuid';
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../../constants.js';
+import { SwapperName, TradeQuoteError } from '../../../types.js';
+import { makeSwapErrorRight } from '../../../utils.js';
+import { getAggregatorClient, getSuiClient } from '../utils/helpers.js';
+import { getCetusTradeData } from './getCetusTradeData.js';
+export const getTradeRate = async (input, deps) => {
+    const { sellAsset, buyAsset, receiveAddress, sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount, affiliateBps, slippageTolerancePercentageDecimal, } = input;
+    const tradeDataResult = await getCetusTradeData({
+        sellAsset,
+        buyAsset,
+        receiveAddress,
+        sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+    }, deps);
+    if (tradeDataResult.isErr())
+        return Err(tradeDataResult.unwrapErr());
+    const { buyAmountAfterFeesCryptoBaseUnit, rate, addressForFeeEstimate, routerData, protocolFees, rpcUrl, } = tradeDataResult.unwrap();
+    try {
+        // Build the actual Cetus swap transaction to get accurate gas estimation
+        const client = getAggregatorClient(rpcUrl);
+        const suiClient = getSuiClient(rpcUrl);
+        const slippage = bnOrZero(slippageTolerancePercentageDecimal ??
+            getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Cetus)).toNumber();
+        const txb = new Transaction();
+        txb.setSender(addressForFeeEstimate);
+        await client.fastRouterSwap({
+            router: routerData,
+            slippage,
+            txb,
+            refreshAllCoins: true,
+        });
+        const txFee = await (async () => {
+            try {
+                const transactionBytes = await txb.build({ client: suiClient });
+                const dryRunResult = await suiClient.dryRunTransactionBlock({
+                    transactionBlock: transactionBytes,
+                });
+                const computationCost = BigInt(dryRunResult.effects.gasUsed.computationCost);
+                const storageCost = BigInt(dryRunResult.effects.gasUsed.storageCost);
+                const storageRebate = BigInt(dryRunResult.effects.gasUsed.storageRebate);
+                const netStorageCost = storageCost > storageRebate ? storageCost - storageRebate : 0n;
+                const estimatedGas = computationCost + netStorageCost;
+                return estimatedGas.toString();
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('Not enough coins of type')) {
+                    return undefined;
+                }
+                throw error;
+            }
+        })();
+        const tradeRate = {
+            id: uuid(),
+            quoteOrRate: 'rate',
+            rate,
+            affiliateBps,
+            receiveAddress,
+            slippageTolerancePercentageDecimal,
+            swapperName: SwapperName.Cetus,
+            steps: [
+                {
+                    accountNumber: undefined,
+                    buyAmountBeforeFeesCryptoBaseUnit: buyAmountAfterFeesCryptoBaseUnit,
+                    buyAmountAfterFeesCryptoBaseUnit,
+                    sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
+                    feeData: {
+                        protocolFees,
+                        networkFeeCryptoBaseUnit: txFee,
+                    },
+                    rate,
+                    source: SwapperName.Cetus,
+                    buyAsset,
+                    sellAsset,
+                    allowanceContract: '0x0',
+                    estimatedExecutionTimeMs: undefined,
+                },
+            ],
+        };
+        return tradeDataResult.map(() => [tradeRate]);
+    }
+    catch (error) {
+        return Err(makeSwapErrorRight({
+            message: error instanceof Error ? error.message : 'Unknown error getting Cetus rate',
+            code: TradeQuoteError.QueryFailed,
+        }));
+    }
+};

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

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

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

@@ -0,0 +1,6 @@
+import { suiChainId } from '@shapeshiftoss/caip';
+export const SUPPORTED_CETUS_CHAIN_IDS = [suiChainId];
+export const isSupportedChainId = (chainId) => {
+    return SUPPORTED_CETUS_CHAIN_IDS.includes(chainId);
+};
+export const PYTH_DEPENDENT_PROVIDERS = ['HAEDALPMM', 'HAEDALHMMV2', 'METASTABLE'];

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

@@ -0,0 +1,8 @@
+import type { RouterDataV3 } from '@cetusprotocol/aggregator-sdk';
+import { AggregatorClient } from '@cetusprotocol/aggregator-sdk';
+import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
+import type { Asset } from '@shapeshiftoss/types';
+export declare const getAggregatorClient: (rpcUrl: string) => AggregatorClient;
+export declare const getSuiClient: (rpcUrl: string) => SuiClient;
+export declare const getCoinType: (asset: Asset) => string;
+export declare const findBestRoute: (client: AggregatorClient, sellCoinType: string, buyCoinType: string, sellAmountCryptoBaseUnit: string, providers?: string[]) => Promise<RouterDataV3 | undefined>;

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

@@ -0,0 +1,56 @@
+import { AggregatorClient, Env } from '@cetusprotocol/aggregator-sdk';
+import { SuiClient } from '@cetusprotocol/aggregator-sdk/node_modules/@mysten/sui/client';
+import { fromAssetId } from '@shapeshiftoss/caip';
+let suiClientInstance;
+let aggregatorClientInstance;
+let currentRpcUrl;
+export const getAggregatorClient = (rpcUrl) => {
+    if (!aggregatorClientInstance || !suiClientInstance || currentRpcUrl !== rpcUrl) {
+        suiClientInstance = new SuiClient({ url: rpcUrl });
+        aggregatorClientInstance = new AggregatorClient({
+            client: suiClientInstance,
+            env: Env.Mainnet,
+            signer: '0x0',
+        });
+        currentRpcUrl = rpcUrl;
+    }
+    return aggregatorClientInstance;
+};
+export const getSuiClient = (rpcUrl) => {
+    if (!suiClientInstance || currentRpcUrl !== rpcUrl) {
+        suiClientInstance = new SuiClient({ url: rpcUrl });
+        currentRpcUrl = rpcUrl;
+    }
+    return suiClientInstance;
+};
+export const getCoinType = (asset) => {
+    const { assetReference, assetNamespace } = 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;
+};
+export const findBestRoute = async (client, sellCoinType, buyCoinType, sellAmountCryptoBaseUnit, providers) => {
+    const routerData = await client.findRouters({
+        from: sellCoinType,
+        target: buyCoinType,
+        amount: sellAmountCryptoBaseUnit,
+        byAmountIn: true,
+        ...(providers && { providers }),
+    });
+    if (!routerData) {
+        console.warn('[Cetus Aggregator] No route found for', sellCoinType, buyCoinType);
+        return undefined;
+    }
+    if (routerData.insufficientLiquidity) {
+        console.warn('[Cetus Aggregator] Insufficient liquidity for', sellCoinType, buyCoinType);
+        return undefined;
+    }
+    if (routerData.error) {
+        console.warn('[Cetus Aggregator] Error finding route:', routerData.error);
+        return undefined;
+    }
+    return routerData;
+};

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;

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

@@ -0,0 +1,191 @@
+import { evm } from '@shapeshiftoss/chain-adapters';
+import { TxStatus } from '@shapeshiftoss/unchained-client';
+import { contractAddressOrUndefined } from '@shapeshiftoss/utils';
+import { getExecutableTradeStep, isExecutableTradeQuote } from '../../utils.js';
+import { isNativeEvmAsset } from '../utils/helpers/helpers.js';
+import { ChainflipStatusMessage } from './constants.js';
+import { getTradeQuote } from './swapperApi/getTradeQuote.js';
+import { getTradeRate } from './swapperApi/getTradeRate.js';
+import { chainflipService } from './utils/chainflipService.js';
+import { getLatestChainflipStatusMessage } from './utils/getLatestChainflipStatusMessage.js';
+export const chainflipApi = {
+    getTradeQuote,
+    getTradeRate,
+    getUnsignedEvmTransaction: async ({ from, stepIndex, tradeQuote, assertGetEvmChainAdapter, supportsEIP1559, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, chainflipSpecific, sellAsset } = step;
+        if (!chainflipSpecific?.chainflipDepositAddress)
+            throw Error('Missing deposit address');
+        if (!chainflipSpecific?.chainflipSwapId)
+            throw Error('Missing swap id');
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const to = chainflipSpecific.chainflipDepositAddress;
+        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+        const data = evm.getErc20Data(to, value, contractAddress);
+        const feeData = await evm.getFees({
+            adapter,
+            data: data || '0x',
+            to: contractAddress ?? to,
+            value: isNativeEvmAsset(sellAsset.assetId) ? value : '0',
+            from,
+            supportsEIP1559,
+        });
+        return adapter.buildSendApiTransaction({
+            accountNumber,
+            from,
+            to,
+            value,
+            chainSpecific: { contractAddress, ...feeData },
+        });
+    },
+    getEvmTransactionFees: async ({ from, stepIndex, tradeQuote, supportsEIP1559, assertGetEvmChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { chainflipSpecific, sellAsset } = step;
+        if (!chainflipSpecific?.chainflipDepositAddress)
+            throw Error('Missing deposit address');
+        if (!chainflipSpecific?.chainflipSwapId)
+            throw Error('Missing swap id');
+        const adapter = assertGetEvmChainAdapter(sellAsset.chainId);
+        const contractAddress = contractAddressOrUndefined(sellAsset.assetId);
+        const to = chainflipSpecific.chainflipDepositAddress;
+        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const data = evm.getErc20Data(to, value, contractAddress);
+        const { networkFeeCryptoBaseUnit } = await evm.getFees({
+            adapter,
+            data: data || '0x',
+            to: contractAddress ?? to,
+            value: isNativeEvmAsset(sellAsset.assetId) ? value : '0',
+            from,
+            supportsEIP1559,
+        });
+        return networkFeeCryptoBaseUnit;
+    },
+    getUnsignedUtxoTransaction: ({ stepIndex, tradeQuote, xpub, accountType, assertGetUtxoChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, chainflipSpecific, sellAsset } = step;
+        if (!chainflipSpecific?.chainflipDepositAddress)
+            throw Error('Missing deposit address');
+        if (!chainflipSpecific?.chainflipSwapId)
+            throw Error('Missing swap id');
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        return adapter.buildSendApiTransaction({
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            xpub,
+            to: chainflipSpecific.chainflipDepositAddress,
+            accountNumber,
+            skipToAddressValidation: true,
+            chainSpecific: {
+                accountType,
+                satoshiPerByte: step.feeData.chainSpecific.satsPerByte,
+            },
+        });
+    },
+    getUtxoTransactionFees: async ({ stepIndex, tradeQuote, xpub, assertGetUtxoChainAdapter }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { chainflipSpecific, sellAsset } = step;
+        if (!chainflipSpecific?.chainflipDepositAddress)
+            throw Error('Missing deposit address');
+        if (!chainflipSpecific?.chainflipSwapId)
+            throw Error('Missing swap id');
+        const adapter = assertGetUtxoChainAdapter(sellAsset.chainId);
+        const { fast } = await adapter.getFeeData({
+            to: chainflipSpecific.chainflipDepositAddress,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            chainSpecific: { pubkey: xpub },
+            sendMax: false,
+        });
+        return fast.txFee;
+    },
+    getUnsignedSolanaTransaction: async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { accountNumber, chainflipSpecific, sellAsset } = step;
+        if (!chainflipSpecific?.chainflipDepositAddress)
+            throw Error('Missing deposit address');
+        if (!chainflipSpecific?.chainflipSwapId)
+            throw Error('Missing swap id');
+        const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+        const to = chainflipSpecific.chainflipDepositAddress;
+        const value = step.sellAmountIncludingProtocolFeesCryptoBaseUnit;
+        const tokenId = contractAddressOrUndefined(sellAsset.assetId);
+        const { fast } = await adapter.getFeeData({
+            to,
+            value,
+            chainSpecific: { from, tokenId },
+        });
+        return adapter.buildSendApiTransaction({
+            to,
+            from,
+            value,
+            accountNumber,
+            chainSpecific: {
+                tokenId,
+                computeUnitLimit: fast.chainSpecific.computeUnits,
+                computeUnitPrice: fast.chainSpecific.priorityFee,
+            },
+        });
+    },
+    getSolanaTransactionFees: async ({ stepIndex, tradeQuote, from, assertGetSolanaChainAdapter, }) => {
+        if (!isExecutableTradeQuote(tradeQuote))
+            throw new Error('Unable to execute a trade rate quote');
+        const step = getExecutableTradeStep(tradeQuote, stepIndex);
+        const { chainflipSpecific, sellAsset } = step;
+        if (!chainflipSpecific?.chainflipDepositAddress)
+            throw Error('Missing deposit address');
+        if (!chainflipSpecific?.chainflipSwapId)
+            throw Error('Missing swap id');
+        const adapter = assertGetSolanaChainAdapter(sellAsset.chainId);
+        const { fast } = await adapter.getFeeData({
+            to: chainflipSpecific.chainflipDepositAddress,
+            value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+            chainSpecific: {
+                from,
+                tokenId: contractAddressOrUndefined(sellAsset.assetId),
+            },
+        });
+        return fast.txFee;
+    },
+    checkTradeStatus: async ({ config, swap }) => {
+        const chainflipSwapId = swap?.metadata.chainflipSwapId;
+        if (!chainflipSwapId)
+            throw Error(`chainflipSwapId is required`);
+        const brokerUrl = config.VITE_CHAINFLIP_API_URL;
+        const apiKey = config.VITE_CHAINFLIP_API_KEY;
+        const maybeStatusResponse = await chainflipService.get(`${brokerUrl}/status-by-id?apiKey=${apiKey}&swapId=${chainflipSwapId}`);
+        if (maybeStatusResponse.isErr()) {
+            return {
+                buyTxHash: undefined,
+                status: TxStatus.Unknown,
+                // assume the swap is not yet seen on that call
+                message: ChainflipStatusMessage.WaitingForDeposit,
+            };
+        }
+        const { data: statusResponse } = maybeStatusResponse.unwrap();
+        const { status: { swapEgress }, } = statusResponse;
+        // Assume no outbound Tx is a pending Tx
+        if (!swapEgress?.transactionReference) {
+            return {
+                buyTxHash: undefined,
+                status: TxStatus.Pending,
+                message: getLatestChainflipStatusMessage(statusResponse),
+            };
+        }
+        // Assume as soon as we have an outbound Tx, the swap is complete.
+        // Chainflip waits for 3 confirmations to assume complete (vs. 1 for us), which is turbo long.
+        return {
+            buyTxHash: swapEgress.transactionReference,
+            status: TxStatus.Confirmed,
+            message: undefined,
+        };
+    },
+};

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

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './constants.js';

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

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './constants.js';