@shogun-sdk/swap 0.0.2-test.3 → 0.0.2-test.31

package/dist/index-CtZ-hgYk.d.cts

@@ -0,0 +1,394 @@
+import { ChainID, QuoteResponse, ChainOrderStatus, TokenSearchResponse as TokenSearchResponse$1, TokenSearchParams, ApiUserOrders, ApiCrossChainOrder, ApiSingleChainOrder, isEvmChain as isEvmChain$1 } from '@shogun-sdk/intents-sdk';
+import { A as AdaptedWallet } from './wallet-B9bKceyN.cjs';
+import { WalletClient } from 'viem';
+
+type ChainId$1 = ChainID;
+interface SupportedChain {
+    id: ChainId$1;
+    name: string;
+    isEVM: boolean;
+    wrapped: string;
+    symbol: string;
+    decimals: number;
+    tokenAddress: string;
+}
+
+/**
+ * Token metadata used in quotes.
+ * Provides address, decimals, and optional symbol.
+ */
+type QuoteTokenInfo = {
+    /** Token contract or mint address (EVM/Solana/Sui) */
+    address: string;
+    /** Number of decimals for precise conversion */
+    decimals: number;
+    /** Optional symbol (for display purposes only) */
+    symbol?: string;
+    chainId: number;
+};
+/**
+ * 🔧 SwapQuoteParams — input shape for requesting a swap quote.
+ *
+ * Works for both EVM and non-EVM chains (Solana, Sui, etc.).
+ */
+type SwapQuoteParams = {
+    /** Token you’re swapping *from* */
+    tokenIn: QuoteTokenInfo;
+    /** Token you’re swapping *to* */
+    tokenOut: QuoteTokenInfo;
+    /** The source chain ID — where the swap starts */
+    sourceChainId: ChainId$1;
+    /** The destination chain ID — where the swap ends */
+    destChainId: ChainId$1;
+    /** Input amount (smallest unit — wei, lamports, etc.) */
+    amount: string;
+    slippage?: number;
+};
+/**
+ * 💱 SwapQuoteResponse — output returned by `getQuote()`.
+ */
+type SwapQuoteResponse = {
+    /** Input token amount (smallest units, e.g. wei, lamports, etc.) */
+    amountIn: bigint;
+    /** Output token amount after routing/slippage (smallest units) */
+    amountOut: bigint;
+    /** Estimated USD value of output tokens */
+    amountOutUsd: number;
+    /** Estimated USD value of input tokens */
+    amountInUsd: number;
+    /** Minimum stablecoin equivalent for guaranteed slippage bounds */
+    minStablecoinsAmount: bigint;
+    /** Metadata for input token (includes decimals & chain ID) */
+    tokenIn: QuoteTokenInfo & {
+        chainId: ChainId$1;
+    };
+    /** Metadata for output token (includes decimals & chain ID) */
+    tokenOut: QuoteTokenInfo & {
+        chainId: ChainId$1;
+    };
+    /**
+     * Derived: how many tokenOut for 1 tokenIn (raw, 1e18 scaled bigint)
+     * Formula: (amountOut * 1e18) / amountIn
+     */
+    pricePerInputToken: bigint;
+    internal: QuoteResponse;
+    slippage: number;
+    warning?: string;
+};
+
+/**
+ * Types representing the structure of user orders and polling results.
+ */
+
+type OrderStatus = ChainOrderStatus | "Timeout" | "NotFound";
+type PollResult = OrderStatus;
+
+type Stage = 'processing' | 'approving' | 'approved' | 'signing' | 'submitting' | 'initiated' | 'shogun_processing' | 'success' | 'error';
+type PlaceOrderResult = {
+    status: boolean;
+    orderId: string;
+    chainId: number;
+    finalStatus: PollResult;
+    stage: Stage;
+} | {
+    status: boolean;
+    message: string;
+    stage: string;
+};
+interface MarketOrderOptions {
+    deadline?: number;
+}
+interface LimitOrderOptions {
+    executionPrice: string;
+    deadline: number;
+}
+type ExecuteOrderParams = {
+    orderType?: OrderExecutionType.MARKET;
+    options?: MarketOrderOptions;
+} | {
+    orderType?: OrderExecutionType.LIMIT;
+    options: LimitOrderOptions;
+};
+type ExtendedOrderParams = {
+    orderType?: OrderExecutionType;
+    options?: MarketOrderOptions | LimitOrderOptions;
+};
+
+interface BalanceRequestParams {
+    /** Object containing wallet addresses for supported chains. */
+    addresses: {
+        /** EVM-compatible wallet address (optional). */
+        evm?: string;
+        /** Solana wallet address (optional). */
+        svm?: string;
+    };
+    /** Optional pagination cursor for EVM balances. */
+    cursorEvm?: string;
+    /** Optional pagination cursor for Solana balances. */
+    cursorSvm?: string;
+}
+interface TokenBalance {
+    name: string;
+    symbol: string;
+    chainId: ChainID;
+    address: string;
+    balance: string;
+    balanceUsd: number;
+    decimals: number;
+    image?: string;
+    isNative: boolean;
+}
+interface BalanceResponse {
+    /** List of balances across networks. */
+    results: TokenBalance[];
+    /** Optional pagination cursors */
+    nextCursorEvm?: string;
+    nextCursorSvm?: string;
+}
+
+type TokenSearchResponse = TokenSearchResponse$1;
+type TokenInfo = {
+    address: string;
+    symbol: string;
+    name: string;
+    chainId: number;
+    decimals: number;
+    image?: string;
+    isVerified?: boolean;
+    priceUSD?: string;
+};
+
+declare function getTokensData(addresses: string[]): Promise<TokenInfo[]>;
+
+/**
+ * Configuration options for initializing the Swap SDK.
+ */
+type SwapSDKConfig = {
+    apiKey: string;
+};
+/**
+ * SwapSDK — Unified SDK for token discovery, quoting, and transaction execution.
+ *
+ * Features:
+ * - Retrieve real-time swap quotes across EVM and Solana.
+ * - Execute swaps using an adapted wallet or standard WalletClient.
+ * - Search verified tokens with pagination and query support.
+ * - Fetch balances across EVM and SVM chains.
+ *
+ * Designed to integrate easily with React hooks and Vue composables.
+ */
+declare class SwapSDK {
+    private readonly apiKey;
+    constructor(config: SwapSDKConfig);
+    /**
+     * Retrieves a swap quote for the given input and output tokens.
+     *
+     * @param params - Quote parameters including source/destination tokens and amount.
+     * @returns A normalized `SwapQuoteResponse` containing output amount, route, and metadata.
+     */
+    getQuote(params: SwapQuoteParams): Promise<SwapQuoteResponse>;
+    /**
+     * Fetches token balances for the specified user wallet(s).
+     *
+     * Supports both EVM and SVM (Solana) wallet addresses.
+     *
+     * @param params - Wallet address and optional chain filters.
+     * @param options - Optional abort signal for cancellation.
+     * @returns A unified balance response with per-chain token details.
+     */
+    getBalances(params: BalanceRequestParams, options?: {
+        signal?: AbortSignal;
+    }): Promise<BalanceResponse>;
+    /**
+     * Retrieves a list of verified tokens based on search query or chain filter.
+     *
+     * @param params - Search parameters (query, chain ID, pagination options).
+     * @returns Paginated `TokenSearchResponse` containing token metadata.
+     */
+    getTokenList(params: TokenSearchParams): Promise<TokenSearchResponse>;
+    /**
+     * Executes a prepared swap quote using the provided wallet and configuration.
+     *
+     * Handles:
+     * - Token approval (if required)
+     * - Transaction signing and broadcasting
+     * - Confirmation polling and stage-based status updates
+     *
+     * Supports both:
+     * - Market orders (with optional deadline)
+     * - Limit orders (requires executionPrice and deadline)
+     *
+     * @param quote - The swap quote to execute, containing route and metadata.
+     * @param accountAddress - The user's wallet address executing the swap.
+     * @param recipientAddress - Optional recipient address for the output tokens (defaults to sender).
+     * @param wallet - Adapted wallet instance (EVM/Solana) or a standard Viem `WalletClient`.
+     * @param onStatus - Optional callback for receiving execution stage updates and messages.
+     * @param orderType - Defines whether this is a market or limit order.
+     * @param options - Execution parameters (different per order type).
+     *
+     * @returns A finalized execution result containing transaction hash, status, and any returned data.
+     *
+     * @example
+     * ```ts
+     * * Market order
+     * const result = await sdk.executeTransaction({
+     *   quote,
+     *   accountAddress: "0x123...",
+     *   wallet,
+     *   orderType: OrderExecutionType.MARKET,
+     *   options: { deadline: 1800 },
+     *   onStatus: (stage, msg) => console.log(stage, msg),
+     * });
+     *
+     * * Limit order
+     * const result = await sdk.executeTransaction({
+     *   quote,
+     *   accountAddress: "0x123...",
+     *   wallet,
+     *   orderType: OrderExecutionType.LIMIT,
+     *   options: { executionPrice: "0.0021", deadline: 3600 },
+     * });
+     * ```
+     */
+    executeTransaction({ quote, accountAddress, recipientAddress, wallet, onStatus, orderType, options, }: {
+        quote: SwapQuoteResponse;
+        accountAddress: string;
+        recipientAddress: string;
+        wallet: AdaptedWallet | WalletClient;
+        onStatus?: (stage: Stage, message?: string) => void;
+    } & ExtendedOrderParams): Promise<{
+        status: boolean;
+        orderId: string;
+        chainId: number;
+        finalStatus: string;
+        stage: string;
+    } | {
+        status: boolean;
+        message: string;
+        stage: string;
+    }>;
+    /**
+     * Fetches metadata for one or more tokens from the Shogun Token Search API.
+     *
+     * ---
+     * ### Overview
+     * `getTokensData` retrieves normalized token information — such as symbol, name,
+     * decimals, logo URI, and verified status — for a given list of token addresses.
+     *
+     * It supports both **EVM** and **SVM (Solana)** tokens, returning metadata from
+     * Shogun’s unified token registry.
+     *
+     * ---
+     * @example
+     * ```ts
+     * const tokens = await getTokensData([
+     *   "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+     *   "So11111111111111111111111111111111111111112", // SOL
+     * ]);
+     *
+     * console.log(tokens);
+     * [
+     * { symbol: "USDC", name: "USD Coin", chainId: 1, decimals: 6, ... },
+     * { symbol: "SOL", name: "Solana", chainId: 101, decimals: 9, ... }
+     * ]
+     * ```
+     *
+     * @param addresses - An array of token addresses (EVM or SVM) to fetch metadata for.
+     * @returns A promise resolving to an array of {@link TokenInfo} objects.
+     *
+     * @throws Will throw an error if the network request fails or the API responds with a non-OK status.
+     */
+    getTokensData: typeof getTokensData;
+    /**
+ * Fetches all user orders (Market, Limit, Cross-chain) for connected wallets.
+ *
+ * ---
+ * ### Overview
+ * Retrieves both **single-chain** and **cross-chain** orders from the Shogun Intents API.
+ * Works across EVM, Solana
+ *
+ * ---
+ * @example
+ * ```ts
+ * const orders = await sdk.getOrders({
+ *   evmAddress: "0x123...",
+ *   solAddress: "9d12hF...abc",
+ * });
+ *
+ * console.log(orders.singleChainLimitOrders);
+ * ```
+ *
+ * @param params - Wallet addresses to fetch orders for (EVM, Solana).
+ * @returns A structured {@link ApiUserOrders} object containing all user orders.
+ */
+    getOrders(params: {
+        evmAddress?: string | null;
+        solAddress?: string | null;
+    }): Promise<ApiUserOrders>;
+    /**
+     * Cancels an order (single-chain or cross-chain) on EVM or Solana.
+     *
+     * Internally routes to the correct guard contract or Solana program to
+     * deactivate the order or invalidate its nonce.
+     *
+     * @param params.order - Order payload returned from the Intents API.
+     * @param params.wallet - Adapted wallet used to submit the cancellation transaction.
+     * @param params.solRpc - Solana RPC URL used for SVM cancellations.
+     *
+     * @returns A transaction signature or hash from the underlying wallet.
+     */
+    cancelOrder(params: {
+        order: ApiCrossChainOrder | ApiSingleChainOrder;
+        wallet: AdaptedWallet;
+        solRpc: string;
+    }): Promise<string>;
+}
+
+/**
+ * buildQuoteParams — Converts user-friendly input into normalized `SwapQuoteParams`.
+ *
+ * Converts human-readable token amount (like "100") into base units via `parseUnits`.
+ * Slippage should be passed as a percentage number (e.g., 1 = 1%, 10 = 10%).
+ */
+declare function buildQuoteParams({ tokenIn, tokenOut, sourceChainId, destChainId, amount, slippage, }: {
+    tokenIn: QuoteTokenInfo;
+    tokenOut: QuoteTokenInfo;
+    sourceChainId: ChainID;
+    destChainId: ChainID;
+    amount: string | number;
+    slippage?: number;
+}): SwapQuoteParams;
+
+declare enum OrderExecutionType {
+    LIMIT = "limit",
+    MARKET = "market"
+}
+
+/**
+ * Public filtered enum — exposes only currently supported chains.
+ *
+ */
+declare const ChainId: Partial<Record<"Arbitrum" | "Optimism" | "Base" | "Hyperliquid" | "BSC" | "Solana" | "Sui" | "MONAD", number>>;
+/**
+ * Public chains — only currently supported ones.
+ */
+declare const SupportedChains: ({
+    id: ChainID;
+    name: string;
+    isEVM: boolean;
+    wrapped: string;
+    symbol: string;
+    decimals: number;
+    tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+} | {
+    id: ChainID;
+    name: string;
+    isEVM: boolean;
+    wrapped: string;
+    symbol: string;
+    decimals: number;
+    tokenAddress: "So11111111111111111111111111111111111111111";
+})[];
+declare const isEvmChain: typeof isEvmChain$1;
+
+export { type BalanceRequestParams as B, ChainId as C, type ExecuteOrderParams as E, OrderExecutionType as O, type PlaceOrderResult as P, type SwapSDKConfig as S, type TokenInfo as T, SwapSDK as a, type SwapQuoteParams as b, type SwapQuoteResponse as c, type Stage as d, type BalanceResponse as e, buildQuoteParams as f, SupportedChains as g, type TokenBalance as h, isEvmChain as i, type SupportedChain as j };