@hyperix/hooks 0.1.8 → 0.1.10

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export * from "./use-l2-book.js";
+export * from "./use-historical-orders.js";
 export * from "./use-trade-history.js";
 export * from "./use-trades.js";
+export * from "./use-order-history.js";
 export * from "./use-user-fundings.js";
 export * from "./use-user-fills.js";
+export * from "./use-user-non-funding-ledger-updates.js";
+export * from "./use-user-account-activity.js";

package/dist/index.js

@@ -1,5 +1,9 @@
 export * from "./use-l2-book.js";
+export * from "./use-historical-orders.js";
 export * from "./use-trade-history.js";
 export * from "./use-trades.js";
+export * from "./use-order-history.js";
 export * from "./use-user-fundings.js";
 export * from "./use-user-fills.js";
+export * from "./use-user-non-funding-ledger-updates.js";
+export * from "./use-user-account-activity.js";

package/dist/use-historical-orders.d.ts

@@ -0,0 +1,12 @@
+import { type UseSubscribeState } from "@outofgas/react-stream";
+import type { UserHistoricalOrdersEvent } from "@nktkas/hyperliquid/api/subscription";
+export type HistoricalOrder = UserHistoricalOrdersEvent["orderHistory"][number];
+export type HistoricalOrdersData = {
+    user: `0x${string}`;
+    orderHistory: HistoricalOrder[];
+};
+export type UseHistoricalOrdersOptions = {
+    enabled?: boolean;
+    onUpdate?: (event: UserHistoricalOrdersEvent) => void;
+};
+export declare function useHistoricalOrders(user: `0x${string}`, options?: UseHistoricalOrdersOptions): UseSubscribeState<HistoricalOrdersData>;

package/dist/use-historical-orders.js

@@ -0,0 +1,42 @@
+import { useSubscribe } from "@outofgas/react-stream";
+import { wsClient } from "./config/hl.js";
+function sortHistoricalOrders(orderHistory) {
+    return [...orderHistory].sort((a, b) => b.statusTimestamp - a.statusTimestamp);
+}
+function mergeHistoricalOrders(previousData, incomingEvent) {
+    const orderHistory = incomingEvent.isSnapshot
+        ? incomingEvent.orderHistory
+        : [...(previousData?.orderHistory ?? []), ...incomingEvent.orderHistory];
+    return {
+        user: incomingEvent.user,
+        orderHistory: sortHistoricalOrders(orderHistory),
+    };
+}
+export function useHistoricalOrders(user, options = {}) {
+    const { enabled: enabledOverride, onUpdate } = options;
+    const enabled = enabledOverride ?? Boolean(user);
+    return useSubscribe({
+        key: ["historical-orders", user],
+        enabled,
+        subscribe: async ({ onData, onError }) => {
+            let data;
+            const subscription = await wsClient.userHistoricalOrders({ user }, (event) => {
+                try {
+                    if (!event.isSnapshot) {
+                        onUpdate?.(event);
+                    }
+                    data = mergeHistoricalOrders(data, event);
+                    onData(data);
+                }
+                catch (error) {
+                    onError(error instanceof Error
+                        ? error
+                        : new Error("Failed to process user historical orders event"));
+                }
+            });
+            return {
+                unsubscribe: () => subscription.unsubscribe(),
+            };
+        },
+    });
+}

package/dist/use-order-history.d.ts

@@ -0,0 +1,16 @@
+import { type HistoricalOrder, type UseHistoricalOrdersOptions } from "./use-historical-orders.js";
+export type OrderHistoryDirection = "Buy" | "Sell" | "Long" | "Short" | "Close Long" | "Close Short";
+export type OrderHistory = HistoricalOrder & {
+    displayCoin: string;
+    direction: OrderHistoryDirection;
+};
+export type OrderHistoryData = {
+    user: `0x${string}`;
+    orderHistory: OrderHistory[];
+};
+export declare function useOrderHistory(user: `0x${string}`, options?: UseHistoricalOrdersOptions): {
+    data: OrderHistoryData | undefined;
+    ready: boolean;
+    loading: boolean;
+    error?: string;
+};

