@coin-voyage/swapkit 0.1.0-beta.0 → 0.1.0-beta.2

package/dist/hooks/use-swap-quote.d.ts

@@ -0,0 +1,6 @@
+import type { SwapQuote, SwapQuoteRequest } from "@coin-voyage/shared/types";
+export declare function useSwapQuote(request: SwapQuoteRequest | null, enabled?: boolean): {
+    quote: SwapQuote | null;
+    loading: boolean;
+    error: string | null;
+};

package/dist/hooks/use-swap-quote.js

@@ -0,0 +1,63 @@
+import { useEffect, useRef, useState } from "react";
+import { useSwapKit } from "../providers/swapkit-context";
+const QUOTE_DEBOUNCE_MS = 400;
+const QUOTE_REFRESH_MS = 10000;
+export function useSwapQuote(request, enabled = true) {
+    const { api } = useSwapKit();
+    const [quote, setQuote] = useState(null);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const requestId = useRef(0);
+    useEffect(() => {
+        const id = ++requestId.current;
+        if (!request || !enabled) {
+            setLoading(false);
+            if (!request) {
+                setQuote(null);
+                setError(null);
+            }
+            return;
+        }
+        setQuote(null);
+        setError(null);
+        setLoading(true);
+        const controller = new AbortController();
+        let interval;
+        const load = async (initial) => {
+            try {
+                const response = await api.swapQuote(request, { signal: controller.signal });
+                if (requestId.current !== id)
+                    return;
+                if (response.error || !response.data?.quote) {
+                    setQuote(null);
+                    setError(response.error?.message || "No swap route is available");
+                }
+                else {
+                    setQuote(response.data.quote);
+                    setError(null);
+                }
+            }
+            catch (requestError) {
+                if (requestId.current !== id || requestError.name === "AbortError")
+                    return;
+                setQuote(null);
+                setError("Unable to fetch a swap quote");
+            }
+            finally {
+                if (initial && requestId.current === id)
+                    setLoading(false);
+            }
+        };
+        const timeout = setTimeout(() => {
+            void load(true);
+            interval = setInterval(() => void load(false), QUOTE_REFRESH_MS);
+        }, QUOTE_DEBOUNCE_MS);
+        return () => {
+            clearTimeout(timeout);
+            if (interval)
+                clearInterval(interval);
+            controller.abort();
+        };
+    }, [api, request, enabled]);
+    return { quote, loading, error };
+}

package/dist/hooks/use-swap-state.d.ts

@@ -0,0 +1,70 @@
+import type { ChainType, Currency, CurrencyBase } from "@coin-voyage/shared/types";
+import type { SwapSide } from "../lib/quote";
+export type SlippageMode = "auto" | "custom";
+export interface ManualOutputWallet {
+    chainId: number;
+    address: string;
+}
+export interface SwapState {
+    sourceId?: string;
+    destinationId?: string;
+    inputAmount: string;
+    outputAmount: string;
+    activeSide: SwapSide;
+    slippageMode: SlippageMode;
+    slippagePercent: string;
+    manualOutputWallet?: ManualOutputWallet;
+    currenciesInitialized: boolean;
+    initialSourceId?: string;
+    initialDestinationId?: string;
+    initialSlippageMode: SlippageMode;
+    initialSlippagePercent: string;
+}
+export type SwapStateAction = {
+    type: "initialize_currencies";
+    sourceId?: string;
+    destinationId?: string;
+} | {
+    type: "select_currency";
+    side: SwapSide;
+    id: string;
+} | {
+    type: "set_amount";
+    side: SwapSide;
+    value: string;
+} | {
+    type: "reverse";
+    inputAmount: string;
+    outputAmount: string;
+} | {
+    type: "set_slippage_mode";
+    mode: SlippageMode;
+} | {
+    type: "set_slippage";
+    value: string;
+} | {
+    type: "set_manual_output_wallet";
+    wallet?: ManualOutputWallet;
+} | {
+    type: "reset";
+};
+export declare function createSwapState(defaultSlippageBps?: number): SwapState;
+export declare function swapStateReducer(state: SwapState, action: SwapStateAction): SwapState;
+interface UseSwapStateOptions {
+    currencies: Currency[];
+    connectedChainTypes: ReadonlySet<ChainType>;
+    defaultSourceCurrency?: CurrencyBase;
+    defaultDestinationCurrency?: CurrencyBase;
+    defaultSlippageBps?: number;
+}
+export declare function useSwapState({ currencies, connectedChainTypes, defaultSourceCurrency, defaultDestinationCurrency, defaultSlippageBps, }: UseSwapStateOptions): {
+    state: SwapState;
+    setAmount: (side: SwapSide, value: string) => void;
+    selectCurrency: (side: SwapSide, id: string) => void;
+    reverse: (inputAmount: string, outputAmount: string) => void;
+    setSlippageMode: (mode: SlippageMode) => void;
+    setSlippagePercent: (value: string) => void;
+    setManualOutputWallet: (wallet?: ManualOutputWallet) => void;
+    reset: () => void;
+};
+export {};

