@pear-protocol/symmio-client 0.1.0 → 0.1.2

package/dist/react/index.d.mts

@@ -0,0 +1,741 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as viem from 'viem';
+import { Address, Hex, PublicClient, WalletClient } from 'viem';
+import * as _pear_protocol_symm_core from '@pear-protocol/symm-core';
+import { SymmSDK, OpenBasketPositionRequest, ClosePositionRequest, CancelOpenRequest, UpdatePositionRequest, SetTpslRequest, CancelTpslRequest } from '@pear-protocol/symm-core';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import * as _tanstack_query_core from '@tanstack/query-core';
+import * as node_modules__pear_protocol_symm_core_dist_types from 'node_modules/@pear-protocol/symm-core/dist/types';
+import * as _pear_protocol_symm_shared from '@pear-protocol/symm-shared';
+
+type ChainId = number;
+type SymmioSDKConfig = {
+    chainId: ChainId;
+    multiAccountAddress?: Address;
+    symmioDiamondAddress?: Address;
+    collateralAddress?: Address;
+    clearingHouseAddress?: Address;
+    signatureStoreAddress?: Address;
+    muonBaseUrls?: string[];
+    muonAppName?: string;
+};
+declare enum PositionType {
+    LONG = 0,
+    SHORT = 1
+}
+declare enum OrderType {
+    LIMIT = 0,
+    MARKET = 1
+}
+
+type SymmProviderProps = {
+    chainId?: number;
+    symmCoreConfig: {
+        apiUrl: string;
+        wsUrl?: string;
+    };
+    symmioConfig?: Partial<SymmioSDKConfig>;
+    siweDomain?: string;
+    children: React.ReactNode;
+};
+declare function SymmProvider({ chainId: configChainId, symmCoreConfig, symmioConfig, siweDomain, children, }: SymmProviderProps): react_jsx_runtime.JSX.Element;
+
+type Account = {
+    accountAddress: Address;
+    name: string;
+};
+
+type SchnorrSign = {
+    signature: bigint;
+    owner: Address;
+    nonce: Address;
+};
+type MuonSingleUpnlSig = {
+    reqId: Hex;
+    timestamp: bigint;
+    upnl: bigint;
+    gatewaySignature: Hex;
+    sigs: SchnorrSign;
+};
+type MuonSingleUpnlAndPriceSig = {
+    reqId: Hex;
+    timestamp: bigint;
+    upnl: bigint;
+    price: bigint;
+    gatewaySignature: Hex;
+    sigs: SchnorrSign;
+};
+type MuonBatchSig = {
+    reqId: Hex;
+    timestamp: bigint;
+    upnl: bigint;
+    prices: bigint[];
+    symbolIds: bigint[];
+    gatewaySignature: Hex;
+    sigs: SchnorrSign;
+};
+type MuonClientConfig = {
+    baseUrls: string[];
+    appName: string;
+    timeout?: number;
+};
+type MuonQuoteParams = {
+    partyA: Address;
+    chainId: number;
+    symmioAddress: Address;
+    symbolId: number;
+};
+type MuonDeallocateParams = {
+    partyA: Address;
+    chainId: number;
+    symmioAddress: Address;
+};
+type MuonBatchParams = {
+    partyA: Address;
+    chainId: number;
+    symmioAddress: Address;
+    symbolIds: number[];
+};
+
+type DepositParams = {
+    account: Address;
+    amount: bigint;
+};
+type DepositAndAllocateParams = {
+    account: Address;
+    amount: bigint;
+};
+type WithdrawParams = {
+    account: Address;
+    amount: bigint;
+};
+type AllocateParams = {
+    amount: bigint;
+};
+type DeallocateParams = {
+    amount: bigint;
+    upnlSig: MuonSingleUpnlSig;
+};
+type InternalTransferParams = {
+    recipient: Address;
+    amount: bigint;
+};
+
+type SendQuoteParams = {
+    partyBsWhiteList: Address[];
+    symbolId: number;
+    positionType: PositionType;
+    orderType: OrderType;
+    price: bigint;
+    quantity: bigint;
+    cva: bigint;
+    lf: bigint;
+    partyAmm: bigint;
+    partyBmm: bigint;
+    maxFundingRate: bigint;
+    deadline: bigint;
+    affiliate: Address;
+    upnlSig: MuonSingleUpnlAndPriceSig;
+};
+type ClosePositionParams = {
+    quoteId: bigint;
+    closePrice: bigint;
+    quantityToClose: bigint;
+    orderType: OrderType;
+    deadline: bigint;
+};
+
+type CreateSiweMessageParams = {
+    address: Address;
+    statement: string;
+    chainId: number;
+    nonce: string;
+    domain: string;
+    uri: string;
+    version?: string;
+};
+type SiweMessageResult = {
+    message: string;
+    issuedAt: string;
+    expirationTime: string;
+};
+type InstantLoginParams = {
+    accountAddress: Address;
+    signature: string;
+    expirationTime: string;
+    issuedAt: string;
+    nonce: string;
+};
+type InstantAuthToken = {
+    accessToken: string;
+    expirationTime: string;
+    issuedAt: string;
+};
+type InstantOpenParams = {
+    symbolId: number;
+    positionType: number;
+    orderType: number;
+    price: string;
+    quantity: string;
+    cva: string;
+    lf: string;
+    partyAmm: string;
+    partyBmm: string;
+    maxFundingRate: string;
+    deadline: number;
+};
+type InstantOpenResponse = {
+    successful: string;
+    message: string;
+};
+type InstantCloseParams = {
+    quoteId: string;
+    quantityToClose: string;
+    closePrice: string;
+};
+type InstantCloseResponse = {
+    successful: string;
+    message: string;
+};
+
+declare class MuonClient {
+    private baseUrls;
+    private appName;
+    private timeout;
+    constructor(config?: Partial<MuonClientConfig>);
+    /**
+     * Sends a request to Muon, trying each base URL in order until one succeeds.
+     */
+    private sendRequest;
+    /**
+     * Gets a UPnL + Price signature for opening a position (sendQuote).
+     */
+    getQuoteSig(params: MuonQuoteParams): Promise<MuonSingleUpnlAndPriceSig>;
+    /**
+     * Gets a UPnL signature for deallocating funds.
+     * v0.8.5: Now includes pendingBalance for safe deallocate.
+     */
+    getDeallocateSig(params: MuonDeallocateParams): Promise<MuonSingleUpnlSig>;
+    /**
+     * Gets a batch signature for multiple positions (v0.8.5).
+     * Single signature covers multiple symbol prices for batch open/close.
+     */
+    getBatchSig(params: MuonBatchParams): Promise<MuonBatchSig>;
+}
+
+declare enum ApprovalState {
+    UNKNOWN = "UNKNOWN",
+    NOT_APPROVED = "NOT_APPROVED",
+    PENDING = "PENDING",
+    APPROVED = "APPROVED"
+}
+
+type DelegateAccessParams = {
+    account: Address;
+    target: Address;
+    selectors: Hex[];
+    activate: boolean;
+};
+type ProposeRevokeParams = {
+    account: Address;
+    target: Address;
+    selectors: Hex[];
+};
+type RevokeAccessParams = {
+    account: Address;
+    target: Address;
+    selectors: Hex[];
+};
+
+/**
+ * SymmioSDK — Main client for Symmio protocol.
+ *
+ * Provides a unified, ergonomic API over all protocol actions:
+ * account management (via MultiAccount), deposits/withdrawals,
+ * allocation/deallocation, trading, delegation, and administrative operations.
+ *
+ * @example
+ * ```ts
+ * import { SymmioSDK } from '@pear-protocol/symmio-client';
+ * import { createPublicClient, createWalletClient, http } from 'viem';
+ * import { arbitrum } from 'viem/chains';
+ *
+ * const sdk = new SymmioSDK({
+ *   chainId: 42161,
+ *   publicClient: createPublicClient({ chain: arbitrum, transport: http() }),
+ *   walletClient: myWalletClient,
+ * });
+ *
+ * // Create an account
+ * const hash = await sdk.account.addAccount('Main Trading');
+ *
+ * // Deposit and allocate
+ * await sdk.deposit.depositAndAllocate({ account: '0x...', amount: 100000000n });
+ *
+ * // Open a position
+ * await sdk.trade.sendQuote('0x...account', { ... });
+ * ```
+ */
+declare class SymmioSDK {
+    readonly chainId: number;
+    readonly muon: MuonClient;
+    private _publicClient;
+    private _walletClient;
+    private _multiAccount;
+    private _symmioDiamond;
+    private _collateral;
+    private _clearingHouse?;
+    private _signatureStore?;
+    constructor(options: {
+        chainId: number;
+        publicClient: PublicClient;
+        walletClient: WalletClient;
+        config?: Partial<SymmioSDKConfig>;
+    });
+    get addresses(): {
+        multiAccount: `0x${string}`;
+        symmioDiamond: `0x${string}`;
+        collateral: `0x${string}`;
+        clearingHouse: `0x${string}` | undefined;
+        signatureStore: `0x${string}` | undefined;
+    };
+    get account(): {
+        /** Creates a new account. */
+        addAccount: (name: string) => Promise<`0x${string}`>;
+        /** Edits an account's name. */
+        editName: (accountAddress: Address, name: string) => Promise<`0x${string}`>;
+        /** Gets all accounts for a user (paginated). */
+        getAll: (user: Address, start?: number, size?: number) => Promise<Account[]>;
+        /** Gets the number of accounts for a user. */
+        getCount: (user: Address) => Promise<number>;
+        /** Gets the owner of an account. */
+        getOwner: (accountAddress: Address) => Promise<`0x${string}`>;
+    };
+    get deposit(): {
+        /** Standard deposit to an account. */
+        standard: (params: DepositParams) => Promise<`0x${string}`>;
+        /** Deposit and allocate in a single transaction. */
+        depositAndAllocate: (params: DepositAndAllocateParams) => Promise<`0x${string}`>;
+    };
+    get withdraw(): {
+        /** Withdraws collateral from an account. */
+        withdraw: (params: WithdrawParams) => Promise<`0x${string}`>;
+    };
+    get collateral(): {
+        /** Allocate collateral to a trading account. */
+        allocate: (subAccount: Address, params: AllocateParams) => Promise<`0x${string}`>;
+        /** Deallocate collateral (requires Muon signature). */
+        deallocate: (subAccount: Address, params: DeallocateParams) => Promise<`0x${string}`>;
+        /** Transfer funds to recipient's allocated balance. */
+        internalTransfer: (subAccount: Address, params: InternalTransferParams) => Promise<`0x${string}`>;
+    };
+    get trade(): {
+        /** Opens a position via sendQuoteWithAffiliate. */
+        sendQuote: (subAccount: Address, params: SendQuoteParams) => Promise<`0x${string}`>;
+        /** Close a position. */
+        closePosition: (subAccount: Address, params: ClosePositionParams) => Promise<`0x${string}`>;
+        /** Cancel a pending quote. */
+        cancelQuote: (subAccount: Address, quoteId: bigint) => Promise<`0x${string}`>;
+        /** Cancel a pending close request. */
+        cancelCloseRequest: (subAccount: Address, quoteId: bigint) => Promise<`0x${string}`>;
+        /** Force cancel a quote. */
+        forceCancelQuote: (subAccount: Address, quoteId: bigint) => Promise<`0x${string}`>;
+        /** Force cancel a close request. */
+        forceCancelCloseRequest: (subAccount: Address, quoteId: bigint) => Promise<`0x${string}`>;
+    };
+    get approval(): {
+        /** Approve the MultiAccount contract to spend collateral. */
+        approveCollateral: (amount: bigint) => Promise<`0x${string}`>;
+        /** Approve any spender for any token. */
+        approve: (token: Address, spender: Address, amount: bigint) => Promise<`0x${string}`>;
+        /** Get current allowance. */
+        getAllowance: (token: Address, owner: Address, spender: Address) => Promise<bigint>;
+        /** Get token balance. */
+        getBalance: (token: Address, account: Address) => Promise<bigint>;
+        /** Get approval state for a required amount. */
+        getState: (token: Address, owner: Address, spender: Address, requiredAmount: bigint) => Promise<ApprovalState>;
+    };
+    get delegation(): {
+        /** Delegate access to selectors. */
+        delegateAccess: (params: DelegateAccessParams) => Promise<`0x${string}`>;
+        /** Propose to revoke delegated access (starts cooldown). */
+        proposeRevoke: (params: ProposeRevokeParams) => Promise<`0x${string}`>;
+        /** Revoke delegated access (after cooldown). */
+        revokeAccess: (params: RevokeAccessParams) => Promise<`0x${string}`>;
+    };
+    get signature(): {
+        signTerms: () => Promise<`0x${string}`>;
+        storeSignature: (sig: Hex) => Promise<`0x${string}`>;
+        hasSigned: (user: Address) => Promise<boolean>;
+        getMessage: () => Promise<string>;
+    };
+    get admin(): {
+        grantRole: (role: Hex, grantee: Address) => Promise<`0x${string}`>;
+        revokeRole: (role: Hex, revokee: Address) => Promise<`0x${string}`>;
+    };
+    get instant(): {
+        /** Creates a SIWE message for instant trading authentication. */
+        createSiweMessage: (params: CreateSiweMessageParams) => SiweMessageResult;
+        /** Fetches a nonce from the hedger for SIWE authentication. */
+        getNonce: (subAccount: Address) => Promise<string>;
+        /** Exchanges a signed SIWE message for an access token. */
+        login: (params: InstantLoginParams) => Promise<InstantAuthToken>;
+        /** Opens a position instantly via the hedger (off-chain). */
+        open: (params: InstantOpenParams, accessToken: string) => Promise<InstantOpenResponse>;
+        /** Closes a position instantly via the hedger (off-chain). */
+        close: (params: InstantCloseParams, accessToken: string) => Promise<InstantCloseResponse>;
+        /** Cancels a pending instant close request. */
+        cancelClose: (quoteId: string, accessToken: string) => Promise<void>;
+        /** Fetches the list of open instant close requests for an account. */
+        getOpenCloses: (account: Address, accessToken: string) => Promise<unknown[]>;
+    };
+    getQuoteSig(partyA: Address, symbolId: number): Promise<MuonSingleUpnlAndPriceSig>;
+    getDeallocateSig(partyA: Address): Promise<MuonSingleUpnlSig>;
+}
+
+type SymmContextValue = {
+    symmioClient: SymmioSDK | null;
+    symmCoreClient: SymmSDK | null;
+    chainId: number;
+    address?: `0x${string}`;
+    accessToken: string | null;
+    authToken: string | null;
+    isReady: boolean;
+    refreshAuth: (accountAddress?: Address) => Promise<string | null>;
+};
+declare function useSymmContext(): SymmContextValue;
+
+declare function useSymmioClient(): SymmioSDK | null;
+
+declare function useSymmCoreClient(): SymmSDK | null;
+
+declare function useSymmAuth(): {
+    accessToken: string | null;
+    authToken: string | null;
+    isAuthenticated: boolean;
+    refresh: (accountAddress?: viem.Address) => Promise<string | null>;
+};
+
+declare function useSymmAccounts(userAddress?: Address): {
+    accounts: Account[];
+    count: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<Account[], Error>>;
+    createAccount: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        name: string;
+    }, unknown>;
+    editName: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        accountAddress: Address;
+        name: string;
+    }, unknown>;
+};
+
+declare function useSymmApproval(params: {
+    owner?: Address;
+    amount: bigint;
+    spender?: Address;
+    collateralToken?: Address;
+}): {
+    approvalState: ApprovalState | null;
+    allowance: bigint;
+    balance: bigint;
+    isLoading: boolean;
+    approve: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, bigint, unknown>;
+};
+
+declare function useSymmDeposit(): {
+    deposit: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        account: Address;
+        amount: bigint;
+    }, unknown>;
+    depositAndAllocate: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        account: Address;
+        amount: bigint;
+    }, unknown>;
+};
+
+declare function useSymmWithdraw(): {
+    withdraw: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        account: Address;
+        amount: bigint;
+    }, unknown>;
+};
+
+declare function useSymmCollateral(): {
+    allocate: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        subAccount: Address;
+        amount: bigint;
+    }, unknown>;
+    deallocate: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        subAccount: Address;
+        amount: bigint;
+    }, unknown>;
+    internalTransfer: _tanstack_react_query.UseMutationResult<`0x${string}`, Error, {
+        subAccount: Address;
+        params: InternalTransferParams;
+    }, unknown>;
+};
+
+declare function useSymmSignature(userAddress?: Address): {
+    hasSigned: boolean;
+    isLoading: boolean;
+    signTerms: _tanstack_react_query.UseMutationResult<void, Error, void, unknown>;
+};
+
+declare function useSymmBalances(params: {
+    userAddress?: Address;
+    chainId?: number;
+    multiAccountAddress?: Address;
+}): {
+    balanceInfo: node_modules__pear_protocol_symm_core_dist_types.BalanceInfoResponse | null;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<node_modules__pear_protocol_symm_core_dist_types.BalanceInfoResponse, Error>>;
+};
+
+declare function useSymmTrade(): {
+    openBasket: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.BasketOpenResponse | _pear_protocol_symm_core.OpenBasketCommandResult, Error, OpenBasketPositionRequest, unknown>;
+    closePosition: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.ClosePositionResponse | _pear_protocol_symm_core.CloseCommandResult, Error, ClosePositionRequest, unknown>;
+    closeAll: _tanstack_react_query.UseMutationResult<node_modules__pear_protocol_symm_core_dist_types.CloseAllPositionsResponse, Error, Omit<node_modules__pear_protocol_symm_core_dist_types.CloseAllPositionsRequest, "chainId"> & {
+        chainId?: number;
+    }, unknown>;
+    cancelOpen: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_shared.ApiResponse<unknown>, Error, CancelOpenRequest, unknown>;
+    updatePosition: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.UpdatePositionResponse, Error, {
+        positionId: string;
+        request: UpdatePositionRequest;
+    }, unknown>;
+};
+
+declare function useSymmPositions(params: {
+    accountAddress?: Address;
+    mainAddress?: Address;
+    chainId?: number;
+}): {
+    positions: _pear_protocol_symm_core.OpenPositionDto[];
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.OpenPositionsListResponse, Error>>;
+};
+
+declare function useSymmOpenOrders(params: {
+    accountAddress?: Address;
+    mainAddress?: Address;
+    chainId?: number;
+}): {
+    orders: _pear_protocol_symm_core.UnifiedOrderItem[];
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.UnifiedOrdersListResponse, Error>>;
+};
+
+declare function useSymmTradeHistory(params: {
+    accountAddress?: Address;
+    mainAddress?: Address;
+    chainId?: number;
+}): {
+    trades: _pear_protocol_symm_shared.ApiResponse<unknown> | null;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_shared.ApiResponse<unknown>, Error>>;
+};
+
+declare function useSymmTpsl(): {
+    setTpsl: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.TpslUpdateResponse, Error, SetTpslRequest, unknown>;
+    cancelTpsl: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_shared.ApiResponse<unknown>, Error, CancelTpslRequest, unknown>;
+};
+
+declare function useSymmTwap(params: {
+    accountAddress?: Address;
+    mainAddress?: Address;
+    chainId?: number;
+}): {
+    twapOrders: node_modules__pear_protocol_symm_core_dist_types.TwapOrder[];
+    isLoading: boolean;
+    cancelTwap: _tanstack_react_query.UseMutationResult<node_modules__pear_protocol_symm_core_dist_types.TwapOrderResponse, Error, string, unknown>;
+};
+
+declare function useSymmMarkets(params?: {
+    chainId?: number;
+    searchText?: string;
+}): {
+    markets: _pear_protocol_symm_core.MarketGroupItem[];
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.MarketsResponse, Error>>;
+};
+
+declare function useSymmFunding(params?: {
+    chainId?: number;
+}): {
+    rates: node_modules__pear_protocol_symm_core_dist_types.FundingRate[];
+    isLoading: boolean;
+};
+
+declare function useSymmPortfolio(params: {
+    accountAddress?: Address;
+    mainAddress?: Address;
+    chainId?: number;
+}): {
+    metrics: _pear_protocol_symm_core.PortfolioResponse | null;
+    isLoading: boolean;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.PortfolioResponse, Error>>;
+};
+
+declare function useSymmNotifications(params: {
+    userAddress?: Address;
+    chainId?: number;
+}): {
+    notifications: _pear_protocol_symm_core.Notification[];
+    unreadCount: number;
+    isLoading: boolean;
+    markRead: _tanstack_react_query.UseMutationResult<_pear_protocol_symm_core.MarkReadResponse, Error, {
+        id?: string;
+        timestamp?: number;
+    }, unknown>;
+    refetch: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<_pear_protocol_symm_core.NotificationsResponse, Error>>;
+};
+
+declare function useSymmWs(params: {
+    accountAddress?: Address;
+    chainId?: number;
+}): {
+    isConnected: boolean;
+};
+
+interface SymmChartSelectionInput {
+    longSymbol: string | null;
+    shortSymbol: string | null;
+    longWeight?: number;
+    shortWeight?: number;
+    longTokens?: SymmChartTokenSelection[];
+    shortTokens?: SymmChartTokenSelection[];
+}
+interface SymmChartTokenSelection {
+    symbol: string;
+    weight: number;
+}
+interface SymmChartSelection {
+    longTokens: SymmChartTokenSelection[];
+    shortTokens: SymmChartTokenSelection[];
+    isSingleSided: boolean;
+    activeSide: 'long' | 'short' | null;
+    activeTokenSymbol?: string;
+    pairLabel: string;
+    selectedSymbols: string[];
+}
+/**
+ * SYMM chart selection hook. Accepts selection input as parameters
+ * rather than importing app store state, keeping the SDK app-agnostic.
+ */
+declare function useSymmChartSelection(input: SymmChartSelectionInput): SymmChartSelection;
+
+interface SymmTokenMetadata {
+    currentPrice: number;
+    prevDayPrice: number;
+    priceChange24h: number;
+    priceChange24hPercent: number;
+    netFunding: number;
+    markPrice: number;
+}
+interface UseSymmTokenSelectionMetadataReturn {
+    isLoading: boolean;
+    isPriceDataReady: boolean;
+    isUnsupported: boolean;
+    unsupportedSymbols: string[];
+    unavailableReason: string | null;
+    longTokensMetadata: Record<string, SymmTokenMetadata | null>;
+    shortTokensMetadata: Record<string, SymmTokenMetadata | null>;
+    weightedRatio: number;
+    weightedRatio24h: number;
+    priceRatio: number;
+    priceRatio24h: number;
+    sumNetFunding: number;
+}
+/**
+ * Fetches Binance market data for selected SYMM chart tokens and derives
+ * chart header metrics (price ratio, weighted ratio, etc.).
+ */
+declare function useSymmTokenSelectionMetadata(selection: SymmChartSelection): UseSymmTokenSelectionMetadataReturn;
+
+/**
+ * Candle interval type matching the chart system.
+ * Binance USD-M Futures uses the same string format.
+ */
+type CandleInterval = '1m' | '3m' | '5m' | '15m' | '30m' | '1h' | '2h' | '4h' | '8h' | '12h' | '1d' | '3d' | '1w' | '1M';
+
+interface ChartCandleData {
+    s?: string;
+    t: number;
+    T: number;
+    o: number;
+    c: number;
+    h: number;
+    l: number;
+}
+type RealtimeBar = {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume?: number;
+};
+type RealtimeBarsCallback = (bar: RealtimeBar) => void;
+interface UseSymmChartCandlesReturn {
+    fetchBasketCandles: (start: number, end: number, interval: CandleInterval) => Promise<ChartCandleData[]>;
+    fetchPerformanceCandles: (start: number, end: number, interval: CandleInterval, symbol: string) => Promise<ChartCandleData[]>;
+    fetchOverallPerformanceCandles: (start: number, end: number, interval: CandleInterval) => Promise<ChartCandleData[]>;
+    addRealtimeListener: (cb: RealtimeBarsCallback) => string;
+    removeRealtimeListener: (id: string) => void;
+    getEffectiveDataBoundary: (interval: CandleInterval) => number | null;
+    isLoading: boolean;
+    isUnsupported: boolean;
+    unsupportedSymbols: string[];
+    unavailableReason: string | null;
+}
+/**
+ * SYMM chart candles hook backed by Binance mark-price klines.
+ * Returns the same interface as the Hyperliquid useBasketCandles hook.
+ *
+ * Realtime updates are provided via Binance kline WebSocket streams.
+ * When listeners are registered, the hook subscribes to kline streams
+ * for all selected symbols and emits computed basket bars.
+ */
+declare function useSymmChartCandles(selection: SymmChartSelection): UseSymmChartCandlesReturn;
+
+interface SymmPerformanceOverlay {
+    id: string;
+    symbol: string;
+    label: string;
+    color: string;
+    enabled: boolean;
+    type: 'asset' | 'portfolio';
+    weight?: number;
+}
+/**
+ * SYMM performance overlay hook. Generates overlay definitions
+ * for each selected SYMM leg, matching the Hyperliquid overlay contract.
+ */
+declare function useSymmPerformanceOverlays(selection: SymmChartSelection): {
+    overlays: SymmPerformanceOverlay[];
+    generateOverlaySymbols: () => string[];
+};
+
+declare const symmKeys: {
+    all: readonly ["symm"];
+    accounts: (address?: Address) => readonly ["symm", "accounts", `0x${string}` | undefined];
+    accountSummary: (address?: Address, chainId?: number) => readonly ["symm", "accountSummary", `0x${string}` | undefined, number | undefined];
+    signature: (address?: Address) => readonly ["symm", "signature", `0x${string}` | undefined];
+    approval: (owner?: Address, spender?: Address) => readonly ["symm", "approval", `0x${string}` | undefined, `0x${string}` | undefined];
+    balances: (address?: Address, chainId?: number) => readonly ["symm", "balances", `0x${string}` | undefined, number | undefined];
+    positions: (address?: Address, chainId?: number) => readonly ["symm", "positions", `0x${string}` | undefined, number | undefined];
+    openOrders: (address?: Address, chainId?: number) => readonly ["symm", "openOrders", `0x${string}` | undefined, number | undefined];
+    tradeHistory: (address?: Address, chainId?: number) => readonly ["symm", "tradeHistory", `0x${string}` | undefined, number | undefined];
+    tpslOrders: (address?: Address, chainId?: number) => readonly ["symm", "tpslOrders", `0x${string}` | undefined, number | undefined];
+    twapOrders: (address?: Address, chainId?: number) => readonly ["symm", "twapOrders", `0x${string}` | undefined, number | undefined];
+    markets: (chainId?: number, search?: string) => readonly ["symm", "markets", number | undefined, string | undefined];
+    fundingRates: (chainId?: number) => readonly ["symm", "fundingRates", number | undefined];
+    portfolio: (address?: Address, chainId?: number) => readonly ["symm", "portfolio", `0x${string}` | undefined, number | undefined];
+    notifications: (address?: Address, chainId?: number) => readonly ["symm", "notifications", `0x${string}` | undefined, number | undefined];
+    unreadCount: (address?: Address, chainId?: number) => readonly ["symm", "unreadCount", `0x${string}` | undefined, number | undefined];
+};
+
+declare function getSymmErrorMessage(error: unknown): string;
+
+export { type SymmChartSelection, type SymmChartSelectionInput, type SymmChartTokenSelection, type SymmContextValue, type SymmPerformanceOverlay, SymmProvider, type SymmProviderProps, type SymmTokenMetadata, type UseSymmChartCandlesReturn, type UseSymmTokenSelectionMetadataReturn, getSymmErrorMessage, symmKeys, useSymmAccounts, useSymmApproval, useSymmAuth, useSymmBalances, useSymmChartCandles, useSymmChartSelection, useSymmCollateral, useSymmContext, useSymmCoreClient, useSymmDeposit, useSymmFunding, useSymmMarkets, useSymmNotifications, useSymmOpenOrders, useSymmPerformanceOverlays, useSymmPortfolio, useSymmPositions, useSymmSignature, useSymmTokenSelectionMetadata, useSymmTpsl, useSymmTrade, useSymmTradeHistory, useSymmTwap, useSymmWithdraw, useSymmWs, useSymmioClient };