package/dist/use-order-history.js

@@ -0,0 +1,37 @@
+import { useMemo } from "react";
+import { useSymbolConverter } from "./use-symbol-converter.js";
+import { useHistoricalOrders, } from "./use-historical-orders.js";
+function formatOrderDirection(order, isSpot) {
+    if (order.reduceOnly) {
+        return order.side === "A" ? "Close Long" : "Close Short";
+    }
+    if (order.side === "B") {
+        return isSpot ? "Buy" : "Long";
+    }
+    return isSpot ? "Sell" : "Short";
+}
+function formatOrderHistoryEntry(historicalOrder, displayCoin) {
+    const isSpot = Boolean(displayCoin);
+    return {
+        ...historicalOrder,
+        displayCoin: displayCoin ?? historicalOrder.order.coin,
+        direction: formatOrderDirection(historicalOrder.order, isSpot),
+    };
+}
+export function useOrderHistory(user, options = {}) {
+    const historicalOrdersState = useHistoricalOrders(user, options);
+    const symbolConverter = useSymbolConverter();
+    const data = useMemo(() => {
+        if (!historicalOrdersState.data) {
+            return undefined;
+        }
+        return {
+            ...historicalOrdersState.data,
+            orderHistory: historicalOrdersState.data.orderHistory.map((historicalOrder) => formatOrderHistoryEntry(historicalOrder, symbolConverter?.getSpotByPairId(historicalOrder.order.coin))),
+        };
+    }, [historicalOrdersState.data, symbolConverter]);
+    return {
+        ...historicalOrdersState,
+        data,
+    };
+}

package/dist/use-user-account-activity.d.ts

@@ -0,0 +1,36 @@
+import { type UseUserNonFundingLedgerUpdatesOptions, type UserNonFundingLedgerUpdate } from "./use-user-non-funding-ledger-updates.js";
+export type UserAccountActivityStatus = "Completed" | "Triggered";
+export type UserAccountActivityDirection = "in" | "out" | "neutral";
+export type UserAccountActivityAmount = {
+    value: string | null;
+    numericValue: number | null;
+    token: string | null;
+    displayValue: string;
+    direction: UserAccountActivityDirection;
+};
+export type UserAccountActivityFee = {
+    value: string | null;
+    numericValue: number | null;
+    token: string | null;
+    displayValue: string;
+};
+export type UserAccountActivity = UserNonFundingLedgerUpdate & {
+    status: UserAccountActivityStatus;
+    action: string;
+    source: string;
+    destination: string;
+    explorerUrl: string;
+    amount: UserAccountActivityAmount;
+    fee: UserAccountActivityFee;
+};
+export type UserAccountActivityData = {
+    user: `0x${string}`;
+    activity: UserAccountActivity[];
+    nonFundingLedgerUpdates: UserNonFundingLedgerUpdate[];
+};
+export declare function useUserAccountActivity(user: `0x${string}`, options?: UseUserNonFundingLedgerUpdatesOptions): {
+    data: UserAccountActivityData | undefined;
+    ready: boolean;
+    loading: boolean;
+    error?: string;
+};

package/dist/use-user-account-activity.js