package/dist/hooks/use-swap-state.js

@@ -0,0 +1,147 @@
+import { useCallback, useEffect, useReducer, useState } from "react";
+import { resolveCurrencySelection } from "../lib/currency-selection";
+const DEFAULT_CUSTOM_SLIPPAGE_BPS = 100;
+function slippagePercent(defaultSlippageBps) {
+    if (!Number.isFinite(defaultSlippageBps) ||
+        !Number.isInteger(defaultSlippageBps) ||
+        defaultSlippageBps < 0 ||
+        defaultSlippageBps > 10000) {
+        throw new RangeError("defaultSlippageBps must be an integer between 0 and 10000");
+    }
+    return String(defaultSlippageBps / 100);
+}
+export function createSwapState(defaultSlippageBps) {
+    const initialSlippageMode = defaultSlippageBps === undefined ? "auto" : "custom";
+    const initialSlippagePercent = slippagePercent(defaultSlippageBps ?? DEFAULT_CUSTOM_SLIPPAGE_BPS);
+    return {
+        inputAmount: "",
+        outputAmount: "",
+        activeSide: "input",
+        slippageMode: initialSlippageMode,
+        slippagePercent: initialSlippagePercent,
+        currenciesInitialized: false,
+        initialSlippageMode,
+        initialSlippagePercent,
+    };
+}
+export function swapStateReducer(state, action) {
+    switch (action.type) {
+        case "initialize_currencies":
+            if (state.currenciesInitialized)
+                return state;
+            return {
+                ...state,
+                sourceId: action.sourceId,
+                destinationId: action.destinationId,
+                initialSourceId: action.sourceId,
+                initialDestinationId: action.destinationId,
+                currenciesInitialized: true,
+            };
+        case "select_currency":
+            return {
+                ...state,
+                sourceId: action.side === "input" ? action.id : state.sourceId,
+                destinationId: action.side === "output" ? action.id : state.destinationId,
+                inputAmount: "",
+                outputAmount: "",
+                manualOutputWallet: action.side === "output" ? undefined : state.manualOutputWallet,
+            };
+        case "set_amount":
+            return {
+                ...state,
+                activeSide: action.side,
+                inputAmount: action.side === "input" ? action.value : state.inputAmount,
+                outputAmount: action.side === "output" ? action.value : state.outputAmount,
+            };
+        case "reverse":
+            return {
+                ...state,
+                sourceId: state.destinationId,
+                destinationId: state.sourceId,
+                inputAmount: action.outputAmount,
+                outputAmount: action.inputAmount,
+                activeSide: state.activeSide === "input" ? "output" : "input",
+                manualOutputWallet: undefined,
+            };
+        case "set_slippage_mode":
+            return { ...state, slippageMode: action.mode };
+        case "set_slippage":
+            return { ...state, slippageMode: "custom", slippagePercent: action.value };
+        case "set_manual_output_wallet":
+            return { ...state, manualOutputWallet: action.wallet };
+        case "reset":
+            return {
+                ...state,
+                sourceId: state.initialSourceId,
+                destinationId: state.initialDestinationId,
+                inputAmount: "",
+                outputAmount: "",
+                activeSide: "input",
+                slippageMode: state.initialSlippageMode,
+                slippagePercent: state.initialSlippagePercent,
+                manualOutputWallet: undefined,
+            };
+    }
+}
+export function useSwapState({ currencies, connectedChainTypes, defaultSourceCurrency, defaultDestinationCurrency, defaultSlippageBps, }) {
+    const [defaults] = useState(() => ({ source: defaultSourceCurrency, destination: defaultDestinationCurrency }));
+    const [state, dispatch] = useReducer(swapStateReducer, undefined, () => {
+        const initialState = createSwapState(defaultSlippageBps);
+        if (currencies.length === 0)
+            return initialState;
+        return swapStateReducer(initialState, {
+            type: "initialize_currencies",
+            ...resolveCurrencySelection({
+                currencies,
+                connectedChainTypes,
+                defaultSourceCurrency: defaults.source,
+                defaultDestinationCurrency: defaults.destination,
+            }),
+        });
+    });
+    useEffect(() => {
+        if (state.currenciesInitialized || currencies.length === 0)
+            return;
+        const selection = resolveCurrencySelection({
+            currencies,
+            connectedChainTypes,
+            defaultSourceCurrency: defaults.source,
+            defaultDestinationCurrency: defaults.destination,
+        });
+        dispatch({ type: "initialize_currencies", ...selection });
+    }, [connectedChainTypes, currencies, defaults.destination, defaults.source, state.currenciesInitialized]);
+    const setAmount = useCallback((side, value) => {
+        dispatch({ type: "set_amount", side, value });
+    }, []);
+    const selectCurrency = useCallback((side, id) => {
+        dispatch({ type: "select_currency", side, id });
+    }, []);
+    const reverse = useCallback((inputAmount, outputAmount) => {
+        dispatch({ type: "reverse", inputAmount, outputAmount });
+    }, []);
+    const setSlippagePercent = useCallback((value) => dispatch({ type: "set_slippage", value }), []);
+    const setSlippageMode = useCallback((mode) => dispatch({ type: "set_slippage_mode", mode }), []);
+    const setManualOutputWallet = useCallback((wallet) => dispatch({ type: "set_manual_output_wallet", wallet }), []);
+    const reset = useCallback(() => dispatch({ type: "reset" }), []);
+    const resolvedState = !state.currenciesInitialized && currencies.length > 0
+        ? swapStateReducer(state, {
+            type: "initialize_currencies",
+            ...resolveCurrencySelection({
+                currencies,
+                connectedChainTypes,
+                defaultSourceCurrency: defaults.source,
+                defaultDestinationCurrency: defaults.destination,
+            }),
+        })
+        : state;
+    return {
+        state: resolvedState,
+        setAmount,
+        selectCurrency,
+        reverse,
+        setSlippageMode,
+        setSlippagePercent,
+        setManualOutputWallet,
+        reset,
+    };
+}

