@shogun-sdk/intents-sdk 1.2.31 → 1.4.0

package/dist/index.d.ts

@@ -0,0 +1,1654 @@
+import * as _solana_kit from '@solana/kit';
+import { Address, ReadonlyUint8Array, Instruction } from '@solana/kit';
+import * as _mysten_sui_transactions from '@mysten/sui/transactions';
+import { Transaction } from '@mysten/sui/transactions';
+import * as viem from 'viem';
+import { Address as Address$1, TypedDataDefinition, Hex } from 'viem';
+import { SuiClient } from '@mysten/sui/client';
+import { AddressLike, BigNumberish, ethers, BytesLike } from 'ethers';
+import { QuoteResponse as QuoteResponse$1 } from '@jup-ag/api';
+import { OptimalRate } from '@paraswap/sdk';
+import { RouterCompleteTradeRoute } from 'aftermath-ts-sdk';
+import * as bn_js from 'bn.js';
+import { PublicKey } from '@solana/web3.js';
+
+type TupleToUnion<ArrayType> = ArrayType extends readonly unknown[] ? ArrayType[number] : never;
+
+/**
+ * Represents the blockchain platform type
+ * Used to distinguish between different blockchain ecosystems
+ */
+declare enum ChainType {
+    EVM = "EVM",
+    Solana = "Solana",
+    Sui = "Sui"
+}
+/**
+ * Enum of chain IDs for supported blockchains
+ * EVM chains use their standard chain IDs
+ * Non-EVM chains use custom assigned IDs
+ */
+declare enum ChainID {
+    Arbitrum = 42161,
+    Optimism = 10,
+    Base = 8453,
+    Hyperliquid = 999,
+    Solana = 7565164,
+    Sui = 101,
+    BSC = 56,
+    MONAD = 143
+}
+/**
+ * Array of chain IDs that are supported by the SDK
+ * Used as a source of truth for type generation
+ */
+declare const SupportedChains: readonly [ChainID.Arbitrum, ChainID.Base, ChainID.Optimism, ChainID.Hyperliquid, ChainID.Solana, ChainID.Sui, ChainID.BSC, ChainID.MONAD];
+/**
+ * Type utility to identify chains not in the SupportedChains array
+ * @internal
+ */
+type UnsupportedChain = Exclude<ChainID, TupleToUnion<typeof SupportedChains>>;
+/**
+ * Type representing chains that are supported by the SDK
+ * Derived from the SupportedChains array
+ */
+type SupportedChain = Exclude<ChainID, UnsupportedChain>;
+type SupportedSolanaChain = 7565164;
+type SupportedSuiChain = 101;
+type SupportedEvmChain = Exclude<ChainID, SupportedSolanaChain | SupportedSuiChain>;
+declare function isEvmChain(chainId: ChainID): chainId is SupportedEvmChain;
+/**
+ * Type guard that checks if a chain ID is among the supported chains
+ * @param chain - The chain ID to check
+ * @returns Boolean indicating if the chain is supported
+ */
+declare const isSupportedChain: (chain: unknown) => chain is SupportedChain;
+/**
+ * Maps chain IDs to their corresponding chain types
+ * Used to determine which SDK implementation to use for a given chain
+ */
+declare const chainIdToChainTypeMap: {
+    readonly 42161: ChainType.EVM;
+    readonly 8453: ChainType.EVM;
+    readonly 10: ChainType.EVM;
+    readonly 999: ChainType.EVM;
+    readonly 7565164: ChainType.Solana;
+    readonly 101: ChainType.Sui;
+    readonly 56: ChainType.EVM;
+    readonly 143: ChainType.EVM;
+};
+
+declare enum IntentsOrderType {
+    CROSS_CHAIN_LIMIT = "CROSS_CHAIN_LIMIT",
+    SINGLE_CHAIN_LIMIT = "SINGLE_CHAIN_LIMIT"
+}
+declare const PERMIT2_ADDRESS: Record<SupportedEvmChain, Address$1>;
+declare const PROD_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, Address | Address$1>;
+declare const TEST_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, Address | Address$1>;
+declare const PROD_SINGLE_CHAIN_GUARD_ADDRESSES: Record<Exclude<ChainID, SupportedSuiChain>, Address | Address$1>;
+declare const TEST_SINGLE_CHAIN_GUARD_ADDRESSES: Record<Exclude<ChainID, SupportedSuiChain>, Address | Address$1>;
+declare const PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, Address$1>;
+declare const PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, Address$1>;
+declare const TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, Address$1>;
+declare const CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedChain, `0x${string}` | Address>;
+declare const SINGLE_CHAIN_GUARD_ADDRESSES: Record<ChainID.Arbitrum | ChainID.Optimism | ChainID.Base | ChainID.Hyperliquid | ChainID.Solana | ChainID.BSC | ChainID.MONAD, `0x${string}` | Address>;
+declare const DCA_SINGLE_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, `0x${string}`>;
+declare const DCA_CROSS_CHAIN_GUARD_ADDRESSES: Record<SupportedEvmChain, `0x${string}`>;
+declare const NATIVE_SOLANA_TOKEN_ADDRESS: Address<"So11111111111111111111111111111111111111111">;
+declare const WRAPPED_SOL_MINT_ADDRESS: Address<"So11111111111111111111111111111111111111112">;
+type SolanaMint = {
+    name: string;
+    mint: string;
+    decimals: number;
+};
+declare const SOLANA_USDC_MINT: SolanaMint;
+declare const SOLANA_MINT_TOKEN: SolanaMint;
+declare const PROD_SUI_PACKAGE_ID = "0x2c9b6a7a018f2f02663a1b2247e7e53d0bf832b30ab9534c49699a78a2f659f2";
+declare const TEST_SUI_PACKAGE_ID = "0x2c9b6a7a018f2f02663a1b2247e7e53d0bf832b30ab9534c49699a78a2f659f2";
+declare const SUI_PACKAGE_ID = "0x2c9b6a7a018f2f02663a1b2247e7e53d0bf832b30ab9534c49699a78a2f659f2";
+declare const SUI_GUARD_COLLATERAL_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
+declare const SUI_GUARD_STABLECOIN_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
+declare const AUCTIONEER_URL: string;
+declare const MAX_UINT_32: bigint;
+declare const MAX_UINT_64: bigint;
+declare const MAX_UINT_128: bigint;
+declare const MAX_UINT_256: bigint;
+declare const NATIVE_EVM_ETH_ADDRESSES: string[];
+declare const WRAPPED_ETH_ADDRESSES: Record<SupportedEvmChain, Address$1>;
+declare const NATIVE_SUI_TOKEN_ADDRESS = "0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI";
+declare function isNativeEvmToken(tokenAddress: string): boolean;
+declare const EVM_ZERO_ADDRESS: Address$1;
+/** Placeholder signature (32 zero bytes) for unsigned/validate-only intent requests. */
+declare const EVM_ZERO_SIGNATURE = "0x0000000000000000000000000000000000000000000000000000000000000000";
+/**
+ * Output-token addresses must be normalized to the zero address before signing the EIP-712
+ * witness: the auctioneer collapses any native sentinel (`0xeee…`/`0x0…`) to `Address::default()`
+ * when it reconstructs `requestedOutput`/`extraTransfers` to recover the signer. Signing the raw
+ * sentinel instead would yield a different hash → signature recovery fails. (`tokenIn` is NOT
+ * normalized on either side, so leave it untouched.)
+ */
+declare function normalizeNativeEvmTokenForSigning(tokenAddress: string): string;
+declare const TOKEN_SEARCH_API_BASE_URL = "https://shogun-token-search-api-825534211396.europe-west4.run.app";
+
+type StopLossType = 'FIXED' | 'TRAILING_ABSOLUTE' | 'TRAILING_PERCENT';
+type ExtraTransfer$1 = {
+    /** Token address */
+    token: string;
+    /** Receiver address */
+    receiver: string;
+    /** Amount of tokens to transfer */
+    amount: bigint;
+};
+
+type ChainOrderStatus = 'Auction' | 'NoBids' | 'Executing' | 'Fulfilled' | 'Cancelled' | 'Outdated' | 'DcaIntervalFulfilled';
+type ApiCrossChainOrder = {
+    orderId: string;
+    user: string;
+    srcChainId: number;
+    tokenIn: string;
+    minStablecoinsAmount: string;
+    destChainId: number;
+    tokenOut: string;
+    amountOutMin: string;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    executionDetailsHash: string;
+    amountIn: string;
+    executionDetails: string;
+    orderCreationTime: number;
+    orderStatus: ChainOrderStatus;
+    tokensInWereSwappedToStablecoins: boolean;
+    lockedStablecoins: string;
+    nonce?: string;
+    orderFulfillmentTimestamp?: number;
+    transactionHash?: string;
+    amountOut?: string;
+};
+type ApiSingleChainOrder = {
+    orderId: string;
+    user: string;
+    chainId: number;
+    tokenIn: string;
+    tokenOut: string;
+    amountOutMin: string;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    amountIn: string;
+    orderCreationTime: number;
+    orderStatus: ChainOrderStatus;
+    nonce?: string;
+    orderFulfillmentTimestamp?: number;
+    transactionHash?: string;
+    amountOut?: string;
+};
+type ApiUserOrders = {
+    singleChainLimitOrders: ApiSingleChainOrder[];
+    crossChainLimitOrders: ApiCrossChainOrder[];
+};
+/**
+ * Represents the response from an Intent API endpoint.
+ */
+interface ApiIntentResponse {
+    /** Unique identifier for the created intent */
+    intentId: string;
+    /**
+     * JWT token used for authorization or subsequent requests.
+     * Optional: order-creation responses only return `intentId`; obtain a JWT via the
+     * SIWE flow (`EVMSDK.authenticate()` / `fetchJWTToken`) instead.
+     */
+    jwt?: string;
+}
+type ValidResponseData = ApiUserOrders | string | ApiIntentResponse | null;
+type ApiResponse<T extends ValidResponseData = ValidResponseData> = {
+    success: boolean;
+    code: number;
+    data?: T;
+    error?: unknown;
+    extra_error_data?: unknown;
+};
+declare function isSuccessApiResponse<T extends ValidResponseData>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    success: true;
+    data: T;
+};
+declare function isErrorApiResponse<T extends ValidResponseData>(response: ApiResponse<T>): response is ApiResponse<T> & {
+    success: false;
+    error: unknown;
+};
+
+type CreateSingleChainOrderParams = {
+    chainId: SupportedChain;
+    amountIn: bigint;
+    tokenIn: string;
+    tokenOut: string;
+    amountOutMin?: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+    takeProfitMinOut?: bigint;
+};
+declare class SingleChainOrder {
+    user: string;
+    chainId: SupportedChain;
+    amountIn: bigint;
+    tokenIn: string;
+    tokenOut: string;
+    amountOutMin: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+    takeProfitMinOut?: bigint;
+    private constructor();
+    static create(input: CreateSingleChainOrderParams & {
+        user: string;
+    }): Promise<SingleChainOrder>;
+    private getRandomPreparedData;
+    private static calculateAmountOutMin;
+    private static getSingleChainOrderScenario;
+    toIntentRequest(preparedData: SingleChainPreparedData): SingleChainUserIntentRequest;
+    sendToAuctioneer(preparedData: SingleChainPreparedData): Promise<ApiResponse>;
+    toEVMTypedData(): Promise<{
+        orderTypedData: viem.TypedDataDefinition;
+        nonce: bigint;
+    }>;
+    toSolanaInstructionsByteArray(): Promise<SolanaOrderInstructionResult & {
+        secretNumber: string;
+    }>;
+    toSuiTransaction(secretHash: Uint8Array, guardAddress: string, client?: any): Promise<_mysten_sui_transactions.Transaction>;
+}
+
+/**
+ * Details required to execute the order on the destination chain
+ * Contains all information needed for the cross-chain fulfillment
+ */
+type ExecutionDetails = {
+    /** Chain ID where tokens will be received */
+    destChainId: SupportedChain;
+    /** Token address on the destination chain to receive */
+    tokenOut: string;
+    /** Minimum amount of destination tokens to receive, in smallest units */
+    amountOutMin: bigint;
+    /** Recipient wallet address on the destination chain */
+    destinationAddress: string;
+    /** Extra transfers to be made */
+    extraTransfers?: ExtraTransfer$1[];
+    /** Stop loss type, must match the auctioneer's `stopLossType` field */
+    stopLossType?: StopLossType;
+    /** Initial trigger price (tokenIn/tokenOut) that arms the stop loss */
+    stopLossTriggerPrice?: string;
+    /** Take profit minimum amount out */
+    takeProfitMinOut?: bigint;
+};
+type Hash = `0x${string}`;
+/** Hash of execution details, used to verify order integrity across chains */
+type ExecutionDetailsHash = Hash;
+type EvmPreparedData = {
+    /** Random nonce for Permit2 signature, prevents replay attacks */
+    nonce: string;
+    /** EIP-712 signature authorizing the order */
+    signature: string | Hash;
+};
+type SuiPreparedData = {
+    /** Transaction hash of the successful order creation transaction */
+    transactionHash: string;
+    /** Secret number for single-chain orders (optional for cross-chain) */
+    secretNumber?: string;
+};
+type SolanaPreparedData = {
+    /** Public key of the created order account on Solana */
+    orderPubkey: string;
+    /** Secret number for single-chain orders (optional for cross-chain) */
+    secretNumber?: string;
+};
+/**
+ * Source chain data sent to the auctioneer
+ * Contains all information needed to start the cross-chain swap from the source chain
+ */
+type SourceChainData = {
+    /** User's wallet address that initiated the order */
+    user: string;
+    /** Source chain ID where tokens will be sent from */
+    srcChainId: SupportedChain;
+    /** Token address on the source chain to be swapped */
+    tokenIn: string;
+    /** Amount of source tokens to swap, in smallest units */
+    amountIn: bigint;
+    /** Minimum amount of stablecoins in the intermediate swap, in smallest units */
+    minStablecoinsAmount: bigint;
+    /** Timestamp (in seconds) after which the order expires */
+    deadline: number;
+    /** Hash of execution details for cross-chain verification */
+    executionDetailsHash: ExecutionDetailsHash;
+    extraTransfers?: ExtraTransfer$1[];
+};
+type CrossChainUserIntentRequest = {
+    /** Generic data common to all chains */
+    genericData: SourceChainData;
+    /** JSON-stringified execution details for the destination chain */
+    executionDetails: string;
+    /** Chain-specific data including signatures and transaction details */
+    chainSpecificData: {
+        /** EVM-specific data (for Ethereum, Arbitrum, Optimism, Base) */
+        EVM?: EvmPreparedData;
+        /** Solana-specific data */
+        Solana?: SolanaPreparedData;
+        /** Sui-specific data */
+        Sui?: SuiPreparedData;
+    };
+};
+type SingleChainUserIntentRequest = {
+    genericData: SingleChainOrder;
+    chainSpecificData: {
+        EVM?: EvmPreparedData;
+        Solana?: SolanaPreparedData;
+        Sui?: SuiPreparedData;
+    };
+};
+/**
+ * Source chain data for a cross-chain DCA order. Mirrors the auctioneer's
+ * `CrossChainDcaOrderGenericRequestData` (common cross-chain fields + flattened
+ * `CommonDcaOrderData`). The destination fields live in `executionDetails`.
+ */
+type DcaCrossChainSourceChainData = {
+    user: string;
+    srcChainId: SupportedChain;
+    tokenIn: string;
+    minStablecoinsAmount: bigint;
+    deadline: number;
+    executionDetailsHash: ExecutionDetailsHash;
+    /** Flattened CommonDcaOrderData */
+    startTime: number;
+    amountInPerInterval: bigint;
+    totalIntervals: number;
+    intervalDuration: number;
+};
+type DcaCrossChainUserIntentRequest = {
+    genericData: DcaCrossChainSourceChainData;
+    /** JSON-stringified execution details for the destination chain */
+    executionDetails: string;
+    chainSpecificData: {
+        EVM?: DcaSingleChainEVMPreparedData;
+        Solana?: DcaSingleChainSolanaPreparedData;
+        Sui?: DcaSingleChainSuiPreparedData;
+    };
+};
+type ChainPreparedData = EvmPreparedData | SuiPreparedData | SolanaPreparedData;
+type CrossChainOrderPrepared = {
+    order: CrossChainOrder;
+    preparedData: ChainPreparedData;
+};
+type SingleChainEVMPreparedData = {
+    nonce: string;
+    signature: string | Hash;
+};
+type SingleChainSolanaPreparedData = {
+    secretNumber: string;
+    orderPubkey: string;
+};
+type SingleChainSuiPreparedData = {
+    transactionHash: string;
+    secretNumber: string;
+};
+type SingleChainPreparedData = SingleChainEVMPreparedData | SingleChainSolanaPreparedData | SingleChainSuiPreparedData;
+type SingleChainOrderPrepared = {
+    order: SingleChainOrder;
+    preparedData: SingleChainPreparedData;
+};
+type DcaSingleChainSuiPreparedData = {
+    transactionHash: string;
+    secretNumber: string;
+};
+type DcaSingleChainUserIntentRequest = {
+    genericData: DcaSingleChainOrder;
+    chainSpecificData: {
+        EVM?: DcaSingleChainEVMPreparedData;
+        Solana?: DcaSingleChainSolanaPreparedData;
+        Sui?: DcaSingleChainSuiPreparedData;
+    };
+};
+type DcaSingleChainEVMPreparedData = {
+    nonce: string;
+    signature: string | Hash;
+};
+type DcaSingleChainSolanaPreparedData = {
+    secretNumber: string;
+    orderPubkey: string;
+};
+type DcaSingleChainPreparedData = DcaSingleChainEVMPreparedData | DcaSingleChainSolanaPreparedData | DcaSingleChainSuiPreparedData;
+type DcaSingleChainOrderPrepared = {
+    order: DcaSingleChainOrder;
+    preparedData: DcaSingleChainPreparedData;
+};
+
+type CreateCrossChainOrderParams = {
+    /** Source chain ID where tokens will be sent from */
+    sourceChainId: SupportedChain;
+    /** Token address on the source chain to be swapped */
+    sourceTokenAddress: string;
+    /** Amount of source tokens to swap with decimals */
+    sourceTokenAmount: bigint;
+    /** Destination chain ID where tokens will be received */
+    destinationChainId: SupportedChain;
+    /** Token address on the destination chain to receive */
+    destinationTokenAddress: string;
+    /** Minimum amount of destination tokens to receive */
+    destinationTokenMinAmount?: bigint;
+    /** Recipient wallet address on the destination chain */
+    destinationAddress: string;
+    /** Minimum amount of stablecoins in the intermediate swap */
+    minStablecoinAmount?: bigint;
+    /** Timestamp (in seconds) after which the order expires */
+    deadline: number;
+    /** Extra transfers to be made */
+    extraTransfers?: ExtraTransfer$1[];
+    /** Stop loss */
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+    /** Take profit min out */
+    takeProfitMinOut?: bigint;
+};
+/**
+ * Represents a X-chain swap order
+ * Contains all the information needed to execute the order on both source and destination chains
+ */
+declare class CrossChainOrder {
+    /** User's wallet address that initiates the order */
+    user: string;
+    /** Source chain ID where tokens will be sent from */
+    sourceChainId: SupportedChain;
+    /** Token address on the source chain to be swapped */
+    sourceTokenAddress: string;
+    /** Amount of source tokens to swap */
+    sourceTokenAmount: bigint;
+    /** Destination chain ID where tokens will be received */
+    destinationChainId: SupportedChain;
+    /** Token address on the destination chain to receive */
+    destinationTokenAddress: string;
+    /** Minimum amount of destination tokens to receive */
+    destinationTokenMinAmount: bigint;
+    /** Recipient wallet address on the destination chain */
+    destinationAddress: string;
+    /** Minimum amount of stablecoins in the intermediate swap */
+    minStablecoinAmount: bigint;
+    /** Timestamp (in seconds) after which the order expires */
+    deadline: number;
+    /** Extra transfers to be made */
+    extraTransfers?: ExtraTransfer$1[];
+    /** Stop loss */
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+    /** Take profit min out */
+    takeProfitMinOut?: bigint;
+    private constructor();
+    /**
+     * Factory method to create and validate a new Order instance
+     * @param input Order parameters
+     * @returns Validated Order instance
+     * @throws {ValidationError} If order validation fails
+     */
+    static create(input: CreateCrossChainOrderParams & {
+        user: string;
+    }): Promise<CrossChainOrder>;
+    private getRandomPreparedData;
+    private static calculateAmountOutMin;
+    /**
+     * Gets the execution details for the destination chain
+     * These details are used to complete the order on the destination chain
+     * @returns Structured execution details object
+     */
+    getExecutionDetails(): ExecutionDetails;
+    executionDetailsHashToBytes(): Uint8Array;
+    /**
+     * Generates a cryptographic hash of the execution details
+     * This hash is used to verify order integrity across chains
+     * @returns SHA-256 hash of the execution details as a 0x-prefixed hex string
+     * @throws {ValidationError} If hash generation fails
+     */
+    getExecutionDetailsHash(): Hash;
+    toIntentRequest(preparedData: ChainPreparedData): CrossChainUserIntentRequest;
+    /**
+     * Converts the order to the format required for source chain processing
+     * Used when sending the order to the auctioneer for execution
+     * @returns Object containing source chain-specific data
+     */
+    toSourceChainData(): SourceChainData;
+    /**
+     * Serializes the order to a JSON-compatible object
+     * Converts bigint values to strings to ensure proper JSON serialization
+     * @returns JSON-serializable representation of the order
+     */
+    toJSON(): {
+        user: string;
+        sourceChainId: number;
+        sourceTokenAddress: string;
+        sourceTokenAmount: string;
+        destinationChainId: number;
+        destinationTokenAddress: string;
+        destinationTokenMinAmount: string;
+        destinationAddress: string;
+        minStablecoinAmount: string;
+        deadline: number;
+        executionDetailsHash: `0x${string}`;
+        extraTransfers: ExtraTransfer$1[] | undefined;
+    };
+    sendToAuctioneer(preparedData: ChainPreparedData): Promise<ApiResponse>;
+    toEVMTypedData(): Promise<{
+        orderTypedData: TypedDataDefinition;
+        nonce: bigint;
+    }>;
+    toSolanaInstructionsByteArray(): Promise<SolanaOrderInstructionResult>;
+    toSuiTransaction(client?: any): Promise<_mysten_sui_transactions.Transaction>;
+}
+
+type SolanaOrderInstructionResult = {
+    orderAddress: string;
+    txBytes: ReadonlyUint8Array;
+};
+declare function getSolanaSingleChainOrderInstructions(order: SingleChainOrder, options?: {
+    rpcUrl?: string;
+}): Promise<SolanaOrderInstructionResult & {
+    secretNumber: string;
+}>;
+declare function getSolanaCrossChainOrderInstructions(order: CrossChainOrder, options?: {
+    rpcUrl?: string;
+}): Promise<SolanaOrderInstructionResult>;
+
+type CreateDcaSingleChainOrderParams = {
+    chainId: SupportedChain;
+    tokenIn: string;
+    tokenOut: string;
+    destinationAddress: string;
+    startTime: number;
+    amountInPerInterval: bigint;
+    totalIntervals: number;
+    intervalDuration: number;
+    amountOutMin?: bigint;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+};
+declare class DcaSingleChainOrder {
+    user: string;
+    chainId: SupportedChain;
+    tokenIn: string;
+    tokenOut: string;
+    destinationAddress: string;
+    startTime: number;
+    amountInPerInterval: bigint | number;
+    totalIntervals: number;
+    intervalDuration: number;
+    amountOutMin: bigint | number;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    private constructor();
+    static create(input: CreateDcaSingleChainOrderParams & {
+        user: string;
+    }): Promise<DcaSingleChainOrder>;
+    private getRandomPreparedData;
+    getTotalAmountIn(): bigint;
+    toIntentRequest(preparedData: DcaSingleChainPreparedData): DcaSingleChainUserIntentRequest;
+    sendToAuctioneer(preparedData: DcaSingleChainPreparedData): Promise<ApiResponse>;
+    toEVMTypedData(): Promise<{
+        orderTypedData: viem.TypedDataDefinition;
+        nonce: bigint;
+    }>;
+    toSolanaInstructionsByteArray(): Promise<SolanaOrderInstructionResult & {
+        secretNumber: string;
+    }>;
+}
+
+type EVMConfig = {
+    chainId: SupportedEvmChain;
+    rpcProviderUrl?: string;
+    privateKey: `0x${string}`;
+};
+type SolanaConfig = {
+    rpcProviderUrl?: string;
+    privateKey: string;
+    /**
+     * Transaction confirmation level
+     * - 'confirmed': Transaction has been processed and confirmed by the cluster
+     * - 'finalized': Transaction has been finalized and cannot be rolled back
+     */
+    commitment: 'confirmed' | 'finalized';
+};
+type SuiConfig = {
+    privateKey: string;
+};
+
+/**
+ * Base SDK providing common functionality for all blockchain implementations
+ */
+declare abstract class BaseSDK {
+    abstract getUserAddress(): Promise<string>;
+    protected abstract prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared>;
+    protected prepareSingleChainOrder?(order: SingleChainOrder): Promise<SingleChainOrderPrepared>;
+    protected prepareDcaSingleChainOrder?(order: DcaSingleChainOrder): Promise<DcaSingleChainOrderPrepared>;
+    private static makeRequest;
+    private static validateOrder;
+    private static sendOrder;
+    createCrossChainOrder(params: CreateCrossChainOrderParams): Promise<CrossChainOrderPrepared>;
+    createAndSendCrossChainOrder(params: CreateCrossChainOrderParams): Promise<ApiResponse>;
+    static sendCrossChainOrder(preparedOrder: CrossChainOrderPrepared): Promise<ApiResponse>;
+    static validateCrossChainOrder(intentRequest: CrossChainUserIntentRequest): Promise<void>;
+    createSingleChainOrder(params: CreateSingleChainOrderParams): Promise<SingleChainOrderPrepared>;
+    createAndSendSingleChainOrder(params: CreateSingleChainOrderParams): Promise<ApiResponse>;
+    static sendSingleChainOrder(preparedOrder: SingleChainOrderPrepared): Promise<ApiResponse>;
+    static validateSingleChainOrder(intentRequest: SingleChainUserIntentRequest): Promise<void>;
+    createDcaSingleChainOrder(params: CreateDcaSingleChainOrderParams): Promise<DcaSingleChainOrderPrepared>;
+    createAndSendDcaSingleChainOrder(params: CreateDcaSingleChainOrderParams): Promise<ApiResponse>;
+    static sendDcaSingleChainOrder(preparedOrder: DcaSingleChainOrderPrepared): Promise<ApiResponse>;
+    static validateDcaSingleChainOrder(intentRequest: DcaSingleChainUserIntentRequest): Promise<void>;
+    static validateDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<void>;
+    static sendDcaCrossChainOrder(intentRequest: DcaCrossChainUserIntentRequest): Promise<ApiResponse>;
+}
+
+type CancelSingleChainOrderParams$1 = {
+    orderId: string;
+    user: string;
+    tokenIn: string;
+    amountIn: bigint;
+    requestedOutput: ExtraTransfer$1;
+    extraTransfers: ExtraTransfer$1[];
+    encodedExternalCallData: string;
+    deadline: number;
+    nonce: bigint;
+};
+type CancelCrossChainOrderParams$1 = {
+    orderId: string;
+    user: string;
+    tokenIn: string;
+    amountIn: bigint;
+    srcChainId: number;
+    deadline: number;
+    minStablecoinsAmount: bigint;
+    executionDetailsHash: string;
+    nonce: bigint;
+};
+/**
+ * Handles EVM-specific aspects of cross-chain swaps for Ethereum-compatible chains:
+ */
+declare class EVMSDK extends BaseSDK {
+    private readonly config;
+    private readonly evmIntentProvider;
+    constructor(config: EVMConfig);
+    cancelCrossChainOrder(params: CancelCrossChainOrderParams$1): Promise<string>;
+    cancelSingleChainOrder(params: CancelSingleChainOrderParams$1): Promise<string>;
+    authenticate(token?: string): Promise<string>;
+    /**
+     * Gets the user's Ethereum address derived from their private key
+     * @returns Promise resolving to the user's Ethereum address as a 0x-prefixed string
+     */
+    getUserAddress(): Promise<string>;
+    protected approveAllowanceIfNeeded(tokenAddress: Address$1, amount: bigint): Promise<void>;
+    /**
+     * Prepares an EVM order for submission
+     *
+     * This method:
+     * 1. Validates token balances and allowances
+     * 2. Creates and signs the EIP-712 typed data for Permit2
+     * 3. Prepares the order for submission to the auctioneer
+     *
+     * @param order The validated order to prepare
+     * @returns Promise resolving to a prepared order with EVM-specific signature data
+     */
+    protected prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared>;
+    protected prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared>;
+    protected prepareDcaSingleChainOrder(order: DcaSingleChainOrder): Promise<DcaSingleChainOrderPrepared>;
+}
+
+/**
+ * Solana-specific SDK implementation
+ *
+ * Handles Solana-specific aspects of cross-chain swaps using Solana blockchain.
+ * Uses @solana/kit for transaction creation, signing, and submission.
+ * Supports cross-chain swaps from Solana to other supported chains.
+ */
+declare class SolanaSDK extends BaseSDK {
+    /** Configuration for Solana connection and authentication */
+    private readonly config;
+    /** Client for Solana RPC interactions and transaction handling */
+    private client;
+    /**
+     * Creates a new instance of the Solana SDK
+     *
+     * @param config Solana configuration including privateKey, commitment level, and optional RPC URL
+     */
+    constructor(config: SolanaConfig);
+    /**
+     * Gets the user's Solana wallet address derived from their private key
+     *
+     * Uses @solana/kit to securely derive the wallet address from the private key
+     *
+     * @returns Promise resolving to the user's Solana address as a Base58-encoded string
+     * @throws {SolanaError} If address derivation fails
+     */
+    getUserAddress(): Promise<string>;
+    cancelCrossChainOrder(orderId: string): Promise<string>;
+    cancelSingleChainOrder(orderId: string): Promise<string>;
+    /**
+     * Creates a CryptoKeyPair from the user's private key
+     *
+     * Converts the Base58-encoded private key to the format required by WebCrypto API
+     *
+     * @returns Promise resolving to a CryptoKeyPair for transaction signing
+     * @private
+     */
+    private getUserCryptoKeypair;
+    /**
+     * Creates a KeyPairSigner from the user's crypto keypair
+     *
+     * The KeyPairSigner is used for transaction signing and verification
+     *
+     * @returns Promise resolving to a KeyPairSigner for transaction operations
+     * @private
+     */
+    private getUserSigner;
+    authenticate(token?: string): Promise<string>;
+    /**
+     * Prepares a Solana order for submission
+     *
+     * This method:
+     * 1. Gets the user's signer from their private key
+     * 2. Generates Solana-specific instructions for the order
+     * 3. Creates, signs, and submits the transaction to the Solana blockchain
+     * 4. Returns the prepared order with the orderPubkey for tracking
+     *
+     * @param order The validated order to prepare
+     * @returns Promise resolving to a prepared order with Solana-specific data
+     * @protected
+     */
+    protected prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared>;
+    protected prepareSingleChainOrder(order: SingleChainOrder): Promise<SingleChainOrderPrepared>;
+    cancelDcaSingleChainOrder(orderId: string): Promise<string>;
+    protected prepareDcaSingleChainOrder(order: DcaSingleChainOrder): Promise<DcaSingleChainOrderPrepared>;
+}
+
+/**
+ * Sui-specific SDK implementation
+ *
+ * Handles Sui-specific aspects of cross-chain swaps using the Sui blockchain.
+ * Uses @mysten/sui libraries for transaction creation, signing, and submission.
+ * Supports cross-chain swaps from Sui to other supported chains.
+ */
+declare class SuiSDK extends BaseSDK {
+    /** Configuration for Sui connection and authentication */
+    private readonly config;
+    /** Client for Sui RPC interactions and transaction handling */
+    private client;
+    /**
+     * Creates a new instance of the Sui SDK
+     *
+     * @param config Sui configuration including privateKey and optional RPC URL
+     */
+    constructor(config: SuiConfig);
+    /**
+     * Gets the user's Sui wallet address derived from their private key
+     *
+     * Uses Ed25519Keypair to securely derive the wallet address from the private key
+     *
+     * @returns Promise resolving to the user's Sui address as a hex string
+     */
+    getUserAddress(): Promise<string>;
+    /**
+     * Creates an Ed25519Keypair from the user's private key
+     *
+     * The keypair is used for transaction signing and address derivation
+     *
+     * @returns Ed25519Keypair for cryptographic operations
+     * @private
+     */
+    private getKeyPair;
+    authenticate(token?: string): Promise<string>;
+    /**
+     * Prepares a Sui order for submission
+     *
+     * This method:
+     * 1. Gets the user's keypair from their private key
+     * 2. Generates Sui-specific transaction for the order
+     * 3. Signs and executes the transaction on the Sui blockchain
+     * 4. Returns the prepared order with the transaction hash for tracking
+     *
+     * @param order The validated order to prepare
+     * @returns Promise resolving to a prepared order with Sui-specific data
+     * @protected
+     */
+    protected prepareCrossChainOrder(order: CrossChainOrder): Promise<CrossChainOrderPrepared>;
+    cancelCrossChainOrder(orderId: string): Promise<string>;
+}
+
+/**
+ * Parameters for {@link fetchUserOrders}.
+ *
+ * The auctioneer resolves the wallets to query from the JWT claims and/or the `wallet`
+ * address, so at least one of `token`/`wallet` must be provided. `network` optionally
+ * restricts the results to a single chain.
+ */
+interface FetchUserOrdersParams {
+    /**
+     * SIWE-issued JWT. Optional while the auctioneer skips JWT verification — when present,
+     * its wallet claims are queried in addition to `wallet`. Obtain it with
+     * `EVMSDK.authenticate()` (or the `fetchSiweMessage` + `fetchJWTToken` pair).
+     */
+    token?: string;
+    /** Wallet address to query. Required when no `token` is supplied. */
+    wallet?: string;
+    /** Restrict results to a single chain; omit to return orders on every network. */
+    network?: SupportedChain;
+}
+/**
+ * Fetches the orders owned by a wallet (and/or the wallets encoded in a SIWE-issued JWT).
+ *
+ * ⚠️ The auctioneer currently skips JWT verification, so the queried wallet may be passed
+ * directly via `wallet`. Once verification is restored, only wallets proved via SIWE (i.e.
+ * carried by a valid `token`) will be readable.
+ */
+declare function fetchUserOrders({ token, wallet, network }: FetchUserOrdersParams): Promise<ApiUserOrders>;
+
+/**
+ * Query filters for `GET /user_intent`.
+ *
+ * The auctioneer resolves the wallets to query from the (currently unvalidated) JWT claims
+ * and/or the `wallet` param; at least one source must be present. `network` optionally
+ * restricts results to a single chain — omit it to return orders on every network.
+ */
+interface GetUserOrdersParams {
+    /** Wallet address to query. Combined with any wallet(s) carried by the JWT claims. */
+    wallet?: string;
+    /** Restrict results to a single chain. Serialized as its chain id (e.g. 8453). */
+    network?: SupportedChain;
+}
+declare class AuctioneerAPI {
+    aggregatedToken?: string;
+    constructor(aggregatedToken?: string);
+    extend(token: string): void;
+    getUserOrders(params?: GetUserOrdersParams): Promise<ApiUserOrders>;
+}
+
+type FetchSiweMessageParams = {
+    wallet: string;
+    chainId: ChainID;
+};
+type FetchJWTParams = {
+    message: string;
+    signature: string;
+};
+declare function fetchSiweMessage(params: FetchSiweMessageParams): Promise<ApiResponse<string>>;
+declare function fetchJWTToken(params: FetchJWTParams, token?: string): Promise<ApiResponse<string>>;
+
+declare class BaseError extends Error {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+    toJSON(): Record<string, unknown>;
+    private formatCause;
+}
+declare class ValidationError extends BaseError {
+    constructor(message: string, cause?: unknown);
+}
+
+/**
+ * Response structure from DefiLlama API for token prices
+ */
+interface DefiLlamaTokensResponse {
+    coins: Record<string, DefiLlamaCoinData>;
+}
+/**
+ * Individual token data from DefiLlama API
+ */
+interface DefiLlamaCoinData {
+    /** Number of decimal places for the token */
+    decimals: number;
+    /** Token symbol (e.g., "ETH", "USDC") */
+    symbol: string;
+    /** Current price in USD */
+    price: number;
+    /** Unix timestamp of the price data */
+    timestamp: number;
+    /** Confidence level of the price data (0-1) */
+    confidence: number;
+}
+/**
+ * Retrieves token data from DefiLlama response by chain and address
+ */
+declare const getCoinFromResponse: (response: DefiLlamaTokensResponse, chainId: ChainID, tokenAddress: string) => DefiLlamaCoinData;
+/**
+ * Fetch tokens data for array of coins
+ *
+ * @param tokens Array of [ChainID, Token Address] tuples
+ * @returns Promise resolving to DefiLlama tokens response
+ */
+declare function getTokensData(tokens: Array<[ChainID, string]>): Promise<DefiLlamaTokensResponse>;
+declare function calculateAmounts({ srcChainId, tokenIn, amountIn, destChainId, tokenOut, }: {
+    srcChainId: SupportedChain;
+    tokenIn: string;
+    amountIn: bigint;
+    destChainId: SupportedChain;
+    tokenOut: string;
+}): Promise<{
+    amountOut: bigint;
+    minStablecoinsAmount: bigint;
+}>;
+
+type CancelSingleChainOrderParams = {
+    orderId: string;
+    user: string;
+    tokenIn: string;
+    amountIn: bigint;
+    requestedOutput: ExtraTransfer$1;
+    extraTransfers: ExtraTransfer$1[];
+    encodedExternalCallData: string;
+    deadline: number;
+    nonce: bigint;
+};
+type CancelCrossChainOrderParams = {
+    orderId: string;
+    user: string;
+    tokenIn: string;
+    amountIn: bigint;
+    srcChainId: number;
+    deadline: number;
+    minStablecoinsAmount: bigint;
+    executionDetailsHash: string;
+    nonce: bigint;
+};
+declare function getCancelCrossChainOrderRawData(params: CancelCrossChainOrderParams): Hex;
+declare function getCancelSingleChainOrderRawData(params: CancelSingleChainOrderParams): Hex;
+declare function getInvalidateNoncesRawData(nonce: bigint): Hex;
+
+declare function cancelDcaSingleChainOrderInstructions(orderAddress: string, options?: {
+    rpcUrl?: string;
+}): Promise<Instruction[]>;
+
+declare function getEVMSingleChainOrderTypedData(order: SingleChainOrder): Promise<{
+    orderTypedData: TypedDataDefinition;
+    nonce: bigint;
+}>;
+/**
+ * Generates typed data for EVM order signatures
+ * @param order The order to generate typed data for
+ * @returns Object containing the typed data and nonce
+ */
+declare function getEVMCrossChainOrderTypedData(order: CrossChainOrder): Promise<{
+    orderTypedData: TypedDataDefinition;
+    nonce: bigint;
+}>;
+
+/**
+ * Inspect Solana guards to find orders that are currently locked on-chain.
+ * @param userAddress - The user's Solana address
+ * @param config - The Solana RPC configuration
+ * @returns An object containing the Solana guard programs for cross-chain and single-chain orders
+ */
+declare function getSolanaOrdersWithLockedFunds(userAddress: string, config?: {
+    rpcUrl?: string;
+}): Promise<{
+    crossChainGuardPrograms: {
+        pubkey: _solana_kit.Address;
+    }[];
+}>;
+
+declare function cancelCrossChainOrderInstructionsAsBytes(orderAddress: string, signerAddress: string, options?: {
+    rpcUrl?: string;
+}): Promise<{
+    versionedMessageBytes: ReadonlyUint8Array;
+}>;
+declare function cancelSingleChainOrderInstructionsAsBytes(orderAddress: string, signerAddress: string, options?: {
+    rpcUrl?: string;
+}): Promise<{
+    versionedMessageBytes: ReadonlyUint8Array;
+}>;
+
+declare const createSuiClient: () => SuiClient;
+
+/**
+ * Generates Sui order transaction for creating an order
+ * @param order The order to generate transaction for
+ * @param client The Sui client instance (optional, creates new if not provided)
+ * @returns Object containing the transaction
+ */
+declare function getSuiOrderTransaction(order: CrossChainOrder, client?: ReturnType<typeof createSuiClient>): Promise<Transaction>;
+
+declare function getSuiCancelCrossChainOrder(orderId: string): Promise<Transaction>;
+
+/**
+ * Generates secret hash based on types, addresses and secret number for single chain DCA orders
+ * @param coinOutType Type tag of Coin OUT
+ * @param receiver Main Coins OUT receiver
+ * @param secretNumber Secret number, for hash randomness
+ * @param extraTransferCoinOut Type tag of extra transfer coin OUT
+ * @param extraTransferReceiver Receiver of extra transfer
+ */
+declare function getDcaSecretHash(coinOutType: string, receiver: string, secretNumber: string, extraTransferCoinOut?: string, extraTransferReceiver?: string): number[];
+/**
+ * Generates Sui single-chain DCA order transaction
+ * @param order The DCA order to generate transaction for
+ * @param secretHash The secret hash for the order
+ * @param guardAddress The guard contract address
+ * @param client The Sui client instance
+ * @returns Transaction object for creating the DCA order
+ */
+declare function getSuiSingleChainDcaOrderTransaction(order: DcaSingleChainOrder, secretHash: Uint8Array, guardAddress: string, client?: ReturnType<typeof createSuiClient>): Promise<Transaction>;
+
+/**
+ * Generates random U64 number
+ */
+declare function getRandomU64Number(): string;
+/**
+ * Generates secret hash based on types, addresses and secret number for single chain limit orders
+ * @param coinOutType Type tag of Coin OUT
+ * @param receiver Main Coins OUT receiver
+ * @param secretNumber Secret number, for hash randomness
+ * @param extraTransferCoinOut Type tag of extra transfer coin OUT
+ * @param extraTransferReceiver Receiver of extra transfer
+ */
+declare function getSecretHash(coinOutType: string, receiver: string, secretNumber: string, extraTransferCoinOut?: string, extraTransferReceiver?: string): number[];
+/**
+ * Generates Sui single-chain limit order transaction
+ * @param order The single-chain order to generate transaction for
+ * @param secretHash The secret hash for the order
+ * @param guardAddress The guard contract address
+ * @param client The Sui client instance
+ * @returns Transaction object for creating the limit order
+ */
+declare function getSuiSingleChainLimitOrderTransaction(order: SingleChainOrder, secretHash: Uint8Array, guardAddress: string, client?: ReturnType<typeof createSuiClient>): Promise<Transaction>;
+
+/**
+ * Computes the SHA-256 hash the auctioneer expects for cross-chain execution details.
+ *
+ * The auctioneer recomputes sha256 over the exact `executionDetails` JSON string it
+ * receives and rejects the order when it differs (hash mismatch). Callers therefore MUST
+ * hash the same serialized string they send on the wire — pass that string here directly
+ * instead of re-serializing a parallel object, which is how key-order/field drift creeps in.
+ */
+declare function generateExecutionDetailsHash(executionDetails: string): string;
+
+type CreateSuiSingleChainLimitOrderIntentParams = {
+    user: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    amountOutMin: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    transactionHash: string;
+    secretNumber?: string;
+    takeProfitMinOut?: bigint;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+};
+type CreateSuiSingleChainDcaOrderIntentParams = {
+    user: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountInPerInterval: bigint;
+    totalIntervals: number;
+    intervalDuration: number;
+    amountOutMin: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    startTime: number;
+    transactionHash: string;
+    secretNumber?: string;
+};
+type CreateSuiCrossChainOrderIntentParams = {
+    user: string;
+    srcChainId: number;
+    tokenIn: string;
+    amountIn: bigint;
+    minStablecoinsAmount: bigint;
+    deadline: number;
+    destChainId: number;
+    destinationAddress: string;
+    tokenOut: string;
+    amountOutMin: bigint;
+    transactionHash: string;
+    takeProfitMinOut?: bigint;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+    extraTransfers?: ExtraTransfer$1[];
+};
+/**
+ * Creates a Sui single-chain limit order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createSuiSingleChainLimitOrderIntentRequest(params: CreateSuiSingleChainLimitOrderIntentParams): SingleChainUserIntentRequest;
+/**
+ * Creates a Sui single-chain DCA order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createSuiSingleChainDcaOrderIntentRequest(params: CreateSuiSingleChainDcaOrderIntentParams): DcaSingleChainUserIntentRequest;
+/**
+ * Creates a Sui cross-chain order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createSuiCrossChainOrderIntentRequest(params: CreateSuiCrossChainOrderIntentParams): CrossChainUserIntentRequest;
+/**
+ * Generates secret hash for Sui single-chain limit orders
+ * @param tokenOut Output token address
+ * @param receiver Receiver address
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and secret hash
+ */
+declare function generateSuiLimitOrderSecretData(tokenOut: string, receiver: string, secretNumber?: string, extraTransfers?: ExtraTransfer$1[]): {
+    secretNumber: string;
+    secretHash: Uint8Array;
+};
+/**
+ * Generates secret hash for Sui single-chain DCA orders
+ * @param tokenOut Output token address
+ * @param receiver Receiver address
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and secret hash
+ */
+declare function generateSuiDcaOrderSecretData(tokenOut: string, receiver: string, secretNumber?: string, extraTransfers?: ExtraTransfer$1[]): {
+    secretNumber: string;
+    secretHash: Uint8Array;
+};
+
+declare function getSolanaDcaSingleChainOrderInstructions(order: DcaSingleChainOrder, options?: {
+    rpcUrl?: string;
+}): Promise<SolanaOrderInstructionResult & {
+    secretNumber: string;
+}>;
+
+type TransferDataStruct = {
+    token: AddressLike;
+    receiver: AddressLike;
+    amount: BigNumberish;
+};
+
+type SingleChainDcaOrderStruct = {
+    user: AddressLike;
+    tokenIn: AddressLike;
+    startTime: BigNumberish;
+    amountInPerInterval: BigNumberish;
+    totalIntervals: BigNumberish;
+    intervalDuration: BigNumberish;
+    requestedOutput: TransferDataStruct;
+    extraTransfers: TransferDataStruct[];
+    encodedExternalCallData: BytesLike;
+    deadline: BigNumberish;
+    nonce: BigNumberish;
+};
+/**
+ * Signs Permit2 struct with SingleChainDcaOrder
+ */
+declare function signSingleChainDcaOrder(signer: ethers.Wallet, order: SingleChainDcaOrderStruct, chainId: number, guardAddress: string, permit2Address: string): Promise<{
+    domain: any;
+    types: any;
+    values: any;
+    signature: string;
+}>;
+
+type SingleChainLimitOrderStruct = {
+    user: AddressLike;
+    tokenIn: AddressLike;
+    amountIn: BigNumberish;
+    requestedOutput: TransferDataStruct;
+    extraTransfers: TransferDataStruct[];
+    encodedExternalCallData: BytesLike;
+    deadline: BigNumberish;
+    nonce: BigNumberish;
+};
+/**
+ * Signs Permit2 struct with SingleChainLimitOrder
+ */
+declare function signSingleChainLimitOrder(signer: ethers.Wallet, order: SingleChainLimitOrderStruct, chainId: number, guardAddress: string, permit2Address: string): Promise<{
+    domain: any;
+    types: any;
+    values: any;
+    signature: string;
+}>;
+
+type RelayQuoteResult = {
+    amountOut: bigint;
+    amountIn: bigint;
+    amountOutUsd: number;
+    amountInUsd: number;
+    slippage: number;
+    priceImpact: number;
+    quote: any;
+};
+
+type SwapEstimateResult = {
+    amountOut: bigint;
+    amountIn: bigint;
+    amountOutUsd: number;
+    amountInUsd: number;
+    quote: OptimalRate;
+};
+
+type LiquidSwapQuoteResponse = {
+    success: boolean;
+    amountIn: string;
+    amountOut: string;
+    averagePriceImpact: string;
+    execution: any;
+};
+
+type SingleChainQuoteParams = {
+    chainId: ChainID;
+    amount: bigint;
+    tokenIn: string;
+    tokenOut: string;
+    slippageBps?: number;
+    provider?: RouteProvider;
+};
+type RouteProvider = 'paraswap' | 'jupiter' | 'aftermath' | 'liquidswap' | 'raydium' | 'pumpfun' | 'relay';
+type Quote = {
+    amountIn: bigint;
+    amountOut: bigint;
+    amountOutMin?: bigint;
+    amountOutUsd: number;
+    amountInUsd: number;
+    slippage: number;
+    priceImpact: number;
+    provider: RouteProvider;
+    rawQuote: any;
+};
+type IntentsQuoteParams = {
+    sourceChainId: ChainID;
+    destChainId: ChainID;
+    amount: bigint;
+    tokenIn: string;
+    tokenOut: string;
+};
+type QuoteResponseInternal = {
+    amountInUsd: number;
+    estimatedAmountInAsMinStablecoinAmount: bigint;
+    estimatedAmountOut: bigint;
+    estimatedAmountOutUsd: number;
+    estimatedAmountOutReduced: bigint;
+    estimatedAmountOutUsdReduced: number;
+};
+type QuoteResponse = QuoteResponseInternal & {
+    /** Metadata for source token */
+    tokenIn: {
+        address: string;
+        chainId: ChainID;
+    };
+    /** Metadata for destination token */
+    tokenOut: {
+        address: string;
+        chainId: ChainID;
+    };
+};
+declare class QuoteProvider {
+    static getQuote(params: IntentsQuoteParams): Promise<QuoteResponse>;
+    /**
+     * Get a quote for Solana with explicit provider selection
+     * @param params - Quote parameters including provider preference
+     * @returns Quote response
+     */
+    static getSolanaQuote(params: {
+        amount: bigint;
+        tokenIn: string;
+        tokenOut: string;
+        slippageBps?: number;
+        provider?: 'jupiter' | 'raydium' | 'pumpfun';
+    }): Promise<Quote>;
+    private static getQuoteFromRouters;
+    static getSingleChainQuote(params: SingleChainQuoteParams): Promise<Quote>;
+    static transformLiquidSwapQuote(liquidSwapQuote: LiquidSwapQuoteResponse): Quote;
+    /**
+     * Calculates the weighted reduction factor for an amount in USD.
+     * For amounts <= $5, the reduction factor is 0.65.
+     */
+    static calculateWeightedReductionFactorForUsd(amountUsd: number): number;
+    protected static getLiquidSwapQuote(params: SingleChainQuoteParams): Promise<LiquidSwapQuoteResponse>;
+    protected static getJupiterQuote(params: SingleChainQuoteParams): Promise<{
+        quote: QuoteResponse$1;
+    }>;
+    protected static getParaswapQuote(params: SingleChainQuoteParams): Promise<SwapEstimateResult>;
+    protected static getRelayQuote(params: SingleChainQuoteParams): Promise<RelayQuoteResult>;
+    protected static getAftermathQuote(params: SingleChainQuoteParams): Promise<RouterCompleteTradeRoute>;
+    protected static getRaydiumQuote(params: SingleChainQuoteParams): Promise<Quote>;
+    protected static getPumpFunQuote(params: SingleChainQuoteParams): Promise<Quote>;
+    private static transformAftermathQuote;
+    private static transformParaswapQuote;
+    private static transformRelayQuote;
+    static transformJupiterQuote({ quote }: {
+        quote: QuoteResponse$1;
+    }): Quote;
+    private static transformRaydiumQuote;
+}
+
+type ExtraTransfer = {
+    token: PublicKey;
+    receiver: PublicKey;
+    amount: string;
+};
+/**
+ * Generate secret number and prepare secret hash for single chain limit orders
+ * @param tokenOut Token OUT Pubkey
+ * @param receiver Token OUT receiver Pubkey
+ * @param extraTransfers Requested extra transfers
+ */
+declare function prepareSecretData(tokenOut: PublicKey, receiver: PublicKey, extraTransfers: ExtraTransfer[]): {
+    secretHash: number[];
+    secretNumber: bn_js;
+};
+
+/**
+ * Generate secret number and prepare secret hash for single chain DCA orders
+ * @param tokenOut Token OUT Pubkey
+ * @param receiver Token OUT receiver Pubkey
+ * @param extraTransfers Requested extra transfers
+ */
+declare function prepareDcaSecretData(tokenOut: PublicKey, receiver: PublicKey, extraTransfers: ExtraTransfer[]): {
+    secretHash: number[];
+    secretNumber: bn_js;
+};
+
+interface TokenSearchParams {
+    /** Optional: search phrase (symbol, token name, or address) */
+    q?: string;
+    /** Optional: Chain ID filter (e.g. 8453 = Base, 42161 = Arbitrum, 7565164 = Solana, 101 = Sui) */
+    networkId?: number;
+    /** Optional: page number for pagination (default = 1) */
+    page?: number;
+    /** Optional: number of results per page (default = 20) */
+    limit?: number;
+    /** Optional: Abort signal to cancel requests (useful in UI search inputs) */
+    signal?: AbortSignal;
+}
+/** Normalized token shape returned by the API */
+interface TokenInfo {
+    address: string;
+    symbol: string;
+    name: string;
+    chainId: number;
+    decimals: number;
+    image?: string;
+    isVerified?: boolean;
+}
+/** Paginated API response */
+interface TokenSearchResponse {
+    count: number;
+    page: number;
+    limit: number;
+    results: TokenInfo[];
+}
+
+/**
+ * getTokenList
+ *
+ * High-level SDK function for token discovery.
+ * Supports cancellation via AbortController.
+ *
+ * Example:
+ * ```ts
+ * import { getTokenList } from "@shogun/sdk";
+ *
+ * const controller = new AbortController();
+ * const res = await getTokenList({ q: "usdc", networkId: 8453, signal: controller.signal });
+ *
+ * To cancel:
+ * controller.abort();
+ * ```
+ */
+declare function getTokenList(params: TokenSearchParams): Promise<TokenSearchResponse>;
+
+type CreateEvmSingleChainLimitOrderIntentParams = {
+    user: `0x${string}`;
+    chainId: SupportedEvmChain;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    amountOutMin: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    nonce?: string;
+    signature?: string;
+    takeProfitMinOut?: bigint;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+};
+type CreateEvmSingleChainDcaOrderIntentParams = {
+    user: `0x${string}`;
+    chainId: SupportedEvmChain;
+    tokenIn: string;
+    tokenOut: string;
+    amountInPerInterval: bigint;
+    totalIntervals: number;
+    intervalDuration: number;
+    amountOutMin: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    startTime: number;
+    nonce?: string;
+    signature?: string;
+};
+type CreateEvmCrossChainOrderIntentParams = {
+    user: `0x${string}`;
+    sourceChainId: SupportedEvmChain;
+    sourceTokenAddress: string;
+    sourceTokenAmount: bigint;
+    destinationChainId: number;
+    destinationTokenAddress: string;
+    destinationTokenMinAmount?: bigint;
+    destinationAddress: string;
+    minStablecoinAmount?: bigint;
+    deadline: number;
+    extraTransfers?: ExtraTransfer$1[];
+    nonce?: string;
+    signature?: string;
+    takeProfitMinOut?: bigint;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+};
+/**
+ * Creates an EVM single-chain limit order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createEvmSingleChainLimitOrderIntentRequest(params: CreateEvmSingleChainLimitOrderIntentParams): SingleChainUserIntentRequest;
+/**
+ * Creates an EVM single-chain DCA order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createEvmSingleChainDcaOrderIntentRequest(params: CreateEvmSingleChainDcaOrderIntentParams): DcaSingleChainUserIntentRequest;
+/**
+ * Creates an EVM cross-chain order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createEvmCrossChainOrderIntentRequest(params: CreateEvmCrossChainOrderIntentParams): CrossChainUserIntentRequest;
+/**
+ * Generates EVM typed data and nonce for single-chain limit orders
+ * @param order The single-chain order
+ * @returns Object containing typed data and nonce for signing
+ */
+declare function generateEvmSingleChainLimitOrderTypedData(order: SingleChainOrder): Promise<{
+    orderTypedData: TypedDataDefinition;
+    nonce: bigint;
+}>;
+/**
+ * Generates EVM typed data and nonce for single-chain DCA orders
+ * @param order The DCA order
+ * @returns Object containing typed data and nonce for signing
+ */
+declare function generateEvmSingleChainDcaOrderTypedData(order: DcaSingleChainOrder): Promise<{
+    orderTypedData: TypedDataDefinition;
+    nonce: bigint;
+}>;
+/**
+ * Generates EVM typed data and nonce for cross-chain orders
+ * @param order The cross-chain order
+ * @returns Object containing typed data and nonce for signing
+ */
+declare function generateEvmCrossChainOrderTypedData(order: CrossChainOrder): Promise<{
+    orderTypedData: TypedDataDefinition;
+    nonce: bigint;
+}>;
+/**
+ * Generates a random nonce for EVM orders
+ * @returns Random nonce as string
+ */
+declare function generateEvmRandomNonce(): string;
+type CreateEvmCrossChainDcaOrderIntentParams = {
+    user: `0x${string}`;
+    sourceChainId: SupportedEvmChain;
+    sourceTokenAddress: string;
+    destinationChainId: number;
+    destinationTokenAddress: string;
+    destinationTokenMinAmount?: bigint;
+    destinationAddress: string;
+    minStablecoinAmount?: bigint;
+    deadline: number;
+    startTime: number;
+    amountInPerInterval: bigint;
+    totalIntervals: number;
+    intervalDuration: number;
+    extraTransfers?: ExtraTransfer$1[];
+    nonce?: string;
+    signature?: string;
+};
+/**
+ * Creates an EVM cross-chain DCA order intent request, ready to POST to
+ * `/user_intent/cross_chain/dca_order`. Pass `nonce`/`signature` from
+ * {@link getEVMCrossChainDcaOrderTypedData} for an executable order.
+ */
+declare function createEvmCrossChainDcaOrderIntentRequest(params: CreateEvmCrossChainDcaOrderIntentParams): DcaCrossChainUserIntentRequest;
+/**
+ * Generates the EIP-712 typed data (and nonce) for a cross-chain DCA order's Permit2 witness.
+ * Sign `orderTypedData`, then pass the resulting `nonce`/`signature` into
+ * {@link createEvmCrossChainDcaOrderIntentRequest} — both share the same execution-details hash.
+ */
+declare function getEVMCrossChainDcaOrderTypedData(params: CreateEvmCrossChainDcaOrderIntentParams, providedNonce?: bigint): {
+    orderTypedData: TypedDataDefinition;
+    nonce: bigint;
+};
+
+type CreateSolanaSingleChainLimitOrderIntentParams = {
+    user: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountIn: bigint;
+    amountOutMin: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    orderPubkey?: string;
+    secretNumber?: string;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+    takeProfitMinOut?: bigint;
+};
+type CreateSolanaSingleChainDcaOrderIntentParams = {
+    user: string;
+    tokenIn: string;
+    tokenOut: string;
+    amountInPerInterval: bigint;
+    totalIntervals: number;
+    intervalDuration: number;
+    amountOutMin: bigint;
+    destinationAddress: string;
+    extraTransfers?: ExtraTransfer$1[];
+    deadline: number;
+    startTime: number;
+    orderPubkey?: string;
+    secretNumber?: string;
+};
+type CreateSolanaCrossChainOrderIntentParams = {
+    user: string;
+    sourceChainId: number;
+    sourceTokenAddress: string;
+    sourceTokenAmount: bigint;
+    destinationChainId: number;
+    destinationTokenAddress: string;
+    destinationTokenMinAmount?: bigint;
+    destinationAddress: string;
+    minStablecoinAmount?: bigint;
+    deadline: number;
+    extraTransfers?: ExtraTransfer$1[];
+    orderPubkey?: string;
+    stopLossType?: StopLossType;
+    stopLossTriggerPrice?: string;
+    takeProfitMinOut?: bigint;
+};
+/**
+ * Creates a Solana single-chain limit order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createSolanaSingleChainLimitOrderIntentRequest(params: CreateSolanaSingleChainLimitOrderIntentParams): SingleChainUserIntentRequest;
+/**
+ * Creates a Solana single-chain DCA order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createSolanaSingleChainDcaOrderIntentRequest(params: CreateSolanaSingleChainDcaOrderIntentParams): DcaSingleChainUserIntentRequest;
+/**
+ * Creates a Solana cross-chain order intent request
+ * @param params Parameters for creating the intent request
+ * @returns Formatted intent request ready to send to auctioneer
+ */
+declare function createSolanaCrossChainOrderIntentRequest(params: CreateSolanaCrossChainOrderIntentParams): CrossChainUserIntentRequest;
+/**
+ * Generates instruction bytes for Solana single-chain limit orders
+ * @param order The single-chain order
+ * @returns Promise resolving to instruction bytes
+ */
+declare function generateSolanaSingleChainLimitOrderInstructions(order: SingleChainOrder): Promise<SolanaOrderInstructionResult & {
+    secretNumber: string;
+}>;
+/**
+ * Generates instruction bytes for Solana single-chain DCA orders
+ * @param order The DCA order
+ * @returns Promise resolving to instruction bytes
+ */
+declare function generateSolanaSingleChainDcaOrderInstructions(order: DcaSingleChainOrder): Promise<SolanaOrderInstructionResult & {
+    secretNumber: string;
+}>;
+/**
+ * Generates instruction bytes for Solana cross-chain orders
+ * @param order The cross-chain order
+ * @returns Promise resolving to instruction bytes
+ */
+declare function generateSolanaCrossChainOrderInstructions(order: CrossChainOrder): Promise<SolanaOrderInstructionResult>;
+/**
+ * Generates secret data for Solana single-chain limit orders
+ * @param tokenOut Output token mint address
+ * @param receiver Receiver public key
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and prepared secret data
+ */
+declare function generateSolanaLimitOrderSecretData(tokenOut: string, receiver: string, secretNumber?: string, extraTransfers?: ExtraTransfer$1[]): {
+    secretNumber: string;
+    secretData: any;
+};
+/**
+ * Generates secret data for Solana single-chain DCA orders
+ * @param tokenOut Output token mint address
+ * @param receiver Receiver public key
+ * @param secretNumber Secret number (optional, generates random if not provided)
+ * @param extraTransfers Extra transfers array
+ * @returns Object containing secret number and prepared secret data
+ */
+declare function generateSolanaDcaOrderSecretData(tokenOut: string, receiver: string, secretNumber?: string, extraTransfers?: ExtraTransfer$1[]): {
+    secretNumber: string;
+    secretData: any;
+};
+/**
+ * Generates a random secret number for Solana orders
+ * @returns Random secret number as string
+ */
+declare function generateSolanaRandomSecretNumber(): string;
+
+export { AUCTIONEER_URL, type ApiCrossChainOrder, type ApiIntentResponse, type ApiResponse, type ApiSingleChainOrder, type ApiUserOrders, AuctioneerAPI, CROSS_CHAIN_GUARD_ADDRESSES, type CancelCrossChainOrderParams, type CancelSingleChainOrderParams, ChainID, type ChainOrderStatus, ChainType, type CreateCrossChainOrderParams, type CreateDcaSingleChainOrderParams, type CreateEvmCrossChainDcaOrderIntentParams, type CreateEvmCrossChainOrderIntentParams, type CreateEvmSingleChainDcaOrderIntentParams, type CreateEvmSingleChainLimitOrderIntentParams, type CreateSingleChainOrderParams, type CreateSolanaCrossChainOrderIntentParams, type CreateSolanaSingleChainDcaOrderIntentParams, type CreateSolanaSingleChainLimitOrderIntentParams, type CreateSuiCrossChainOrderIntentParams, type CreateSuiSingleChainDcaOrderIntentParams, type CreateSuiSingleChainLimitOrderIntentParams, CrossChainOrder, DCA_CROSS_CHAIN_GUARD_ADDRESSES, DCA_SINGLE_CHAIN_GUARD_ADDRESSES, DcaSingleChainOrder, type DefiLlamaCoinData, type DefiLlamaTokensResponse, type EVMConfig, EVMSDK, EVM_ZERO_ADDRESS, EVM_ZERO_SIGNATURE, type FetchJWTParams, type FetchSiweMessageParams, type FetchUserOrdersParams, type GetUserOrdersParams, IntentsOrderType, type IntentsQuoteParams, MAX_UINT_128, MAX_UINT_256, MAX_UINT_32, MAX_UINT_64, NATIVE_EVM_ETH_ADDRESSES, NATIVE_SOLANA_TOKEN_ADDRESS, NATIVE_SUI_TOKEN_ADDRESS, PERMIT2_ADDRESS, PROD_CROSS_CHAIN_GUARD_ADDRESSES, PROD_DCA_CROSS_CHAIN_GUARD_ADDRESSES, PROD_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_SINGLE_CHAIN_GUARD_ADDRESSES, PROD_SUI_PACKAGE_ID, QuoteProvider, type QuoteResponse, SINGLE_CHAIN_GUARD_ADDRESSES, SOLANA_MINT_TOKEN, SOLANA_USDC_MINT, SUI_GUARD_COLLATERAL_TYPE, SUI_GUARD_STABLECOIN_TYPE, SUI_PACKAGE_ID, SingleChainOrder, type SolanaConfig, type SolanaOrderInstructionResult, SolanaSDK, type StopLossType, type SuiConfig, SuiSDK, type SupportedChain, SupportedChains, type SupportedEvmChain, TEST_CROSS_CHAIN_GUARD_ADDRESSES, TEST_DCA_SINGLE_CHAIN_GUARD_ADDRESSES, TEST_SINGLE_CHAIN_GUARD_ADDRESSES, TEST_SUI_PACKAGE_ID, TOKEN_SEARCH_API_BASE_URL, type TokenInfo, type TokenSearchParams, type TokenSearchResponse, ValidationError, WRAPPED_ETH_ADDRESSES, WRAPPED_SOL_MINT_ADDRESS, calculateAmounts, cancelCrossChainOrderInstructionsAsBytes, cancelDcaSingleChainOrderInstructions, cancelSingleChainOrderInstructionsAsBytes, chainIdToChainTypeMap, createEvmCrossChainDcaOrderIntentRequest, createEvmCrossChainOrderIntentRequest, createEvmSingleChainDcaOrderIntentRequest, createEvmSingleChainLimitOrderIntentRequest, createSolanaCrossChainOrderIntentRequest, createSolanaSingleChainDcaOrderIntentRequest, createSolanaSingleChainLimitOrderIntentRequest, createSuiCrossChainOrderIntentRequest, createSuiSingleChainDcaOrderIntentRequest, createSuiSingleChainLimitOrderIntentRequest, fetchJWTToken, fetchSiweMessage, fetchUserOrders, generateEvmCrossChainOrderTypedData, generateEvmRandomNonce, generateEvmSingleChainDcaOrderTypedData, generateEvmSingleChainLimitOrderTypedData, generateExecutionDetailsHash, generateSolanaCrossChainOrderInstructions, generateSolanaDcaOrderSecretData, generateSolanaLimitOrderSecretData, generateSolanaRandomSecretNumber, generateSolanaSingleChainDcaOrderInstructions, generateSolanaSingleChainLimitOrderInstructions, generateSuiDcaOrderSecretData, generateSuiLimitOrderSecretData, getCancelCrossChainOrderRawData, getCancelSingleChainOrderRawData, getCoinFromResponse, getDcaSecretHash, getEVMCrossChainDcaOrderTypedData, getEVMCrossChainOrderTypedData, getEVMSingleChainOrderTypedData, getInvalidateNoncesRawData, getSecretHash, getSolanaCrossChainOrderInstructions, getSolanaDcaSingleChainOrderInstructions, getSolanaOrdersWithLockedFunds, getSolanaSingleChainOrderInstructions, getSuiCancelCrossChainOrder, getSuiOrderTransaction, getRandomU64Number as getSuiRandomU64Number, getSuiSingleChainDcaOrderTransaction, getSuiSingleChainLimitOrderTransaction, getTokenList, getTokensData, isErrorApiResponse, isEvmChain, isNativeEvmToken, isSuccessApiResponse, isSupportedChain, normalizeNativeEvmTokenForSigning, prepareDcaSecretData, prepareSecretData, signSingleChainDcaOrder, signSingleChainLimitOrder };