@@ -0,0 +1,490 @@
+import { useMemo } from "react";
+import { useUserNonFundingLedgerUpdates, } from "./use-user-non-funding-ledger-updates.js";
+function isSameAddress(left, right) {
+    return Boolean(left && right && left.toLowerCase() === right.toLowerCase());
+}
+function isSystemAddress(address) {
+    const normalized = address.toLowerCase();
+    const hypeAddress = "0x2222222222222222222222222222222222222222";
+    if (normalized === hypeAddress) {
+        return true;
+    }
+    if (!/^0x[0-9a-f]{40}$/.test(normalized)) {
+        return false;
+    }
+    const bytes = normalized.slice(2);
+    if (!bytes.startsWith("20")) {
+        return false;
+    }
+    return bytes.slice(2, 38) === "0".repeat(36);
+}
+function formatDisplayValue(value, token, direction = "neutral") {
+    if (!value || Number(value) === 0) {
+        return "--";
+    }
+    const prefix = direction === "in" ? "+" : direction === "out" ? "-" : "";
+    return `${prefix}${value} ${token ?? ""}`.trim();
+}
+function getExplorerUrl(entry) {
+    return entry.delta.type === "deposit" || entry.delta.type === "withdraw"
+        ? `https://arbiscan.io/tx/${entry.hash}`
+        : `https://app.hyperliquid.xyz/explorer/tx/${entry.hash}`;
+}
+function getStatus(entry) {
+    return entry.delta.type === "liquidation" ? "Triggered" : "Completed";
+}
+function getAction(entry) {
+    switch (entry.delta.type) {
+        case "deposit":
+            return "Deposit";
+        case "withdraw":
+            return "Withdrawal";
+        case "internalTransfer":
+            return "Send";
+        case "spotTransfer":
+            return isSystemAddress(entry.delta.destination) || isSystemAddress(entry.delta.user)
+                ? "Transfer"
+                : "Send";
+        case "send":
+            if (isSystemAddress(entry.delta.destination) || isSystemAddress(entry.delta.user)) {
+                return "Transfer";
+            }
+            if (entry.delta.sourceDex === "spot" && entry.delta.destinationDex === "spot") {
+                return "Send";
+            }
+            if (entry.delta.sourceDex === "spot" || entry.delta.destinationDex === "spot") {
+                return "Transfer";
+            }
+            return "Send";
+        case "accountClassTransfer":
+        case "subAccountTransfer":
+        case "cStakingTransfer":
+            return "Transfer";
+        case "vaultCreate":
+            return "Vault Create";
+        case "vaultDeposit":
+            return "Vault Deposit";
+        case "vaultDistribution":
+            return "Vault Distribution";
+        case "vaultWithdraw":
+            return "Vault Withdraw";
+        case "liquidation":
+            return "Liquidation";
+        case "rewardsClaim":
+            return "Claim";
+        case "deployGasAuction":
+            return "Gas Auction";
+        case "borrowLend":
+            return entry.delta.operation === "supply"
+                ? "Supply"
+                : entry.delta.operation === "withdraw"
+                    ? "Withdraw"
+                    : entry.delta.operation === "borrow"
+                        ? "Borrow"
+                        : "Repay";
+        case "spotGenesis":
+            return "Genesis";
+        case "activateDexAbstraction":
+            return "Activate";
+    }
+}
+function formatDexLabel(dex) {
+    if (dex === "spot")
+        return "Spot";
+    if (dex === "" || dex === "perp")
+        return "Perps";
+    return `Perps (${dex})`;
+}
+function getSource(entry) {
+    switch (entry.delta.type) {
+        case "deposit":
+            return "Arbitrum";
+        case "withdraw":
+            return "Perps";
+        case "accountClassTransfer":
+            return entry.delta.toPerp ? "Spot" : "Perps";
+        case "spotTransfer":
+            return isSystemAddress(entry.delta.user) ? "HyperEVM" : "Spot";
+        case "subAccountTransfer":
+            return "Perps";
+        case "send":
+            return isSystemAddress(entry.delta.user)
+                ? "HyperEVM"
+                : formatDexLabel(entry.delta.sourceDex);
+        case "internalTransfer":
+            return "Perps";
+        case "cStakingTransfer":
+            return entry.delta.isDeposit ? "Spot" : "Staking";
+        case "vaultCreate":
+            return "Perps";
+        case "vaultDeposit":
+            return "Wallet";
+        case "vaultDistribution":
+            return "Vault";
+        case "vaultWithdraw":
+            return "Vault";
+        case "rewardsClaim":
+            return "Rewards";
+        case "liquidation":
+            return entry.delta.leverageType;
+        case "deployGasAuction":
+            return "Wallet";
+        case "borrowLend":
+            return "Borrow/Lend";
+        case "spotGenesis":
+            return "Genesis";
+        case "activateDexAbstraction":
+            return "Wallet";
+    }
+}
+function getDestination(entry) {
+    switch (entry.delta.type) {
+        case "deposit":
+            return "Perps";
+        case "withdraw":
+            return "Arbitrum";
+        case "accountClassTransfer":
+            return entry.delta.toPerp ? "Perps" : "Spot";
+        case "spotTransfer":
+            return isSystemAddress(entry.delta.destination) ? "HyperEVM" : "Spot";
+        case "subAccountTransfer":
+            return "Perps";
+        case "send":
+            return isSystemAddress(entry.delta.destination) ? "HyperEVM" : formatDexLabel(entry.delta.destinationDex);
+        case "internalTransfer":
+            return "Perps";
+        case "cStakingTransfer":
+            return entry.delta.isDeposit ? "Staking" : "Spot";
+        case "vaultCreate":
+            return "Vault";
+        case "vaultDeposit":
+            return "Vault";
+        case "vaultDistribution":
+            return "Wallet";
+        case "vaultWithdraw":
+            return "Wallet";
+        case "rewardsClaim":
+            return entry.delta.token;
+        case "liquidation":
+            return "System";
+        case "deployGasAuction":
+            return entry.delta.token;
+        case "borrowLend":
+            return entry.delta.token;
+        case "spotGenesis":
+            return entry.delta.token;
+        case "activateDexAbstraction":
+            return entry.delta.dex;
+    }
+}
+function getAmount(entry, user) {
+    switch (entry.delta.type) {
+        case "deposit":
+            return {
+                value: entry.delta.usdc,
+                numericValue: Number(entry.delta.usdc),
+                token: "USDC",
+                direction: "in",
+                displayValue: formatDisplayValue(entry.delta.usdc, "USDC", "in"),
+            };
+        case "withdraw":
+            return {
+                value: entry.delta.usdc,
+                numericValue: -Number(entry.delta.usdc),
+                token: "USDC",
+                direction: "out",
+                displayValue: formatDisplayValue(entry.delta.usdc, "USDC", "out"),
+            };
+        case "accountClassTransfer": {
+            const direction = entry.delta.toPerp ? "in" : "out";
+            const numericValue = Number(entry.delta.usdc) * (direction === "in" ? 1 : -1);
+            return {
+                value: entry.delta.usdc,
+                numericValue,
+                token: "USDC",
+                direction,
+                displayValue: formatDisplayValue(entry.delta.usdc, "USDC", direction),
+            };
+        }
+        case "internalTransfer": {
+            const isInbound = isSameAddress(entry.delta.destination, user);
+            const direction = isInbound ? "in" : "out";
+            const gross = Number(entry.delta.usdc);
+            const numericValue = isInbound
+                ? gross
+                : -(gross - Number(entry.delta.fee || "0"));
+            return {
+                value: isInbound
+                    ? entry.delta.usdc
+                    : (gross - Number(entry.delta.fee || "0")).toString(),
+                numericValue,
+                token: "USDC",
+                direction,
+                displayValue: formatDisplayValue(isInbound
+                    ? entry.delta.usdc
+                    : (gross - Number(entry.delta.fee || "0")).toString(), "USDC", direction),
+            };
+        }
+        case "spotTransfer": {
+            const isInbound = isSameAddress(entry.delta.destination, user);
+            const direction = isInbound ? "in" : "out";
+            const value = entry.delta.usdcValue;
+            return {
+                value,
+                numericValue: Number(value) * (isInbound ? 1 : -1),
+                token: "USDC",
+                direction,
+                displayValue: formatDisplayValue(value, "USDC", direction),
+            };
+        }
+        case "subAccountTransfer": {
+            const isInbound = isSameAddress(entry.delta.destination, user);
+            const direction = isInbound ? "in" : "out";
+            return {
+                value: entry.delta.usdc,
+                numericValue: Number(entry.delta.usdc) * (isInbound ? 1 : -1),
+                token: "USDC",
+                direction,
+                displayValue: formatDisplayValue(entry.delta.usdc, "USDC", direction),
+            };
+        }
+        case "send": {
+            const isInbound = isSameAddress(entry.delta.destination, user);
+            const direction = isInbound ? "in" : "out";
+            return {
+                value: entry.delta.usdcValue,
+                numericValue: Number(entry.delta.usdcValue) * (isInbound ? 1 : -1),
+                token: "USDC",
+                direction,
+                displayValue: formatDisplayValue(entry.delta.usdcValue, "USDC", direction),
+            };
+        }
+        case "cStakingTransfer": {
+            const direction = entry.delta.isDeposit ? "out" : "in";
+            return {
+                value: entry.delta.amount,
+                numericValue: Number(entry.delta.amount) * (direction === "in" ? 1 : -1),
+                token: entry.delta.token,
+                direction,
+                displayValue: formatDisplayValue(entry.delta.amount, entry.delta.token, direction),
+            };
+        }
+        case "vaultCreate": {
+            const netValue = Number(entry.delta.usdc) - Number(entry.delta.fee || "0");
+            return {
+                value: netValue.toString(),
+                numericValue: -netValue,
+                token: "USDC",
+                direction: "out",
+                displayValue: formatDisplayValue(netValue.toString(), "USDC", "out"),
+            };
+        }
+        case "vaultDeposit":
+            return {
+                value: entry.delta.usdc,
+                numericValue: -Number(entry.delta.usdc),
+                token: "USDC",
+                direction: "out",
+                displayValue: formatDisplayValue(entry.delta.usdc, "USDC", "out"),
+            };
+        case "vaultDistribution":
+            return {
+                value: entry.delta.usdc,
+                numericValue: Number(entry.delta.usdc),
+                token: "USDC",
+                direction: "in",
+                displayValue: formatDisplayValue(entry.delta.usdc, "USDC", "in"),
+            };
+        case "vaultWithdraw":
+            return {
+                value: entry.delta.netWithdrawnUsd,
+                numericValue: Number(entry.delta.netWithdrawnUsd),
+                token: "USDC",
+                direction: "in",
+                displayValue: formatDisplayValue(entry.delta.netWithdrawnUsd, "USDC", "in"),
+            };
+        case "rewardsClaim":
+            return {
+                value: entry.delta.amount,
+                numericValue: Number(entry.delta.amount),
+                token: entry.delta.token,
+                direction: "in",
+                displayValue: formatDisplayValue(entry.delta.amount, entry.delta.token, "in"),
+            };
+        case "liquidation":
+            return {
+                value: entry.delta.accountValue,
+                numericValue: Number(entry.delta.accountValue),
+                token: "USDC",
+                direction: "neutral",
+                displayValue: formatDisplayValue(entry.delta.accountValue, "USDC", "neutral"),
+            };
+        case "deployGasAuction":
+            return {
+                value: entry.delta.amount,
+                numericValue: -Number(entry.delta.amount),
+                token: entry.delta.token,
+                direction: "out",
+                displayValue: formatDisplayValue(entry.delta.amount, entry.delta.token, "out"),
+            };
+        case "borrowLend": {
+            const direction = entry.delta.operation === "supply" || entry.delta.operation === "repay"
+                ? "out"
+                : "in";
+            return {
+                value: entry.delta.amount,
+                numericValue: Number(entry.delta.amount) * (direction === "in" ? 1 : -1),
+                token: entry.delta.token,
+                direction,
+                displayValue: formatDisplayValue(entry.delta.amount, entry.delta.token, direction),
+            };
+        }
+        case "spotGenesis": {
+            const numericValue = Number(entry.delta.amount);
+            const direction = numericValue >= 0 ? "in" : "out";
+            return {
+                value: entry.delta.amount.replace(/^-/, ""),
+                numericValue,
+                token: entry.delta.token,
+                direction,
+                displayValue: formatDisplayValue(entry.delta.amount.replace(/^-/, ""), entry.delta.token, direction),
+            };
+        }
+        case "activateDexAbstraction":
+            return {
+                value: entry.delta.amount,
+                numericValue: -Number(entry.delta.amount),
+                token: entry.delta.token,
+                direction: "out",
+                displayValue: formatDisplayValue(entry.delta.amount, entry.delta.token, "out"),
+            };
+    }
+}
+function getFee(entry) {
+    switch (entry.delta.type) {
+        case "internalTransfer":
+            return {
+                value: entry.delta.fee,
+                numericValue: Number(entry.delta.fee),
+                token: "USDC",
+                displayValue: formatDisplayValue(entry.delta.fee, "USDC"),
+            };
+        case "spotTransfer":
+            if (Number(entry.delta.fee) !== 0) {
+                return {
+                    value: entry.delta.fee,
+                    numericValue: Number(entry.delta.fee),
+                    token: entry.delta.feeToken,
+                    displayValue: formatDisplayValue(entry.delta.fee, entry.delta.feeToken),
+                };
+            }
+            if (Number(entry.delta.nativeTokenFee) !== 0) {
+                return {
+                    value: entry.delta.nativeTokenFee,
+                    numericValue: Number(entry.delta.nativeTokenFee),
+                    token: "HYPE",
+                    displayValue: formatDisplayValue(entry.delta.nativeTokenFee, "HYPE"),
+                };
+            }
+            return {
+                value: null,
+                numericValue: null,
+                token: null,
+                displayValue: "--",
+            };
+        case "send":
+            if (Number(entry.delta.fee) !== 0) {
+                return {
+                    value: entry.delta.fee,
+                    numericValue: Number(entry.delta.fee),
+                    token: entry.delta.feeToken,
+                    displayValue: formatDisplayValue(entry.delta.fee, entry.delta.feeToken),
+                };
+            }
+            if (Number(entry.delta.nativeTokenFee) !== 0) {
+                return {
+                    value: entry.delta.nativeTokenFee,
+                    numericValue: Number(entry.delta.nativeTokenFee),
+                    token: "HYPE",
+                    displayValue: formatDisplayValue(entry.delta.nativeTokenFee, "HYPE"),
+                };
+            }
+            return {
+                value: null,
+                numericValue: null,
+                token: null,
+                displayValue: "--",
+            };
+        case "vaultCreate":
+            return {
+                value: entry.delta.fee,
+                numericValue: Number(entry.delta.fee),
+                token: "USDC",
+                displayValue: formatDisplayValue(entry.delta.fee, "USDC"),
+            };
+        case "vaultWithdraw": {
+            const totalFee = Number(entry.delta.commission) +
+                Number(entry.delta.closingCost) +
+                Number(entry.delta.basis);
+            if (totalFee === 0) {
+                return {
+                    value: null,
+                    numericValue: null,
+                    token: null,
+                    displayValue: "--",
+                };
+            }
+            return {
+                value: totalFee.toString(),
+                numericValue: totalFee,
+                token: "USDC",
+                displayValue: formatDisplayValue(totalFee.toString(), "USDC"),
+            };
+        }
+        case "withdraw":
+            return {
+                value: entry.delta.fee,
+                numericValue: Number(entry.delta.fee),
+                token: "USDC",
+                displayValue: Number(entry.delta.fee) === 0
+                    ? "--"
+                    : formatDisplayValue(entry.delta.fee, "USDC"),
+            };
+        default:
+            return {
+                value: null,
+                numericValue: null,
+                token: null,
+                displayValue: "--",
+            };
+    }
+}
+function formatUserAccountActivity(entry, user) {
+    return {
+        ...entry,
+        status: getStatus(entry),
+        action: getAction(entry),
+        source: getSource(entry),
+        destination: getDestination(entry),
+        explorerUrl: getExplorerUrl(entry),
+        amount: getAmount(entry, user),
+        fee: getFee(entry),
+    };
+}
+export function useUserAccountActivity(user, options = {}) {
+    const userNonFundingLedgerUpdatesState = useUserNonFundingLedgerUpdates(user, options);
+    const data = useMemo(() => {
+        if (!userNonFundingLedgerUpdatesState.data) {
+            return undefined;
+        }
+        return {
+            user: userNonFundingLedgerUpdatesState.data.user,
+            nonFundingLedgerUpdates: userNonFundingLedgerUpdatesState.data.nonFundingLedgerUpdates,
+            activity: userNonFundingLedgerUpdatesState.data.nonFundingLedgerUpdates.map((entry) => formatUserAccountActivity(entry, user)),
+        };
+    }, [user, userNonFundingLedgerUpdatesState.data]);
+    return {
+        ...userNonFundingLedgerUpdatesState,
+        data,
+    };
+}