package/dist/hooks/use-token-data.d.ts

@@ -0,0 +1,12 @@
+import { type Currency } from "@coin-voyage/shared/types";
+export interface SwapToken {
+    currency: Currency;
+    balance?: number;
+    balanceUsd?: number;
+}
+export declare function useTokenData(): {
+    tokens: SwapToken[];
+    accounts: import("@coin-voyage/crypto/hooks").Account[];
+    isLoading: boolean;
+    error: string | null;
+};

package/dist/hooks/use-token-data.js

@@ -0,0 +1,80 @@
+import { useAccount } from "@coin-voyage/crypto/hooks";
+import { fetchTokenList, tokenToCurrency } from "@coin-voyage/shared/currency";
+import { currencyID } from "@coin-voyage/shared/types";
+import { useEffect, useState } from "react";
+import { useSwapKit } from "../providers/swapkit-context";
+function mergeTokens(tokenList, portfolio) {
+    const portfolioById = new Map(portfolio.map((token) => [currencyID(token.currency), token]));
+    const tokenListIds = new Set(tokenList.map(currencyID));
+    const listed = tokenList.map((currency) => portfolioById.get(currencyID(currency)) ?? { currency });
+    const unlisted = portfolio.filter((token) => !tokenListIds.has(currencyID(token.currency)));
+    return [...listed, ...unlisted].sort((left, right) => (right.balanceUsd ?? 0) - (left.balanceUsd ?? 0));
+}
+export function useTokenData() {
+    const { api } = useSwapKit();
+    const { accounts } = useAccount();
+    const [listedCurrencies, setListedCurrencies] = useState([]);
+    const [portfolioState, setPortfolioState] = useState({
+        walletKey: "[]",
+        tokens: [],
+    });
+    const [isLoading, setIsLoading] = useState(true);
+    const [tokenError, setTokenError] = useState(null);
+    const [portfolioError, setPortfolioError] = useState(null);
+    useEffect(() => {
+        let active = true;
+        fetchTokenList()
+            .then((data) => {
+            if (!active)
+                return;
+            setListedCurrencies(data.chains.flatMap((chain) => chain.tokens.map(tokenToCurrency)));
+            setTokenError(null);
+        })
+            .catch(() => {
+            if (active)
+                setTokenError("Unable to load supported tokens");
+        })
+            .finally(() => {
+            if (active)
+                setIsLoading(false);
+        });
+        return () => {
+            active = false;
+        };
+    }, []);
+    const walletKey = JSON.stringify(accounts
+        .flatMap((account) => (account.address ? [{ address: account.address, chain_type: account.chainType }] : []))
+        .sort((left, right) => `${left.chain_type}:${left.address}`.localeCompare(`${right.chain_type}:${right.address}`)));
+    useEffect(() => {
+        const wallets = JSON.parse(walletKey);
+        if (wallets.length === 0)
+            return;
+        const controller = new AbortController();
+        api
+            .portfolio({ wallets }, { signal: controller.signal })
+            .then(({ data, error: responseError }) => {
+            if (responseError || !data) {
+                setPortfolioError(responseError?.message || "Unable to load wallet balances");
+                return;
+            }
+            setPortfolioError(null);
+            setPortfolioState({
+                walletKey,
+                tokens: data.portfolio.flatMap((result) => result.currencies.map(({ balance, currency }) => ({
+                    currency,
+                    balance: Number(balance.ui),
+                    balanceUsd: balance.value_usd ?? undefined,
+                }))),
+            });
+        })
+            .catch((requestError) => {
+            if (requestError.name !== "AbortError") {
+                setPortfolioError("Unable to load wallet balances");
+            }
+        });
+        return () => controller.abort();
+    }, [api, walletKey]);
+    const activePortfolioTokens = portfolioState.walletKey === walletKey ? portfolioState.tokens : [];
+    const tokens = mergeTokens(listedCurrencies, activePortfolioTokens);
+    return { tokens, accounts, isLoading, error: tokenError ?? portfolioError };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { WalletProvider } from "@coin-voyage/crypto/wallets";
+export { Swap } from "./components/swap";
+export { SwapKitProvider } from "./providers/swapkit-provider";
+export type { SwapCompleteResult, SwapCurrency, SwapError, SwapKitMode, SwapKitProviderProps, SwapKitTheme, SwapProps, } from "./types";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { WalletProvider } from "@coin-voyage/crypto/wallets";
+export { Swap } from "./components/swap";
+export { SwapKitProvider } from "./providers/swapkit-provider";

package/dist/lib/amount-input.d.ts

@@ -0,0 +1,3 @@
+export declare function isValidSwapAmountInput(value: string): boolean;
+export declare function toSwapAmountInputValue(amount?: string | null): string;
+export declare function shouldValidateSwapBalance(amount: string): boolean;

package/dist/lib/amount-input.js

@@ -0,0 +1,11 @@
+const DECIMAL_INPUT = /^(?:\d+(?:\.\d*)?|\.\d+)?$/;
+export function isValidSwapAmountInput(value) {
+    return DECIMAL_INPUT.test(value);
+}
+export function toSwapAmountInputValue(amount) {
+    return amount && isValidSwapAmountInput(amount) ? amount : "";
+}
+export function shouldValidateSwapBalance(amount) {
+    const numericAmount = Number(amount);
+    return Number.isFinite(numericAmount) && numericAmount > 0;
+}

package/dist/lib/currency-selection.d.ts

@@ -0,0 +1,13 @@
+import { type ChainType, type Currency, type CurrencyBase } from "@coin-voyage/shared/types";
+export declare function currenciesMatch(left: CurrencyBase, right: CurrencyBase): boolean;
+interface ResolveCurrencySelectionOptions {
+    currencies: Currency[];
+    connectedChainTypes: ReadonlySet<ChainType>;
+    defaultSourceCurrency?: CurrencyBase;
+    defaultDestinationCurrency?: CurrencyBase;
+}
+export declare function resolveCurrencySelection({ currencies, connectedChainTypes, defaultSourceCurrency, defaultDestinationCurrency, }: ResolveCurrencySelectionOptions): {
+    sourceId?: string;
+    destinationId?: string;
+};
+export {};

package/dist/lib/currency-selection.js

@@ -0,0 +1,26 @@
+import { getChainTypeByChainId } from "@coin-voyage/shared/chain";
+import { currencyID } from "@coin-voyage/shared/types";
+function normalizedAddress(currency) {
+    return currency.address?.toLowerCase() ?? null;
+}
+export function currenciesMatch(left, right) {
+    return left.chain_id === right.chain_id && normalizedAddress(left) === normalizedAddress(right);
+}
+export function resolveCurrencySelection({ currencies, connectedChainTypes, defaultSourceCurrency, defaultDestinationCurrency, }) {
+    const preferredSource = defaultSourceCurrency
+        ? currencies.find((currency) => currenciesMatch(currency, defaultSourceCurrency))
+        : undefined;
+    const source = preferredSource ??
+        currencies.find((currency) => connectedChainTypes.has(getChainTypeByChainId(currency.chain_id))) ??
+        currencies[0];
+    const preferredDestination = defaultDestinationCurrency
+        ? currencies.find((currency) => currenciesMatch(currency, defaultDestinationCurrency))
+        : undefined;
+    const destination = preferredDestination && source && !currenciesMatch(preferredDestination, source)
+        ? preferredDestination
+        : currencies.find((currency) => !source || !currenciesMatch(currency, source));
+    return {
+        sourceId: source ? currencyID(source) : undefined,
+        destinationId: destination ? currencyID(destination) : undefined,
+    };
+}

package/dist/lib/execution.d.ts

@@ -0,0 +1,38 @@
+import type { ExecuteTransaction } from "@coin-voyage/crypto/types";
+import type { SwapExecuteResponse } from "@coin-voyage/shared/types";
+export type SwapStage = {
+    kind: "idle";
+} | {
+    kind: "confirming";
+} | {
+    kind: "awaiting_payment";
+    swapData: SwapExecuteResponse;
+    paymentStepIndex: number;
+} | {
+    kind: "source_confirming";
+    swapData: SwapExecuteResponse;
+    orderId: string;
+    sourceTxHash?: string;
+} | {
+    kind: "executing";
+    swapData: SwapExecuteResponse;
+    orderId: string;
+    sourceTxHash?: string;
+} | {
+    kind: "done";
+    swapData: SwapExecuteResponse;
+    orderId: string;
+    sourceTxHash?: string;
+    txHash: string;
+} | {
+    kind: "refunded";
+    swapData: SwapExecuteResponse;
+    orderId: string;
+    sourceTxHash?: string;
+    refundTxHash: string;
+} | {
+    kind: "error";
+    swapData: SwapExecuteResponse | null;
+    message: string;
+};
+export declare function buildSwapExecuteTransactions(swapData: SwapExecuteResponse, fromAddress: string): ExecuteTransaction[];

package/dist/lib/execution.js

@@ -0,0 +1,26 @@
+import { isChainPaymentData, isDepositStepData } from "@coin-voyage/shared/payment";
+export function buildSwapExecuteTransactions(swapData, fromAddress) {
+    const steps = swapData.data.steps;
+    if (steps.length === 0)
+        throw new Error("No step found");
+    return steps.map((step) => {
+        const base = { from: fromAddress };
+        if (isChainPaymentData(step.data))
+            return { ...base, paymentData: step.data };
+        if (isDepositStepData(step.data)) {
+            const tokenAddress = step.data.currency.address;
+            const decimals = swapData.data.input.currency.decimals;
+            if (tokenAddress && decimals === undefined) {
+                throw new Error("Unsupported swap step: missing token decimals");
+            }
+            return {
+                ...base,
+                to: step.data.deposit_address,
+                chainId: step.data.currency.chain_id,
+                amount: BigInt(step.data.amount),
+                ...(tokenAddress ? { token: { address: tokenAddress, decimals } } : {}),
+            };
+        }
+        throw new Error(`Unsupported swap step kind: ${step.kind}`);
+    });
+}

package/dist/lib/output-wallet.d.ts

@@ -0,0 +1,24 @@
+import type { ChainType } from "@coin-voyage/shared/types";
+export type SwapWalletRequirement = {
+    target: "none";
+} | {
+    target: "input" | "output";
+    chainType?: ChainType;
+    label: string;
+};
+interface GetSwapWalletRequirementProps {
+    inputWalletAddress?: string;
+    inputChainType?: ChainType;
+    shouldRestrictInputChainType?: boolean;
+    outputWalletAddress?: string;
+    outputChainType?: ChainType;
+}
+export declare function shouldUseSeparateOutputWallet(sourceChainType: ChainType | undefined, destinationChainType: ChainType | undefined): boolean;
+interface ShouldShowOutputWalletSelectorProps {
+    requiresSeparateOutputWallet: boolean;
+    outputChainType?: ChainType;
+    connectionRequirement: SwapWalletRequirement;
+}
+export declare function shouldShowOutputWalletSelector({ requiresSeparateOutputWallet, outputChainType, connectionRequirement, }: ShouldShowOutputWalletSelectorProps): boolean;
+export declare function getSwapWalletRequirement({ inputWalletAddress, inputChainType, shouldRestrictInputChainType, outputWalletAddress, outputChainType, }: GetSwapWalletRequirementProps): SwapWalletRequirement;
+export {};

package/dist/lib/output-wallet.js

@@ -0,0 +1,24 @@
+import { getChainTypeName } from "@coin-voyage/shared/chain";
+export function shouldUseSeparateOutputWallet(sourceChainType, destinationChainType) {
+    return Boolean(sourceChainType && destinationChainType && sourceChainType !== destinationChainType);
+}
+export function shouldShowOutputWalletSelector({ requiresSeparateOutputWallet, outputChainType, connectionRequirement, }) {
+    return Boolean(outputChainType && requiresSeparateOutputWallet && connectionRequirement.target !== "input");
+}
+export function getSwapWalletRequirement({ inputWalletAddress, inputChainType, shouldRestrictInputChainType = true, outputWalletAddress, outputChainType, }) {
+    if (!inputWalletAddress) {
+        return {
+            target: "input",
+            chainType: shouldRestrictInputChainType ? inputChainType : undefined,
+            label: "Connect Wallet",
+        };
+    }
+    if (!outputWalletAddress) {
+        return {
+            target: "output",
+            chainType: outputChainType,
+            label: `Connect ${getChainTypeName(outputChainType)} Wallet`,
+        };
+    }
+    return { target: "none" };
+}

package/dist/lib/quote.d.ts

@@ -0,0 +1,13 @@
+import { type CurrencyBase, type SwapQuoteRequest } from "@coin-voyage/shared/types";
+export type SwapSide = "input" | "output";
+export declare function toCurrencyBase(currency: CurrencyBase): CurrencyBase;
+interface BuildSwapQuoteRequestProps {
+    amount: string;
+    activeSide: SwapSide;
+    source?: CurrencyBase;
+    destination?: CurrencyBase;
+    slippageBps?: number;
+}
+export declare function buildSwapQuoteRequest({ amount, activeSide, source, destination, slippageBps, }: BuildSwapQuoteRequestProps): SwapQuoteRequest | null;
+export declare function isSameSwap(source: CurrencyBase | undefined, destination: CurrencyBase | undefined, inputWalletAddress?: string, outputWalletAddress?: string): boolean;
+export {};

package/dist/lib/quote.js

@@ -0,0 +1,24 @@
+import { currencyID } from "@coin-voyage/shared/types";
+export function toCurrencyBase(currency) {
+    return currency.address ? { chain_id: currency.chain_id, address: currency.address } : { chain_id: currency.chain_id };
+}
+export function buildSwapQuoteRequest({ amount, activeSide, source, destination, slippageBps, }) {
+    const numericAmount = Number(amount);
+    if (!source || !destination || !Number.isFinite(numericAmount) || numericAmount <= 0)
+        return null;
+    return {
+        trade_type: activeSide === "output" ? "EXACT_OUTPUT" : "EXACT_INPUT",
+        amount,
+        source: toCurrencyBase(source),
+        destination: toCurrencyBase(destination),
+        ...(slippageBps === undefined ? {} : { slippage_bps: slippageBps }),
+    };
+}
+export function isSameSwap(source, destination, inputWalletAddress, outputWalletAddress) {
+    return Boolean(source &&
+        destination &&
+        currencyID(source) === currencyID(destination) &&
+        inputWalletAddress &&
+        outputWalletAddress &&
+        inputWalletAddress.toLowerCase() === outputWalletAddress.toLowerCase());
+}

package/dist/lib/version.d.ts

@@ -0,0 +1 @@
+export declare const swapkitVersion: string;

package/dist/lib/version.js

@@ -0,0 +1,2 @@
+import packageJson from "../../package.json";
+export const swapkitVersion = packageJson.version;

package/dist/providers/swapkit-context.d.ts

@@ -0,0 +1,10 @@
+import type { ApiClient, APIEnvironment } from "@coin-voyage/shared/api";
+import type { SwapKitMode, SwapKitTheme } from "../types";
+export interface SwapKitContextValue {
+    api: ApiClient;
+    environment: APIEnvironment;
+    mode: SwapKitMode;
+    theme: Partial<SwapKitTheme>;
+}
+export declare const SwapKitContext: import("react").Context<SwapKitContextValue | null>;
+export declare function useSwapKit(): SwapKitContextValue;

package/dist/providers/swapkit-context.js

@@ -0,0 +1,8 @@
+import { createContext, useContext } from "react";
+export const SwapKitContext = createContext(null);
+export function useSwapKit() {
+    const context = useContext(SwapKitContext);
+    if (!context)
+        throw new Error("Swap must be used within SwapKitProvider");
+    return context;
+}

package/dist/providers/swapkit-provider.d.ts

@@ -0,0 +1,2 @@
+import type { SwapKitProviderProps } from "../types";
+export declare function SwapKitProvider({ apiKey, environment, mode, theme, children, }: SwapKitProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/swapkit-provider.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useInWagmiContext } from "@coin-voyage/crypto/evm";
+import { ApiClient } from "@coin-voyage/shared/api";
+import { generateSessionId } from "@coin-voyage/shared/utils";
+import { useMemo, useState } from "react";
+import { SwapKitContext } from "./swapkit-context";
+import { swapkitVersion } from "../lib/version";
+export function SwapKitProvider({ apiKey, environment = "production", mode = "auto", theme = {}, children, }) {
+    const inWalletContext = useInWagmiContext();
+    if (!inWalletContext)
+        throw new Error("SwapKitProvider must be used within a WalletProvider");
+    if (!apiKey.trim())
+        throw new Error("SwapKitProvider requires a public API key");
+    const [sessionId] = useState(generateSessionId);
+    const api = useMemo(() => new ApiClient({ apiKey, environment, sessionId, version: `swapkit/${swapkitVersion}` }), [apiKey, environment, sessionId]);
+    const context = useMemo(() => ({ api, environment, mode, theme }), [api, environment, mode, theme]);
+    return _jsx(SwapKitContext.Provider, { value: context, children: children });
+}