logiqical 0.1.2 → 0.3.0

package/dist/index.d.mts

@@ -1,12 +1,88 @@
-declare class HttpClient {
-    private baseUrl;
-    private apiKey;
-    constructor(baseUrl: string, apiKey?: string);
-    setApiKey(key: string): void;
-    getApiKey(): string | null;
-    get<T>(path: string, params?: Record<string, string | number | undefined>, skipAuth?: boolean): Promise<T>;
-    post<T>(path: string, body: Record<string, unknown>): Promise<T>;
-    private handleResponse;
+import { Wallet, JsonRpcProvider, TransactionRequest, TransactionResponse } from 'ethers';
+
+interface ChainConfig {
+    chainId: number;
+    name: string;
+    rpcUrl: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
+    blockExplorer?: string;
+}
+declare const CHAINS: Record<string, ChainConfig>;
+interface AgentWalletConfig {
+    /** Network name from CHAINS registry, or a custom RPC URL */
+    network?: string;
+    /** Custom RPC URL (overrides network preset) */
+    rpcUrl?: string;
+    /** Private key to import (0x-prefixed hex) */
+    privateKey?: string;
+    /** Password for keystore encryption/decryption */
+    password?: string;
+    /** Keystore file name (default: "agent") */
+    keystoreName?: string;
+}
+declare class AgentWallet {
+    readonly wallet: Wallet;
+    readonly provider: JsonRpcProvider;
+    readonly chain: ChainConfig;
+    readonly address: string;
+    private constructor();
+    /** The private key (use carefully) */
+    get privateKey(): string;
+    /** Generate a brand new wallet with a random private key */
+    static generate(config?: AgentWalletConfig): AgentWallet;
+    /** Import an existing wallet from a private key */
+    static fromPrivateKey(privateKey: string, config?: AgentWalletConfig): AgentWallet;
+    /** Boot from encrypted keystore, or generate + save if none exists */
+    static boot(config?: AgentWalletConfig): Promise<AgentWallet>;
+    /** Encrypt and save the wallet to the keystore directory */
+    saveKeystore(password?: string, name?: string): Promise<string>;
+    /** Get native token balance (formatted) */
+    getBalance(): Promise<string>;
+    /** Get balance of any address */
+    getBalanceOf(address: string): Promise<string>;
+    /** Sign a message */
+    signMessage(message: string): Promise<string>;
+    /** Sign typed data (EIP-712) */
+    signTypedData(domain: any, types: any, value: any): Promise<string>;
+    /** Sign a transaction without broadcasting */
+    signTransaction(tx: TransactionRequest): Promise<string>;
+    /** Sign and broadcast a transaction */
+    sendTransaction(tx: TransactionRequest): Promise<TransactionResponse>;
+    /** Send native token to an address */
+    send(to: string, amount: string): Promise<TransactionResponse>;
+    /**
+     * Sign and broadcast an unsigned tx object returned by the Logiqical API.
+     * Handles the { to, data, value, chainId, gas/gasLimit } format.
+     */
+    signAndBroadcast(unsignedTx: {
+        to: string;
+        data: string;
+        value: string;
+        chainId?: number;
+        gas?: string;
+        gasLimit?: string;
+    }): Promise<TransactionResponse>;
+    /**
+     * Sign and broadcast multiple unsigned txs in sequence.
+     * Waits for each to confirm before sending the next.
+     */
+    signAndBroadcastAll(unsignedTxs: Array<{
+        to: string;
+        data: string;
+        value: string;
+        chainId?: number;
+        gas?: string;
+        gasLimit?: string;
+    }>, confirmations?: number): Promise<TransactionResponse[]>;
+    /** Call a read-only contract method (no gas, no signing) */
+    call(tx: TransactionRequest): Promise<string>;
+    /** Switch to a different network (returns new AgentWallet instance) */
+    switchNetwork(network: string): AgentWallet;
+    private static resolveProvider;
 }
 
 /** Unsigned transaction ready to be signed and broadcast */
@@ -19,288 +95,298 @@ interface UnsignedTx {
     gasLimit?: string;
     description?: string;
 }
-interface BalancesResponse {
-    wallet: string;
-    avax: string;
-    arena: string;
-    avaxFormatted: string;
-    arenaFormatted: string;
-}
-interface BuyQuoteResponse {
-    avaxIn: string;
-    arenaOut: string;
-    arenaOutFormatted: string;
-    rate: string;
-    priceImpact: string;
-}
-interface SellQuoteResponse {
-    arenaIn: string;
-    avaxOut: string;
-    avaxOutFormatted: string;
-    rate: string;
-    priceImpact: string;
-}
-interface SwapBuyResponse {
-    transactions: UnsignedTx[];
-    summary: string;
-}
-interface SwapSellResponse {
-    transactions: UnsignedTx[];
-}
-interface StakeInfoResponse {
-    staked: string;
-    stakedFormatted: string;
-    rewards: string;
-    rewardsFormatted: string;
-    apy: string;
-}
-interface StakeBuildResponse {
-    transactions: UnsignedTx[];
-}
-interface TokenCreator {
-    address: string;
-    handle: string;
-    photoUrl: string;
-    twitterFollowers: number | null;
-    totalTokensCreated: number | null;
-}
-interface LaunchpadToken {
-    tokenId: string;
-    type: "AVAX-paired" | "ARENA-paired";
-    name: string;
-    symbol: string;
-    tokenAddress: string;
-    photoUrl: string;
-    description: string | null;
-    creator: TokenCreator;
-    price: {
-        eth: number;
-        usd: number;
-        avaxPrice: number;
-    };
-    volume: {
-        totalEth: number;
-        totalUsd: number;
-    };
-    holders: number;
-    transactions: number;
-    graduationProgress: string | null;
-    graduated: boolean;
-    supply: number;
-    createdAt: string | null;
-    whitelist: unknown;
-    isOfficial: boolean;
-    dexPoolId: string | null;
-}
-interface LaunchpadListResponse {
-    count: number;
-    tokens: LaunchpadToken[];
-}
-interface TokenStatsTimeframes {
-    "5m": number;
-    "1h": number;
-    "4h": number;
-    "12h": number;
-    "24h": number;
-}
-interface TokenDetailResponse extends LaunchpadToken {
-    stats?: {
-        buys: TokenStatsTimeframes;
-        sells: TokenStatsTimeframes;
-        uniqueBuyers: TokenStatsTimeframes;
-        uniqueSellers: TokenStatsTimeframes;
-        volume: TokenStatsTimeframes;
-        priceChange: TokenStatsTimeframes;
-    };
-}
-interface LaunchpadQuoteResponse {
-    tokensOut?: string;
-    avaxCost?: string;
-    avaxOut?: string;
-    fees?: Record<string, string>;
+/** Intent for calling a smart contract method */
+interface CallIntent {
+    /** Contract address */
+    contract: string;
+    /** Human-readable ABI (e.g. ["function transfer(address,uint256) returns (bool)"]) */
+    abi: string[];
+    /** Method name to call */
+    method: string;
+    /** Method arguments */
+    args?: any[];
+    /** Native token value to send (human-readable, e.g. "0.1") */
+    value?: string;
+    /** Gas limit override */
+    gasLimit?: string;
 }
-interface TradeEntry {
-    type: "buy" | "sell";
-    trader: {
-        address: string;
-        handle: string;
-        name: string;
-        photoUrl: string;
-        twitterFollowers: number | null;
+/** Result from execute() or call() */
+interface TransactionResult {
+    hash: string;
+    receipt: {
+        status: number;
+        blockNumber: number;
+        gasUsed: string;
+        transactionHash: string;
     };
-    tokenAmount: number;
-    costOrReward?: {
-        eth: number;
-        usd: number;
-    };
-    value?: {
-        eth: number;
-        usd: number;
+}
+
+/** Spending policy configuration */
+interface SpendingPolicy {
+    /** Max native token (e.g. AVAX) per single transaction in human-readable units */
+    maxPerTx?: string;
+    /** Max native token spend per hour */
+    maxPerHour?: string;
+    /** Max native token spend per day (24h rolling) */
+    maxPerDay?: string;
+    /** Allowed contract addresses (if set, only these can be called) */
+    allowedContracts?: string[];
+    /** Blocked contract addresses (rejected even if in allowedContracts) */
+    blockedContracts?: string[];
+    /** Simulate (eth_call) before sending — catches reverts before spending gas */
+    simulateBeforeSend?: boolean;
+    /** Dry run mode — simulate everything, broadcast nothing */
+    dryRun?: boolean;
+}
+declare class PolicyEngine {
+    private policy;
+    private spendLog;
+    constructor(policy?: SpendingPolicy);
+    getPolicy(): SpendingPolicy;
+    setPolicy(policy: SpendingPolicy): void;
+    updatePolicy(updates: Partial<SpendingPolicy>): void;
+    /** Check a transaction against the policy. Throws if rejected. */
+    check(tx: UnsignedTx): void;
+    /** Record a spend after successful broadcast */
+    recordSpend(value: bigint): void;
+    /** Get budget status */
+    getBudgetStatus(): {
+        spentLastHour: string;
+        spentLast24h: string;
+        remainingHour: string | null;
+        remainingDay: string | null;
     };
-    priceEth: number;
-    txHash: string;
-    time: string | null;
+    get shouldSimulate(): boolean;
+    get isDryRun(): boolean;
+    private getSpendSince;
 }
-interface TokenActivityResponse {
-    tokenId: string | null;
-    tokenAddress: string;
-    trades: TradeEntry[];
+type PolicyErrorCode = "MAX_PER_TX_EXCEEDED" | "HOURLY_BUDGET_EXCEEDED" | "DAILY_BUDGET_EXCEEDED" | "CONTRACT_NOT_ALLOWED" | "CONTRACT_BLOCKED" | "SIMULATION_FAILED";
+declare class PolicyError extends Error {
+    readonly code: PolicyErrorCode;
+    constructor(message: string, code: PolicyErrorCode);
 }
-interface HolderEntry {
-    rank: number;
-    address: string;
-    handle: string;
-    name: string;
-    photoUrl: string;
-    twitterFollowers: number | null;
-    balance: number;
-    unrealizedPnl: {
-        eth: number;
-        usd: number;
-    };
-    realizedPnl: {
-        eth: number;
-        usd: number;
-    };
-    buys: number;
-    sells: number;
+
+declare class SwapModule {
+    private provider;
+    private arenaToken;
+    private lbQuoter;
+    constructor(provider: JsonRpcProvider);
+    /** Get AVAX and ARENA balances for a wallet */
+    getBalances(wallet: string): Promise<{
+        avax: string;
+        arena: string;
+        avaxFormatted: string;
+        arenaFormatted: string;
+    }>;
+    /** Quote how much ARENA for a given AVAX amount (includes 0.3% fee) */
+    quote(avaxAmount: string): Promise<{
+        arenaOut: string;
+        fee: string;
+        netAvax: string;
+        rate: string;
+    }>;
+    /** Quote how much AVAX for selling ARENA */
+    sellQuote(arenaAmount: string): Promise<{
+        avaxOut: string;
+        arenaIn: string;
+        rate: string;
+    }>;
+    /** Build unsigned tx to buy ARENA with AVAX via LFJ DEX */
+    buildBuy(wallet: string, avaxAmount: string, slippageBps?: number): Promise<{
+        transactions: UnsignedTx[];
+        summary: string;
+    }>;
+    /** Build unsigned txs to sell ARENA for AVAX: [approve, swap] */
+    buildSell(wallet: string, arenaAmount: string, slippageBps?: number): Promise<{
+        transactions: UnsignedTx[];
+    }>;
 }
-interface TokenHoldersResponse {
-    tokenAddress: string;
-    holders: HolderEntry[];
+
+declare class StakingModule {
+    private provider;
+    private arenaToken;
+    private staking;
+    constructor(provider: JsonRpcProvider);
+    /** Get staking info — staked amount, pending rewards */
+    getInfo(wallet: string): Promise<{
+        staked: string;
+        stakedFormatted: string;
+        rewards: string;
+        rewardsFormatted: string;
+    }>;
+    /** Build txs to stake ARENA: [approve, deposit] */
+    buildStake(wallet: string, amount: string): Promise<{
+        transactions: UnsignedTx[];
+    }>;
+    /** Build tx to unstake ARENA + claim rewards */
+    buildUnstake(wallet: string, amount: string): Promise<{
+        transactions: UnsignedTx[];
+    }>;
+    /** Build buy-and-stake flow (3 txs): buy ARENA via LFJ, approve, stake */
+    buildBuyAndStake(wallet: string, avaxAmount: string, slippageBps?: number): Promise<{
+        transactions: UnsignedTx[];
+    }>;
 }
-interface GlobalTradeEntry extends TradeEntry {
-    token: {
+
+declare class LaunchpadModule {
+    private provider;
+    private launchContract;
+    private tokenManager;
+    private avaxHelper;
+    constructor(provider: JsonRpcProvider);
+    private isArenaPaired;
+    private getContract;
+    /** Get platform overview — total tokens, fees, contract addresses */
+    getOverview(): Promise<{
+        totalAvaxPairedTokens: string;
+        totalArenaPairedTokens: string;
+        totalTokens: string;
+        protocolFeeBps: {
+            avaxPaired: any;
+            arenaPaired: any;
+        };
+        contracts: {
+            launchContract: string;
+            tokenManager: string;
+            avaxHelper: string;
+        };
+    }>;
+    /** Get full token info by ID */
+    getToken(tokenId: string): Promise<{
+        tokenId: string;
+        type: string;
         name: string;
         symbol: string;
-        address: string;
-        photoUrl: string;
+        tokenAddress: any;
+        creator: any;
+        priceAvax: string;
+        graduationProgress: string;
+        graduated: any;
+        amountSold: string;
+        totalSupply: string;
+        remainingForSale: string;
+    }>;
+    /** Get a buy or sell quote */
+    quote(tokenId: string, side: "buy" | "sell", amount: string): Promise<{
         tokenId: string;
-    };
-}
-interface GlobalTradesResponse {
-    count: number;
-    offset: number;
-    trades: GlobalTradeEntry[];
-}
-interface LaunchpadBuyResponse {
-    transactions?: UnsignedTx[];
-    graduated?: boolean;
-    summary?: string;
-    note?: string;
-}
-interface LaunchpadSellResponse {
-    transactions: UnsignedTx[];
-    graduated?: boolean;
-    summary?: string;
-    note?: string;
-}
-interface ArenaCommunity {
-    id: string;
-    signer: string;
-    isTemporary: boolean;
-    name: string;
-    tokenName: string;
-    ticker: string;
-    photoURL: string;
-    paymentToken: string;
-    contractAddress: string | null;
-    createdOn: string;
-}
-interface LaunchTokenResponse {
-    community: ArenaCommunity;
-    imageUrl: string;
-    transaction: UnsignedTx;
-    nextTokenId: string;
-    instructions: string[];
-}
-interface UploadImageResponse {
-    imageUrl: string;
-}
-interface BuildCreateResponse {
-    transaction: UnsignedTx;
-    nextTokenId: string;
-}
-interface DexTokenEntry {
-    symbol: string;
-    address: string;
-    decimals: number;
-}
-interface DexTokensResponse {
-    tokens: DexTokenEntry[];
-    note: string;
-}
-interface DexTokenInfoResponse {
-    address: string;
-    symbol: string;
-    name: string;
-    decimals: number;
-}
-interface DexQuoteResponse {
-    from: string;
-    to: string;
-    amountIn: string;
-    amountOut: string;
-    rate: string;
-    priceImpact: string;
-    path: string[];
-}
-interface DexBalanceResponse {
-    wallet: string;
-    token: string;
-    balance: string;
-    formatted: string;
-    symbol: string;
-}
-interface DexSwapResponse {
-    transactions: UnsignedTx[];
-    summary: string;
-}
-interface PerpsSetupResponse {
-    success: boolean;
-    message: string;
+        side: "buy";
+        avaxIn: string;
+        tokensOut: string;
+        note: string;
+        tokenAmount?: undefined;
+        rewardAvax?: undefined;
+        rewardArena?: undefined;
+    } | {
+        tokenId: string;
+        side: "buy";
+        avaxIn: string;
+        tokensOut: string;
+        note?: undefined;
+        tokenAmount?: undefined;
+        rewardAvax?: undefined;
+        rewardArena?: undefined;
+    } | {
+        tokenId: string;
+        side: "sell";
+        tokenAmount: string;
+        rewardAvax: string | undefined;
+        rewardArena: string | undefined;
+        avaxIn?: undefined;
+        tokensOut?: undefined;
+        note?: undefined;
+    }>;
+    /** Get recent token launches */
+    getRecent(count?: number): Promise<{
+        count: number;
+        tokens: any[];
+    }>;
+    /** Build unsigned tx to buy a launchpad token */
+    buildBuy(wallet: string, tokenId: string, avax: string, slippageBps?: number): Promise<{
+        transactions: UnsignedTx[];
+    }>;
+    /** Build unsigned txs to sell a launchpad token: [approve, sell] */
+    buildSell(wallet: string, tokenId: string, amount: string, slippageBps?: number): Promise<{
+        transactions: UnsignedTx[];
+    }>;
+    /** Binary search for max tokens purchasable with given AVAX */
+    private binarySearchTokenAmount;
 }
-interface PerpsTradingPair {
-    provider: string;
-    dex: string;
-    name: string;
-    symbol: string;
-    icon: string;
-    baseAssetId: number;
-    baseAsset: string;
-    quoteAsset: string;
-    sizePrecision: number;
-    pricePrecision: number;
-    maxLeverage: number;
-    isDelisted: boolean;
-    isOnlyIsolated: boolean;
-    marginMode: string;
-}
-interface PerpsTradingPairsResponse {
-    pairs: PerpsTradingPair[];
-    cachedAt: string;
-    count: number;
-}
-interface PerpsOrderResponse {
-    [key: string]: any;
-}
-interface PerpsPositionsResponse {
-    assetPositions?: any[];
-    marginSummary?: {
-        accountValue: string;
-        totalMarginUsed: string;
-        totalNtlPos: string;
-        totalRawUsd: string;
+
+declare class DexModule {
+    private provider;
+    private lbQuoter;
+    constructor(provider: JsonRpcProvider);
+    /** Resolve token symbol or address to a checksummed address */
+    private resolveToken;
+    /** List known tokens */
+    getTokens(): {
+        tokens: Array<{
+            symbol: string;
+            address: string;
+        }>;
+        note: string;
     };
-    [key: string]: any;
+    /** Look up any ERC-20 token by address */
+    getTokenInfo(address: string): Promise<{
+        address: string;
+        symbol: string;
+        name: string;
+        decimals: number;
+    }>;
+    /** Get balance of any token */
+    getBalance(wallet: string, tokenOrAddress: string): Promise<{
+        wallet: string;
+        token: string;
+        balance: string;
+        formatted: string;
+        symbol: string;
+    }>;
+    /** Quote a swap between any two tokens */
+    quote(from: string, to: string, amount: string): Promise<{
+        from: string;
+        to: string;
+        amountIn: string;
+        amountOut: string;
+        rate: string;
+        path: string[];
+    }>;
+    /** Build swap transactions (1 tx for AVAX→token, 2 txs for token→token with approve) */
+    buildSwap(wallet: string, from: string, to: string, amount: string, slippageBps?: number): Promise<{
+        transactions: UnsignedTx[];
+        summary: string;
+    }>;
 }
-interface BridgeTransaction {
-    to: string;
-    data: string;
-    value: string;
-    gasLimit?: string;
-    chainId: number;
+
+declare class PerpsModule {
+    private arenaApiKey?;
+    constructor(arenaApiKey?: string | undefined);
+    setArenaApiKey(key: string): void;
+    private arenaRequest;
+    private hlPost;
+    register(): Promise<any>;
+    getRegistrationStatus(): Promise<any>;
+    getWalletAddress(): Promise<any>;
+    getAuthStatus(): Promise<any>;
+    getAuthPayload(step: string, mainWalletAddress?: string): Promise<any>;
+    submitAuthSignature(step: string, signature: string, mainWalletAddress?: string, metadata?: any): Promise<any>;
+    enableHip3(): Promise<any>;
+    getTradingPairs(): Promise<{
+        pairs: any[];
+        count: number;
+    }>;
+    updateLeverage(symbol: string, leverage: number, leverageType?: "cross" | "isolated"): Promise<any>;
+    placeOrder(orders: any[]): Promise<any>;
+    cancelOrders(cancels: {
+        assetIndex: number;
+        oid: number;
+    }[]): Promise<any>;
+    closePosition(symbol: string, positionSide: "long" | "short", size: number, currentPrice: number, closePercent?: number): Promise<any>;
+    getOrders(): Promise<any>;
+    getTradeExecutions(): Promise<any>;
+    getPositions(wallet: string): Promise<any>;
+    getOpenOrders(wallet: string): Promise<any>;
 }
+
 interface BridgeQuoteResponse {
     id: string;
     fromChainId: number;
@@ -312,11 +398,13 @@ interface BridgeQuoteResponse {
     estimatedGas: string;
     estimatedTime: number;
     tool: string;
-    transaction?: BridgeTransaction;
-}
-interface BridgeRoutesResponse {
-    routes: BridgeQuoteResponse[];
-    count: number;
+    transaction?: {
+        to: string;
+        data: string;
+        value: string;
+        gasLimit?: string;
+        chainId: number;
+    };
 }
 interface BridgeStatusResponse {
     status: "NOT_FOUND" | "PENDING" | "DONE" | "FAILED";
@@ -347,520 +435,484 @@ interface BridgeLiFiChain {
         address: string;
     };
 }
-interface BridgeTokensResponse {
-    tokens: Record<string, BridgeLiFiToken[]>;
-}
-interface BridgeTokenResponse extends BridgeLiFiToken {
-}
-interface BridgeChainsResponse {
-    chains: BridgeLiFiChain[];
-    count: number;
+declare class BridgeModule {
+    getChains(): Promise<{
+        chains: BridgeLiFiChain[];
+        count: number;
+    }>;
+    getTokens(chains: string): Promise<{
+        tokens: Record<string, BridgeLiFiToken[]>;
+    }>;
+    getToken(chainId: number, address: string): Promise<BridgeLiFiToken>;
+    getConnections(fromChainId: number, toChainId: number, fromToken?: string, toToken?: string): Promise<{
+        connections: any[];
+    }>;
+    getQuote(fromChainId: number, toChainId: number, fromToken: string, toToken: string, fromAmount: string, fromAddress: string, toAddress?: string, slippage?: number, fromDecimals?: number): Promise<BridgeQuoteResponse>;
+    getRoutes(fromChainId: number, toChainId: number, fromToken: string, toToken: string, fromAmount: string, fromAddress: string, toAddress?: string, slippage?: number, fromDecimals?: number): Promise<{
+        routes: BridgeQuoteResponse[];
+        count: number;
+    }>;
+    getStatus(txHash: string, fromChainId: number, toChainId: number, bridge?: string): Promise<BridgeStatusResponse>;
+    getInfo(): {
+        chains: {
+            readonly ethereum: 1;
+            readonly base: 8453;
+            readonly arbitrum: 42161;
+            readonly optimism: 10;
+            readonly polygon: 137;
+            readonly bsc: 56;
+            readonly avalanche: 43114;
+            readonly fantom: 250;
+            readonly gnosis: 100;
+            readonly zksync: 324;
+            readonly linea: 59144;
+            readonly scroll: 534352;
+            readonly blast: 81457;
+            readonly mantle: 5000;
+        };
+        usdc: Record<string, string>;
+        nativeToken: string;
+        tip: string;
+    };
+    private parseUnits;
+    private parseQuote;
+    private parseRoute;
 }
-interface BridgeConnectionsResponse {
-    connections: any[];
+
+interface TicketPriceResponse {
+    price: string;
+    priceWithFee?: string;
+    priceAfterFee?: string;
+    tickets: string;
+    fractionalAmount: number;
+}
+interface TicketBalanceResponse {
+    tickets: string;
+    fractionalAmount: string;
+}
+interface TicketSupplyResponse {
+    wholeSupply: string;
+    fractionalSupply: string;
+    tickets: string;
+}
+interface TicketFeesResponse {
+    protocolFee: string;
+    subjectFee: string;
+    referralFee: string;
+    totalFeePercent: string;
+}
+declare class TicketsModule {
+    private provider;
+    private contract;
+    constructor(provider: JsonRpcProvider);
+    getBuyPrice(subject: string, amount?: string): Promise<TicketPriceResponse>;
+    getSellPrice(subject: string, amount?: string): Promise<TicketPriceResponse>;
+    getBalance(subject: string, user: string): Promise<TicketBalanceResponse>;
+    getSupply(subject: string): Promise<TicketSupplyResponse>;
+    getFees(): Promise<TicketFeesResponse>;
+    buildBuyTx(wallet: string, subject: string, amount?: string): Promise<{
+        transaction: UnsignedTx;
+    }>;
+    buildSellTx(wallet: string, subject: string, amount?: string): Promise<{
+        transaction: UnsignedTx;
+    }>;
+    private ticketsToFractional;
 }
-interface BridgeInfoResponse {
-    chains: Record<string, number>;
-    usdc: Record<string, string>;
-    nativeToken: string;
-    tip: string;
+
+declare class SocialModule {
+    private arenaApiKey?;
+    constructor(arenaApiKey?: string | undefined);
+    setArenaApiKey(key: string): void;
+    private request;
+    searchUsers(q: string, page?: number, pageSize?: number): Promise<any>;
+    getUserByHandle(handle: string): Promise<any>;
+    getUserById(userId: string): Promise<any>;
+    getTopUsers(page?: number, pageSize?: number): Promise<any>;
+    getMe(): Promise<any>;
+    updateProfile(updates: {
+        userName?: string;
+        bio?: string;
+        profilePicture?: string;
+    }): Promise<any>;
+    updateBanner(bannerUrl: string): Promise<any>;
+    follow(userId: string): Promise<any>;
+    unfollow(userId: string): Promise<any>;
+    getFollowers(userId: string, page?: number, pageSize?: number): Promise<any>;
+    getFollowing(userId: string, page?: number, pageSize?: number): Promise<any>;
+    getSharesStats(userId: string): Promise<any>;
+    getShareHolders(userId?: string, page?: number, pageSize?: number): Promise<any>;
+    getHoldings(page?: number, pageSize?: number): Promise<any>;
+    getConversations(page?: number): Promise<any>;
+    getDirectMessages(): Promise<any>;
+    getGroupChats(): Promise<any>;
+    getGroup(groupId: string): Promise<any>;
+    getMembers(groupId: string): Promise<any>;
+    getOrCreateDM(userId: string): Promise<any>;
+    acceptChat(groupId: string): Promise<any>;
+    sendMessage(groupId: string, text: string, replyId?: string): Promise<any>;
+    getMessages(groupId: string, after?: string): Promise<any>;
+    searchMessages(q: string, groupId?: string): Promise<any>;
+    getMentions(groupId?: string): Promise<any>;
+    react(messageId: string, groupId: string, reaction: string): Promise<any>;
+    pinMessage(messageId: string, groupId: string, isPinned?: boolean): Promise<any>;
+    getPinnedMessages(groupId: string): Promise<any>;
+    createThread(content: string, replyToId?: string): Promise<any>;
+    likeThread(threadId: string): Promise<any>;
+    repost(threadId: string): Promise<any>;
 }
-interface RegisterResponse {
-    apiKey: string;
-    wallet: string;
+
+interface HlAssetCtx {
+    coin: string;
+    markPx: string;
+    midPx: string;
+    oraclePx: string;
+    openInterest: string;
+    funding: string;
+    premium: string;
+    dayNtlVlm: string;
+    prevDayPx: string;
+}
+interface HlMeta {
     name: string;
+    szDecimals: number;
+    maxLeverage: number;
 }
-interface BroadcastResponse {
-    txHash: string;
-}
-interface HealthResponse {
-    status: string;
-    router: string;
-    fee: string;
-}
-
-declare class SwapModule {
-    private http;
-    private auth;
-    constructor(http: HttpClient, auth: () => Promise<void>);
-    /**
-     * Get AVAX and ARENA token balances for a wallet.
-     * @param wallet - Wallet address to check
-     */
-    getBalances(wallet: string): Promise<BalancesResponse>;
-    /**
-     * Quote how much ARENA you get for a given amount of AVAX.
-     * @param avax - Amount of AVAX to spend
-     */
-    quote(avax: string): Promise<BuyQuoteResponse>;
-    /**
-     * Quote how much AVAX you get for selling a given amount of ARENA.
-     * @param arena - Amount of ARENA to sell
-     */
-    sellQuote(arena: string): Promise<SellQuoteResponse>;
-    /**
-     * Build unsigned transaction to buy ARENA with AVAX.
-     *
-     * Sign the transaction, then broadcast via `client.broadcast()`.
-     *
-     * @param wallet - Your wallet address
-     * @param avax - Amount of AVAX to spend
-     * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-     */
-    buildBuy(wallet: string, avax: string, slippage?: number): Promise<SwapBuyResponse>;
-    /**
-     * Build unsigned transactions to sell ARENA for AVAX.
-     *
-     * Returns 2 transactions — execute in order:
-     * 1. Approve — allows the DEX router to spend your ARENA
-     * 2. Swap — executes the ARENA → AVAX swap
-     *
-     * Sign each, broadcast via `client.broadcast()`, wait for confirmation before the next.
-     *
-     * @param wallet - Your wallet address
-     * @param amount - Amount of ARENA to sell, or "max" for entire balance
-     * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-     */
-    buildSell(wallet: string, amount: string, slippage?: number): Promise<SwapSellResponse>;
+interface MarketSignal {
+    coin: string;
+    price: number;
+    oraclePrice: number;
+    change24h: number;
+    change24hPct: number;
+    volume24h: number;
+    openInterest: number;
+    fundingRate: number;
+    fundingAnnualized: number;
+    fundingBias: "long-heavy" | "short-heavy" | "neutral";
+    maxLeverage: number;
 }
-
-declare class StakingModule {
-    private http;
-    private auth;
-    constructor(http: HttpClient, auth: () => Promise<void>);
-    /**
-     * Get staking info for a wallet — staked amount, pending rewards, APY.
-     * @param wallet - Wallet address to check
-     */
-    getInfo(wallet: string): Promise<StakeInfoResponse>;
-    /**
-     * Build unsigned transactions to stake ARENA tokens.
-     *
-     * Returns 2 transactions — execute in order:
-     * 1. Approve — allows the staking contract to spend your ARENA
-     * 2. Stake — deposits ARENA into staking
-     *
-     * @param wallet - Your wallet address
-     * @param amount - Amount of ARENA to stake
-     */
-    buildStake(wallet: string, amount: string): Promise<StakeBuildResponse>;
-    /**
-     * Build unsigned transactions to buy ARENA with AVAX and stake in one flow.
-     *
-     * Combines swap + approve + stake. Returns multiple transactions — execute in order.
-     *
-     * @param wallet - Your wallet address
-     * @param avax - Amount of AVAX to spend
-     * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-     */
-    buildBuyAndStake(wallet: string, avax: string, slippage?: number): Promise<StakeBuildResponse>;
-    /**
-     * Build unsigned transaction to unstake ARENA tokens and claim rewards.
-     * @param wallet - Your wallet address
-     * @param amount - Amount of ARENA to unstake
-     */
-    buildUnstake(wallet: string, amount: string): Promise<UnsignedTx>;
+interface TechnicalSignal {
+    coin: string;
+    price: number;
+    sma20: number;
+    sma50: number;
+    rsi14: number;
+    trend: "bullish" | "bearish" | "neutral";
+    momentum: "strong" | "moderate" | "weak";
+    priceVsSma20: number;
+    priceVsSma50: number;
+    volatility: number;
+    support: number;
+    resistance: number;
+}
+interface SignalSummary {
+    coin: string;
+    timestamp: string;
+    market: MarketSignal;
+    technical: TechnicalSignal;
+    whaleActivity: {
+        topLongs: any[];
+        topShorts: any[];
+        netBias: "long" | "short" | "neutral";
+        largestPosition: any | null;
+    };
+    verdict: {
+        direction: "long" | "short" | "wait";
+        confidence: "high" | "medium" | "low";
+        reasons: string[];
+    };
 }
-
-declare class LaunchpadModule {
-    private http;
-    private auth;
-    constructor(http: HttpClient, auth: () => Promise<void>);
-    /**
-     * Get recently launched tokens on Arena.
-     * @param count - Number of tokens (max 50, default 10)
-     * @param type - Filter: "all", "avax" (AVAX-paired), or "arena" (ARENA-paired)
-     */
-    getRecent(count?: number, type?: "all" | "avax" | "arena"): Promise<LaunchpadListResponse>;
-    /**
-     * Search for a token by name, symbol, or contract address.
-     * @param q - Search query — name, symbol, or 0x contract address
-     */
-    search(q: string): Promise<LaunchpadListResponse | LaunchpadToken>;
-    /**
-     * Get tokens that are closest to graduating from the bonding curve to DEX.
-     * @param count - Number of tokens (max 20, default 5)
-     */
-    getGraduating(count?: number): Promise<LaunchpadListResponse>;
-    /**
-     * Get tokens that have already graduated from the bonding curve to DEX.
-     * @param count - Number of tokens (max 50, default 10)
-     */
-    getGraduated(count?: number): Promise<LaunchpadListResponse>;
-    /**
-     * Get top tokens by trading volume.
-     * @param timeframe - "5m", "1h", "4h", "24h", or "all_time"
-     * @param count - Number of tokens (max 50, default 10)
-     */
-    getTopVolume(timeframe?: "5m" | "1h" | "4h" | "24h" | "all_time", count?: number): Promise<LaunchpadListResponse & {
-        timeframe: string;
+declare class SignalsModule {
+    private assetCache;
+    private candleCache;
+    private hlPost;
+    /** Get all asset contexts (cached 10s) */
+    getAssetContexts(): Promise<{
+        meta: HlMeta[];
+        contexts: HlAssetCtx[];
     }>;
-    /**
-     * Get full token profile with stats — price, market cap, graduation progress, buy/sell activity.
-     * @param tokenId - Arena token ID
-     * @param address - Or token contract address (0x...)
-     */
-    getToken(tokenId?: string, address?: string): Promise<TokenDetailResponse>;
-    /**
-     * Get a buy or sell quote for a bonding curve token.
-     * @param tokenId - Arena token ID
-     * @param side - "buy" or "sell"
-     * @param amount - For buy: AVAX amount. For sell: token amount.
-     */
-    quote(tokenId: string, side: "buy" | "sell", amount: string): Promise<LaunchpadQuoteResponse>;
-    /**
-     * Get agent's tracked portfolio — all launchpad tokens the agent has bought.
-     * @param wallet - Agent wallet address
-     */
-    getPortfolio(wallet: string): Promise<unknown>;
-    /**
-     * Get market cap data for a token.
-     * @param tokenId - Arena token ID
-     */
-    getMarketCap(tokenId: string): Promise<unknown>;
-    /**
-     * Get recent trade activity for a token.
-     * @param tokenId - Arena token ID
-     * @param address - Or token contract address
-     * @param count - Number of trades (max 50, default 20)
-     */
-    getActivity(tokenId?: string, address?: string, count?: number): Promise<TokenActivityResponse>;
-    /**
-     * Get top holders for a token with PnL data.
-     * @param address - Token contract address
-     * @param tokenId - Or Arena token ID
-     * @param count - Number of holders (max 50, default 20)
-     */
-    getHolders(address?: string, tokenId?: string, count?: number): Promise<TokenHoldersResponse>;
-    /**
-     * Get platform overview — total tokens launched, contract addresses, stats.
-     */
-    getOverview(): Promise<unknown>;
-    /**
-     * Get the global trade feed across all launchpad tokens.
-     * @param count - Number of trades (max 100, default 50)
-     * @param offset - Pagination offset
-     */
-    getTrades(count?: number, offset?: number): Promise<GlobalTradesResponse>;
-    /**
-     * Launch a new token on Arena — uploads image, creates community, and returns the unsigned createToken transaction.
-     *
-     * @param wallet - Creator wallet address
-     * @param name - Token name (also used as community name)
-     * @param symbol - Token ticker symbol
-     * @param imageBase64 - Token image as base64 string (optional)
-     * @param paymentToken - "avax" or "arena" (default: "arena")
-     * @param initialBuyAvax - AVAX amount for initial buy at creation (default: "0")
-     */
-    launch(wallet: string, name: string, symbol: string, imageBase64?: string, paymentToken?: "avax" | "arena", initialBuyAvax?: string): Promise<LaunchTokenResponse>;
-    /**
-     * Upload a token image to Arena's CDN and get the hosted URL.
-     * Use this before launch() if you want to preview the image URL first.
-     *
-     * @param imageBase64 - Image as base64 string
-     * @param fileType - MIME type (default: "image/jpeg")
-     */
-    uploadImage(imageBase64: string, fileType?: string): Promise<UploadImageResponse>;
-    /**
-     * Build only the createToken transaction (no image or community creation).
-     * Useful if you want to handle image upload and community creation separately.
-     *
-     * @param wallet - Creator wallet address
-     * @param name - Token name
-     * @param symbol - Token ticker symbol
-     * @param paymentToken - "avax" or "arena" (default: "arena")
-     * @param initialBuyAvax - AVAX for initial buy (default: "0")
-     */
-    buildCreate(wallet: string, name: string, symbol: string, paymentToken?: "avax" | "arena", initialBuyAvax?: string): Promise<BuildCreateResponse>;
-    /**
-     * Build unsigned transaction to buy a launchpad token with AVAX.
-     *
-     * Auto-detects if the token is AVAX-paired or ARENA-paired and routes accordingly.
-     * If the token has graduated to DEX, returns transactions for DEX swap instead.
-     *
-     * @param wallet - Your wallet address
-     * @param tokenId - Arena token ID
-     * @param avax - Amount of AVAX to spend
-     * @param slippage - Slippage in basis points (default: 500 = 5%)
-     */
-    buildBuy(wallet: string, tokenId: string, avax: string, slippage?: number): Promise<LaunchpadBuyResponse>;
-    /**
-     * Build unsigned transaction(s) to sell a launchpad token.
-     *
-     * Returns approve + sell transactions. Execute in order.
-     * Use amount="max" to sell entire balance.
-     *
-     * If the token has graduated to DEX, returns transactions for DEX swap instead.
-     *
-     * @param wallet - Your wallet address
-     * @param tokenId - Arena token ID
-     * @param amount - Token amount to sell, or "max" for entire balance
-     * @param slippage - Slippage in basis points (default: 500 = 5%)
-     */
-    buildSell(wallet: string, tokenId: string, amount: string, slippage?: number): Promise<LaunchpadSellResponse>;
+    /** Get market signal for a specific asset */
+    getMarketSignal(coin: string): Promise<MarketSignal>;
+    /** Get funding rate extremes across all markets */
+    getFundingExtremes(count?: number): Promise<{
+        mostPositive: MarketSignal[];
+        mostNegative: MarketSignal[];
+    }>;
+    /** Get candle data for technical analysis (cached 60s) */
+    getCandles(coin: string, interval?: string, count?: number): Promise<number[][]>;
+    /** Compute technical signals from candle data */
+    getTechnicalSignal(coin: string, interval?: string): Promise<TechnicalSignal>;
+    /** Get whale positions from orderbook depth */
+    getWhalePositions(coin: string, minPositionUsd?: number): Promise<any[]>;
+    /** Full signal summary — everything an agent needs to decide */
+    summary(coin: string): Promise<SignalSummary>;
+    /** Scan for top trading opportunities */
+    scan(count?: number): Promise<SignalSummary[]>;
+    private getTopMovers;
+    private buildSignal;
+    private sma;
+    private rsi;
+    private intervalToMs;
 }
 
-declare class DexModule {
-    private http;
-    private auth;
-    constructor(http: HttpClient, auth: () => Promise<void>);
-    /**
-     * List all known tokens with addresses and decimals.
-     * You can also pass any contract address directly to other methods — not limited to this list.
-     */
-    getTokens(): Promise<DexTokensResponse>;
-    /**
-     * Get on-chain info for any token by contract address — name, symbol, decimals.
-     * @param address - Token contract address (0x...)
-     */
-    getTokenInfo(address: string): Promise<DexTokenInfoResponse>;
-    /**
-     * Quote a swap between any two tokens on Avalanche.
-     * @param from - Source token symbol or contract address
-     * @param to - Destination token symbol or contract address
-     * @param amount - Amount of source token to swap
-     */
-    quote(from: string, to: string, amount: string): Promise<DexQuoteResponse>;
-    /**
-     * Get the balance of any token for a wallet.
-     * @param wallet - Wallet address
-     * @param token - Token symbol or contract address
-     */
-    getBalance(wallet: string, token: string): Promise<DexBalanceResponse>;
-    /**
-     * Build unsigned transaction(s) to swap any token pair on Avalanche via LFJ/Pharaoh DEX.
-     *
-     * May return multiple transactions (approve + swap). Execute in order.
-     *
-     * @param wallet - Your wallet address
-     * @param from - Source token symbol or contract address
-     * @param to - Destination token symbol or contract address
-     * @param amount - Amount to swap, or "max" for entire balance
-     * @param slippage - Slippage tolerance in basis points (default: 500 = 5%)
-     */
-    buildSwap(wallet: string, from: string, to: string, amount: string, slippage?: number): Promise<DexSwapResponse>;
+interface PriceData {
+    [coinId: string]: {
+        usd: number;
+        usd_24h_change?: number;
+        usd_market_cap?: number;
+        usd_24h_vol?: number;
+    };
 }
-
-declare class PerpsModule {
-    private http;
-    private auth;
-    constructor(http: HttpClient, auth: () => Promise<void>);
-    /**
-     * Link your Arena API key to enable perps trading.
-     * One-time setup — after this, all /perp endpoints work automatically.
-     * @param arenaApiKey - Your Arena API key (from arena.social)
-     */
-    setup(arenaApiKey: string): Promise<PerpsSetupResponse>;
-    /** Register for perps trading on Hyperliquid */
-    register(): Promise<any>;
-    /** Check perps registration status */
-    getRegistrationStatus(): Promise<any>;
-    /** Get your Hyperliquid API wallet address */
-    getWalletAddress(): Promise<any>;
-    /** Check which auth steps are completed */
-    getAuthStatus(): Promise<any>;
-    /**
-     * Get EIP-712 payload for an auth step.
-     * @param step - Auth step: "accept-terms", "approve-agent", "set-referrer", "approve-builder-fee"
-     * @param body - Optional body (accept-terms requires mainWalletAddress)
-     */
-    getAuthPayload(step: string, body?: any): Promise<any>;
-    /**
-     * Submit signed EIP-712 payload for an auth step.
-     * @param step - Auth step
-     * @param body - Signed payload with signature and metadata
-     */
-    submitAuthSignature(step: string, body: any): Promise<any>;
-    /** Enable HIP-3 abstraction (automated, no signature needed) */
-    enableHip3(): Promise<any>;
-    /** Get all available perpetual trading pairs (250+ markets) */
-    getTradingPairs(): Promise<PerpsTradingPairsResponse>;
-    /**
-     * Update leverage for a market. Must be called before first order.
-     * @param symbol - Market symbol (e.g. "BTC", "ETH")
-     * @param leverage - Leverage multiplier (1-50 depending on market)
-     * @param leverageType - "cross" or "isolated"
-     */
-    updateLeverage(symbol: string, leverage: number, leverageType?: "cross" | "isolated"): Promise<any>;
-    /**
-     * Place one or more perpetual orders.
-     * @param orders - Array of order objects (see docs for BaseOrderParams)
-     */
-    placeOrder(orders: any[]): Promise<PerpsOrderResponse>;
-    /**
-     * Cancel one or more open orders.
-     * @param cancels - Array of { assetIndex, oid }
-     */
-    cancelOrders(cancels: {
-        assetIndex: number;
-        oid: number;
-    }[]): Promise<any>;
-    /**
-     * Modify an existing order.
-     * @param oid - Order ID to modify
-     * @param order - New order parameters
-     */
-    modifyOrder(oid: number, order: any): Promise<any>;
-    /**
-     * Close a position (convenience — creates reduce-only IOC with 10% slippage).
-     * @param symbol - Market symbol
-     * @param positionSide - "long" or "short"
-     * @param size - Position size to close
-     * @param currentPrice - Current market price
-     * @param closePercent - Percentage to close (default: 100)
-     */
-    closePosition(symbol: string, positionSide: "long" | "short", size: number, currentPrice: number, closePercent?: number): Promise<any>;
-    /** Get open orders */
-    getOrders(): Promise<any>;
-    /** Get trade execution history */
-    getTradeExecutions(): Promise<any>;
-    /**
-     * Get positions and margin summary (queries Hyperliquid directly).
-     * @param wallet - Your Hyperliquid wallet address (from getWalletAddress)
-     */
-    getPositions(wallet: string): Promise<PerpsPositionsResponse>;
-    /**
-     * Get open orders from Hyperliquid directly.
-     * @param wallet - Your Hyperliquid wallet address
-     */
-    getOpenOrders(wallet: string): Promise<any>;
+interface TrendingCoin {
+    id: string;
+    name: string;
+    symbol: string;
+    market_cap_rank: number;
+    thumb: string;
+    price_btc: number;
+}
+interface MarketEntry {
+    id: string;
+    symbol: string;
+    name: string;
+    current_price: number;
+    market_cap: number;
+    price_change_percentage_24h: number;
+    total_volume: number;
+    market_cap_rank: number;
+}
+declare class MarketModule {
+    /** Get prices for one or more coins (by CoinGecko ID) */
+    price(ids: string | string[]): Promise<PriceData>;
+    /** Get trending coins */
+    trending(): Promise<{
+        coins: TrendingCoin[];
+    }>;
+    /** Get top coins by market cap */
+    markets(count?: number, page?: number): Promise<{
+        coins: MarketEntry[];
+    }>;
+    /** Search for coins by query */
+    search(query: string): Promise<{
+        coins: Array<{
+            id: string;
+            name: string;
+            symbol: string;
+            market_cap_rank: number;
+        }>;
+    }>;
+    /** Get AVAX price specifically */
+    avaxPrice(): Promise<{
+        usd: number;
+        change24h: number;
+    }>;
+    /** Get ARENA price specifically */
+    arenaPrice(): Promise<{
+        usd: number;
+        change24h: number;
+    }>;
 }
 
-declare class BridgeModule {
-    private http;
-    private auth;
-    constructor(http: HttpClient, auth: () => Promise<void>);
-    /**
-     * Get all supported chains for cross-chain bridging.
-     */
-    getChains(): Promise<BridgeChainsResponse>;
-    /**
-     * Get tokens available on specified chains.
-     * @param chains - Comma-separated chain IDs (e.g. "43114,42161")
-     */
-    getTokens(chains: string): Promise<BridgeTokensResponse>;
-    /**
-     * Get info for a specific token on a chain.
-     * @param chainId - Chain ID
-     * @param address - Token contract address
-     */
-    getToken(chainId: number, address: string): Promise<BridgeTokenResponse>;
-    /**
-     * Get available bridge connections between two chains.
-     * @param fromChainId - Source chain ID
-     * @param toChainId - Destination chain ID
-     * @param fromToken - Optional source token address
-     * @param toToken - Optional destination token address
-     */
-    getConnections(fromChainId: number, toChainId: number, fromToken?: string, toToken?: string): Promise<BridgeConnectionsResponse>;
-    /**
-     * Get a bridge quote with unsigned transaction data.
-     * The agent signs the returned tx on the source chain.
-     *
-     * @param fromChainId - Source chain ID
-     * @param toChainId - Destination chain ID
-     * @param fromToken - Source token address (use 0x0000...0000 for native tokens)
-     * @param toToken - Destination token address
-     * @param fromAmount - Human-readable amount (e.g. "0.1")
-     * @param fromAddress - Sender wallet address
-     * @param toAddress - Optional receiver address (defaults to fromAddress)
-     * @param slippage - Slippage tolerance as decimal (default 0.03 = 3%)
-     * @param fromDecimals - Token decimals (default 18)
-     */
-    getQuote(fromChainId: number, toChainId: number, fromToken: string, toToken: string, fromAmount: string, fromAddress: string, toAddress?: string, slippage?: number, fromDecimals?: number): Promise<BridgeQuoteResponse>;
-    /**
-     * Get multiple bridge route options.
-     */
-    getRoutes(fromChainId: number, toChainId: number, fromToken: string, toToken: string, fromAmount: string, fromAddress: string, toAddress?: string, slippage?: number, fromDecimals?: number): Promise<BridgeRoutesResponse>;
-    /**
-     * Check bridge transfer status.
-     * @param txHash - Source chain transaction hash
-     * @param fromChainId - Source chain ID
-     * @param toChainId - Destination chain ID
-     * @param bridge - Optional bridge tool name
-     */
-    getStatus(txHash: string, fromChainId: number, toChainId: number, bridge?: string): Promise<BridgeStatusResponse>;
-    /**
-     * Get reference info — common chain IDs, USDC addresses, native token constant.
-     */
-    getInfo(): Promise<BridgeInfoResponse>;
+declare class DefiModule {
+    private provider;
+    private savax;
+    constructor(provider: JsonRpcProvider);
+    /** Get sAVAX staking info: exchange rate, total staked, your balance */
+    sAvaxInfo(wallet?: string): Promise<{
+        exchangeRate: string;
+        totalPooledAvax: string;
+        totalShares: string;
+        balance?: string;
+        balanceInAvax?: string;
+    }>;
+    /** Quote: how much sAVAX for staking AVAX */
+    sAvaxStakeQuote(avaxAmount: string): Promise<{
+        avaxIn: string;
+        savaxOut: string;
+    }>;
+    /** Build tx to stake AVAX → sAVAX */
+    buildSAvaxStake(avaxAmount: string): Promise<{
+        transactions: UnsignedTx[];
+    }>;
+    /** Build tx to request unstake sAVAX → AVAX (delayed) */
+    buildSAvaxUnstake(wallet: string, amount: string): Promise<{
+        transactions: UnsignedTx[];
+    }>;
+    /** Get info about any ERC-4626 vault */
+    vaultInfo(vaultAddress: string, wallet?: string): Promise<{
+        name: string;
+        symbol: string;
+        asset: string;
+        totalAssets: string;
+        totalSupply: string;
+        sharePrice: string;
+        userShares?: string;
+        userAssets?: string;
+    }>;
+    /** Quote vault deposit — how many shares for given assets */
+    vaultDepositQuote(vaultAddress: string, amount: string): Promise<{
+        assetsIn: string;
+        sharesOut: string;
+    }>;
+    /** Build txs to deposit into an ERC-4626 vault: [approve, deposit] */
+    buildVaultDeposit(wallet: string, vaultAddress: string, amount: string): Promise<{
+        transactions: UnsignedTx[];
+    }>;
+    /** Build tx to withdraw from an ERC-4626 vault */
+    buildVaultWithdraw(wallet: string, vaultAddress: string, amount: string): Promise<{
+        transactions: UnsignedTx[];
+    }>;
 }
 
 interface LogiqicalConfig {
-    /** Your wallet address — used for auto-registration */
-    wallet: string;
-    /** Existing API key (skips auto-registration if provided) */
-    apiKey?: string;
-    /** Custom base URL (defaults to Logiqical production API) */
-    baseUrl?: string;
-    /** Agent display name for registration */
+    /** Private key — creates a local wallet for signing (0x-prefixed hex) */
+    privateKey?: string;
+    /** Mnemonic phrase — derives wallet from HD path */
+    mnemonic?: string;
+    /** Wallet address (required if no privateKey/mnemonic) */
+    wallet?: string;
+    /** Arena API key for social, perps, tickets endpoints */
+    arenaApiKey?: string;
+    /** Network name from chain registry (default: "avalanche") */
+    network?: string;
+    /** Custom RPC URL (overrides network) */
+    rpcUrl?: string;
+    /** Agent display name */
     name?: string;
+    /** Password for keystore encryption (default: "logiqical-agent") */
+    password?: string;
+    /** Spending policy — per-tx limits, budgets, allowlists, simulation */
+    policy?: SpendingPolicy;
 }
 /**
- * Logiqical SDK client — the complete toolkit for AI agents trading on Avalanche.
+ * Logiqical — standalone agent wallet SDK for Avalanche + Arena.
  *
  * ```ts
- * import { LogiqicalClient } from "logiqical";
+ * import { Logiqical } from "logiqical";
  *
- * const client = new LogiqicalClient({ wallet: "0xYourWallet" });
+ * const agent = await Logiqical.boot({
+ *   policy: { maxPerTx: "1.0", maxPerDay: "10.0", simulateBeforeSend: true },
+ * });
  *
- * // Auto-registers on first call — no setup needed
- * const balances = await client.swap.getBalances("0xYourWallet");
- * const tokens = await client.launchpad.getRecent(10);
- * const tx = await client.dex.buildSwap("0xWallet", "AVAX", "USDC", "1.0");
+ * // One-liner: policy check + simulate + sign + broadcast
+ * await agent.execute(agent.dex.buildSwap(agent.address, "AVAX", "USDC", "1.0"));
  * ```
  */
-declare class LogiqicalClient {
+declare class Logiqical {
     /** Buy/sell ARENA tokens via LFJ DEX */
     readonly swap: SwapModule;
     /** Stake ARENA tokens for rewards */
     readonly staking: StakingModule;
     /** Discover, research, and trade launchpad tokens on bonding curves */
     readonly launchpad: LaunchpadModule;
-    /** Swap any Avalanche token via LFJ + Arena DEX */
+    /** Swap any Avalanche token via LFJ DEX */
     readonly dex: DexModule;
     /** Trade perpetual futures on Hyperliquid via Arena */
     readonly perps: PerpsModule;
-    /** Cross-chain token bridging via Li.Fi — any token, any chain */
+    /** Cross-chain token bridging via Li.Fi */
     readonly bridge: BridgeModule;
-    private http;
-    private wallet;
-    private agentName;
-    private registrationPromise;
+    /** Buy/sell Arena tickets */
+    readonly tickets: TicketsModule;
+    /** Arena social: chat, DMs, posts, follow, user discovery */
+    readonly social: SocialModule;
+    /** Market signals intelligence — scan, funding rates, whale tracking */
+    readonly signals: SignalsModule;
+    /** Market data — prices, trending, top coins via CoinGecko */
+    readonly market: MarketModule;
+    /** DeFi — sAVAX liquid staking + ERC-4626 vaults */
+    readonly defi: DefiModule;
+    /** The agent's wallet address */
+    readonly address: string;
+    /** The local wallet (null if read-only mode) */
+    readonly agentWallet: AgentWallet | null;
+    /** The JSON-RPC provider for direct chain reads */
+    readonly provider: JsonRpcProvider;
+    /** The spending policy engine */
+    readonly policyEngine: PolicyEngine;
+    private config;
     constructor(config: LogiqicalConfig);
-    /** The API key (available after first call or if provided in config) */
-    get apiKey(): string | null;
-    /**
-     * Broadcast a signed transaction to the Avalanche network.
-     * @param signedTx - Signed transaction hex string
-     * @returns Transaction hash
-     */
-    broadcast(signedTx: string): Promise<BroadcastResponse>;
-    /**
-     * Get the full agent instructions document — describes all available capabilities.
-     */
-    getInstructions(): Promise<string>;
-    /**
-     * Check if the API is healthy and responsive.
-     */
-    health(): Promise<HealthResponse>;
-    /**
-     * Manually register and get an API key.
-     * Usually not needed — the client auto-registers on first call.
-     */
-    register(): Promise<RegisterResponse>;
-    private ensureRegistered;
-}
+    /** Generate a brand new agent wallet */
+    static generate(config?: Omit<LogiqicalConfig, "privateKey" | "mnemonic" | "wallet">): Logiqical;
+    /** Boot from encrypted keystore — creates wallet on first run, loads on subsequent runs */
+    static boot(config?: Omit<LogiqicalConfig, "privateKey" | "mnemonic" | "wallet"> & {
+        keystoreName?: string;
+    }): Promise<Logiqical>;
+    /**
+     * Execute any module result — policy check + simulate + sign + broadcast.
+     *
+     * ```ts
+     * await agent.execute(agent.dex.buildSwap(agent.address, "AVAX", "USDC", "1.0"));
+     * await agent.execute(agent.launchpad.buildBuy(agent.address, "42", "0.5"));
+     * ```
+     */
+    execute(resultOrPromise: Promise<{
+        transactions?: UnsignedTx[];
+        transaction?: UnsignedTx;
+        [key: string]: any;
+    }> | {
+        transactions?: UnsignedTx[];
+        transaction?: UnsignedTx;
+        [key: string]: any;
+    }, confirmations?: number): Promise<TransactionResult[]>;
+    /**
+     * Call any smart contract method — policy check + simulate + sign + broadcast.
+     *
+     * ```ts
+     * await agent.call({
+     *   contract: "0x...",
+     *   abi: ["function transfer(address,uint256) returns (bool)"],
+     *   method: "transfer",
+     *   args: ["0xRecipient", ethers.parseUnits("100", 18)],
+     * });
+     * ```
+     */
+    call(intent: CallIntent): Promise<TransactionResult>;
+    /** Send native token (AVAX) — policy check + simulate + sign + broadcast */
+    send(to: string, amount: string): Promise<TransactionResult>;
+    /** Simulate a transaction via eth_call — throws PolicyError if it would revert */
+    simulate(tx: UnsignedTx): Promise<void>;
+    /** Get the current spending policy */
+    getPolicy(): SpendingPolicy;
+    /** Replace the entire spending policy */
+    setPolicy(policy: SpendingPolicy): void;
+    /** Update specific policy fields */
+    updatePolicy(updates: Partial<SpendingPolicy>): void;
+    /** Get budget status: spent this hour, today, remaining */
+    getBudgetStatus(): {
+        spentLastHour: string;
+        spentLast24h: string;
+        remainingHour: string | null;
+        remainingDay: string | null;
+    };
+    /** Check if this client has a local wallet for signing */
+    get canSign(): boolean;
+    /** The private key (only available in wallet mode) */
+    get privateKey(): string;
+    /** Get native token balance (formatted) */
+    getBalance(): Promise<string>;
+    /** Sign a message */
+    signMessage(message: string): Promise<string>;
+    /** Sign EIP-712 typed data */
+    signTypedData(domain: any, types: any, value: any): Promise<string>;
+    /** Switch to a different network (returns new Logiqical instance with same keys) */
+    switchNetwork(network: string): Logiqical;
+    /** Save the wallet to an encrypted keystore file */
+    saveKeystore(password?: string, name?: string): Promise<string>;
+    /** Sign and broadcast a single unsigned tx — bypasses policy engine */
+    signAndBroadcast(unsignedTx: UnsignedTx): Promise<TransactionResponse>;
+    /** Sign and broadcast multiple unsigned txs — bypasses policy engine */
+    signAndBroadcastAll(unsignedTxs: UnsignedTx[], confirmations?: number): Promise<TransactionResponse[]>;
+    private requireWallet;
+    private static resolveProvider;
+}
+/** @deprecated Use `Logiqical` instead */
+declare const LogiqicalClient: typeof Logiqical;
 
-/** Error returned by the Logiqical API */
+type LogiqicalErrorCode = "INSUFFICIENT_BALANCE" | "SLIPPAGE_EXCEEDED" | "TOKEN_NOT_FOUND" | "CONTRACT_REVERT" | "NO_LIQUIDITY" | "TX_FAILED" | "INVALID_ADDRESS" | "INVALID_AMOUNT" | "NO_WALLET" | "NETWORK_ERROR" | "API_ERROR" | "UNKNOWN";
 declare class LogiqicalError extends Error {
-    readonly statusCode: number;
-    readonly endpoint: string;
-    constructor(message: string, statusCode: number, endpoint: string);
-}
-/** Authentication error — invalid or missing API key */
-declare class LogiqicalAuthError extends LogiqicalError {
-    constructor(endpoint: string);
+    readonly code: LogiqicalErrorCode;
+    readonly cause?: Error | undefined;
+    constructor(message: string, code: LogiqicalErrorCode, cause?: Error | undefined);
+    static from(e: unknown, code?: LogiqicalErrorCode): LogiqicalError;
 }
 
-export { type ArenaCommunity, type BalancesResponse, type BridgeChainsResponse, type BridgeConnectionsResponse, type BridgeInfoResponse, type BridgeLiFiChain, type BridgeLiFiToken, BridgeModule, type BridgeQuoteResponse, type BridgeRoutesResponse, type BridgeStatusResponse, type BridgeTokenResponse, type BridgeTokensResponse, type BridgeTransaction, type BroadcastResponse, type BuildCreateResponse, type BuyQuoteResponse, type DexBalanceResponse, DexModule, type DexQuoteResponse, type DexSwapResponse, type DexTokenEntry, type DexTokenInfoResponse, type DexTokensResponse, type GlobalTradeEntry, type GlobalTradesResponse, type HealthResponse, type HolderEntry, type LaunchTokenResponse, type LaunchpadBuyResponse, type LaunchpadListResponse, LaunchpadModule, type LaunchpadQuoteResponse, type LaunchpadSellResponse, type LaunchpadToken, LogiqicalAuthError, LogiqicalClient, type LogiqicalConfig, LogiqicalError, PerpsModule, type PerpsOrderResponse, type PerpsPositionsResponse, type PerpsSetupResponse, type PerpsTradingPair, type PerpsTradingPairsResponse, type RegisterResponse, type SellQuoteResponse, type StakeBuildResponse, type StakeInfoResponse, StakingModule, type SwapBuyResponse, SwapModule, type SwapSellResponse, type TokenActivityResponse, type TokenCreator, type TokenDetailResponse, type TokenHoldersResponse, type TokenStatsTimeframes, type TradeEntry, type UnsignedTx, type UploadImageResponse };
+export { AgentWallet, type AgentWalletConfig, BridgeModule, CHAINS, type CallIntent, type ChainConfig, DefiModule, DexModule, LaunchpadModule, Logiqical, LogiqicalClient, type LogiqicalConfig, LogiqicalError, type LogiqicalErrorCode, MarketModule, type MarketSignal, PerpsModule, PolicyEngine, PolicyError, type PolicyErrorCode, type SignalSummary, SignalsModule, SocialModule, type SpendingPolicy, StakingModule, SwapModule, type TechnicalSignal, type TicketBalanceResponse, type TicketFeesResponse, type TicketPriceResponse, type TicketSupplyResponse, TicketsModule, type TransactionResult, type UnsignedTx };