package/dist/use-user-non-funding-ledger-updates.d.ts

@@ -0,0 +1,12 @@
+import { type UseSubscribeState } from "@outofgas/react-stream";
+import type { UserNonFundingLedgerUpdatesEvent } from "@nktkas/hyperliquid/api/subscription";
+export type UserNonFundingLedgerUpdate = UserNonFundingLedgerUpdatesEvent["nonFundingLedgerUpdates"][number];
+export type UserNonFundingLedgerUpdatesData = {
+    user: `0x${string}`;
+    nonFundingLedgerUpdates: UserNonFundingLedgerUpdate[];
+};
+export type UseUserNonFundingLedgerUpdatesOptions = {
+    enabled?: boolean;
+    onUpdate?: (event: UserNonFundingLedgerUpdatesEvent) => void;
+};
+export declare function useUserNonFundingLedgerUpdates(user: `0x${string}`, options?: UseUserNonFundingLedgerUpdatesOptions): UseSubscribeState<UserNonFundingLedgerUpdatesData>;

package/dist/use-user-non-funding-ledger-updates.js

@@ -0,0 +1,42 @@
+import { useSubscribe } from "@outofgas/react-stream";
+import { wsClient } from "./config/hl.js";
+function mergeUserNonFundingLedgerUpdates(previousData, incomingEvent) {
+    const nonFundingLedgerUpdates = incomingEvent.isSnapshot
+        ? incomingEvent.nonFundingLedgerUpdates
+        : [
+            ...(previousData?.nonFundingLedgerUpdates ?? []),
+            ...incomingEvent.nonFundingLedgerUpdates,
+        ];
+    return {
+        user: incomingEvent.user,
+        nonFundingLedgerUpdates: [...nonFundingLedgerUpdates].sort((a, b) => b.time - a.time),
+    };
+}
+export function useUserNonFundingLedgerUpdates(user, options = {}) {
+    const { enabled: enabledOverride, onUpdate } = options;
+    const enabled = enabledOverride ?? Boolean(user);
+    return useSubscribe({
+        key: ["user-non-funding-ledger-updates", user],
+        enabled,
+        subscribe: async ({ onData, onError }) => {
+            let data;
+            const subscription = await wsClient.userNonFundingLedgerUpdates({ user }, (event) => {
+                try {
+                    if (!event.isSnapshot) {
+                        onUpdate?.(event);
+                    }
+                    data = mergeUserNonFundingLedgerUpdates(data, event);
+                    onData(data);
+                }
+                catch (error) {
+                    onError(error instanceof Error
+                        ? error
+                        : new Error("Failed to process user non-funding ledger updates event"));
+                }
+            });
+            return {
+                unsubscribe: () => subscription.unsubscribe(),
+            };
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperix/hooks",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",