@livo-build/runtime 0.2.6 → 0.2.13

package/dist/hyperliquid.d.ts

@@ -49,6 +49,51 @@ export interface AccountBalance {
     totalMarginUsed: number;
     totalNtlPos: number;
 }
+/** A parsed open perp position. */
+export interface PositionInfo {
+    coin: string;
+    /** Absolute size (always ≥ 0; see `side`). */
+    size: number;
+    side: "long" | "short" | "flat";
+    entryPx: number;
+    positionValue: number;
+    unrealizedPnl: number;
+    /** Return on equity as a fraction (0.12 = +12%). */
+    returnOnEquity: number;
+    leverage: number;
+    liquidationPx: number | null;
+    marginUsed: number;
+}
+/** Best bid / offer snapshot. */
+export interface Bbo {
+    bid: number | null;
+    ask: number | null;
+    mid: number | null;
+    spread: number | null;
+}
+interface RawPosition {
+    coin: string;
+    szi: string;
+    entryPx?: string | null;
+    positionValue?: string;
+    unrealizedPnl?: string;
+    returnOnEquity?: string;
+    leverage?: {
+        value?: number;
+    };
+    liquidationPx?: string | null;
+    marginUsed?: string;
+}
+/** Parse a Hyperliquid clearinghouse position into a clean PositionInfo. */
+export declare function parseHlPosition(p: RawPosition): PositionInfo;
+/** Parse an L2 book into a best bid/offer + mid + spread. */
+export declare function parseBbo(book: {
+    levels?: [Array<{
+        px: string;
+    }>, Array<{
+        px: string;
+    }>];
+}): Bbo;
 export interface PlaceOrderOptions {
     /** Reduce-only (close, never flip). Default false. */
     reduceOnly?: boolean;
@@ -133,6 +178,32 @@ export declare class Hyperliquid {
     assetCtx(coin: string): Promise<AssetContext>;
     /** OHLCV candles for charting. `interval` default "1h"; window defaults to the last 24h. */
     candles(coin: string, interval?: CandleInterval, opts?: CandlesOptions): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").CandleSnapshotResponse>;
+    /** Recent public trades for a coin. */
+    recentTrades(coin: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").RecentTradesResponse>;
+    /** Best bid/offer + mid + spread for a coin (parsed from the L2 book). */
+    bbo(coin: string): Promise<Bbo>;
+    /** All open positions as clean PositionInfo[] (default: the signer's account). */
+    positionsList(user?: string): Promise<PositionInfo[]>;
+    /** A single open position for a coin, or null if flat. */
+    position(coin: string, user?: string): Promise<PositionInfo | null>;
+    /** Current hourly funding rate for a coin (fraction, e.g. 0.0000125). */
+    fundingRate(coin: string): Promise<number>;
+    /** Historical funding rates for a coin (default: the last 7 days). */
+    fundingHistory(coin: string, opts?: {
+        startTime?: number;
+        endTime?: number;
+        lookbackMs?: number;
+    }): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").FundingHistoryResponse>;
+    /** Funding payments paid/received by an account (default signer; last 7 days). */
+    userFunding(opts?: {
+        startTime?: number;
+        endTime?: number;
+        lookbackMs?: number;
+    }, user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").UserFundingResponse>;
+    /** Predicted next funding rates across venues (no key). */
+    predictedFundings(): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").PredictedFundingsResponse>;
+    /** Portfolio history (PnL/account-value time series) for an account (default: the signer). */
+    portfolio(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").PortfolioResponse>;
     /** Raw order passthrough (the @nktkas `order` shape) for full control. */
     order(params: Parameters<ExchangeClient["order"]>[0]): Promise<{
         status: "ok";
@@ -333,6 +404,130 @@ export declare class Hyperliquid {
             };
         };
     }>;
+    /** Cancel a resting order by its client order id (cloid). */
+    cancelByCloid(coin: string, cloid: Hex): Promise<{
+        status: "ok";
+        response: {
+            type: "cancel";
+            data: {
+                statuses: "success"[];
+            };
+        };
+    }>;
+    /** Cancel ALL resting orders (optionally only for one coin). Returns the count cancelled. */
+    cancelAll(coin?: string): Promise<{
+        cancelled: number;
+    }>;
+    /** Modify a resting limit order in place (new size/price/side). */
+    modifyOrder(oid: number, coin: string, isBuy: boolean, size: number, price: number, opts?: PlaceOrderOptions): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /**
+     * Place a trigger order (stop / take-profit). `triggerPx` is the activation price;
+     * `tpsl` is "sl" (stop) or "tp". Market trigger by default (fills at market once
+     * armed); reduce-only by default (closing). `isBuy` is the side that executes —
+     * to protect a LONG use isBuy=false (sell), for a SHORT use isBuy=true (buy).
+     */
+    trigger(coin: string, isBuy: boolean, size: number, triggerPx: number, opts: {
+        tpsl: "tp" | "sl";
+        isMarket?: boolean;
+        reduceOnly?: boolean;
+        price?: number;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | "waitingForFill" | "waitingForTrigger")[];
+            };
+        };
+    }>;
+    /** Stop-loss trigger (reduce-only market by default). See `trigger` for `isBuy`. */
+    stopLoss(coin: string, isBuy: boolean, size: number, triggerPx: number, opts?: {
+        isMarket?: boolean;
+        price?: number;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | "waitingForFill" | "waitingForTrigger")[];
+            };
+        };
+    }>;
+    /** Take-profit trigger (reduce-only market by default). See `trigger` for `isBuy`. */
+    takeProfit(coin: string, isBuy: boolean, size: number, triggerPx: number, opts?: {
+        isMarket?: boolean;
+        price?: number;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "order";
+            data: {
+                statuses: ({
+                    resting: {
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | {
+                    filled: {
+                        totalSz: string;
+                        avgPx: string;
+                        oid: number;
+                        cloid?: `0x${string}`;
+                    };
+                } | "waitingForFill" | "waitingForTrigger")[];
+            };
+        };
+    }>;
+    /** Dead-man's switch: auto-cancel all orders at `timeMs` (epoch) unless re-armed. Omit to clear. */
+    scheduleCancel(timeMs?: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Move USDC from spot into the perp wallet (margin top-up; not a withdrawal). */
+    transferToPerp(usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Move USDC from the perp wallet back to spot. */
+    transferToSpot(usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
     /** Set leverage for a coin (cross by default). */
     updateLeverage(coin: string, leverage: number, opts?: {
         cross?: boolean;
@@ -342,6 +537,80 @@ export declare class Hyperliquid {
             type: "default";
         };
     }>;
+    /**
+     * Place a TWAP order — slice `size` evenly over `minutes` (5–1440) to reduce impact.
+     * `randomize` jitters slice timing. Returns the @nktkas response (incl. the TWAP id).
+     */
+    twap(coin: string, isBuy: boolean, size: number, minutes: number, opts?: {
+        reduceOnly?: boolean;
+        randomize?: boolean;
+    }): Promise<{
+        status: "ok";
+        response: {
+            type: "twapOrder";
+            data: {
+                status: {
+                    running: {
+                        twapId: number;
+                    };
+                };
+            };
+        };
+    }>;
+    /** Cancel a running TWAP by its id (from the `twap()` response). */
+    cancelTwap(coin: string, twapId: number): Promise<{
+        status: "ok";
+        response: {
+            type: "twapCancel";
+            data: {
+                status: "success";
+            };
+        };
+    }>;
+    /** Create a named sub-account (1–16 chars). Returns its address. */
+    createSubAccount(name: string): Promise<{
+        status: "ok";
+        response: {
+            type: "createSubAccount";
+            data: `0x${string}`;
+        };
+    }>;
+    /** List sub-accounts for an address (default: the signer). */
+    subAccounts(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").SubAccountsResponse>;
+    /** Move USDC from the master into a sub-account (`usd` in dollars). */
+    transferToSubAccount(subAccount: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Move USDC from a sub-account back to the master (`usd` in dollars). */
+    transferFromSubAccount(subAccount: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Deposit USDC into a vault (`usd` in dollars). */
+    vaultDeposit(vault: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Withdraw USDC from a vault (`usd` in dollars). */
+    vaultWithdraw(vault: string, usd: number): Promise<{
+        status: "ok";
+        response: {
+            type: "default";
+        };
+    }>;
+    /** Vault details + your equity in it (public read; pass a user or use the signer). */
+    vaultDetails(vault: string, user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").VaultDetailsResponse>;
+    /** Your fee schedule + 14-day volume (default: the signer). */
+    userFees(user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").UserFeesResponse>;
+    /** Status of a single order by its oid (resting/filled/canceled). */
+    orderStatus(oid: number, user?: string): Promise<import("file:///home/runner/work/hyperliquid/hyperliquid/src/mod.ts").OrderStatusResponse>;
     private symbols;
     private lookup;
     private requireUser;

package/dist/hyperliquid.js

@@ -25,6 +25,35 @@ import { keccak_256 } from "@noble/hashes/sha3";
 import { localAccount } from "./eip712.js";
 import { privateKeyToAddress } from "./tx.js";
 import { bytesToHex, concatBytes, hexToBytes } from "./hex.js";
+/** Parse a Hyperliquid clearinghouse position into a clean PositionInfo. */
+export function parseHlPosition(p) {
+    const szi = Number(p.szi);
+    return {
+        coin: p.coin,
+        size: Math.abs(szi),
+        side: szi > 0 ? "long" : szi < 0 ? "short" : "flat",
+        entryPx: Number(p.entryPx ?? 0),
+        positionValue: Number(p.positionValue ?? 0),
+        unrealizedPnl: Number(p.unrealizedPnl ?? 0),
+        returnOnEquity: Number(p.returnOnEquity ?? 0),
+        leverage: Number(p.leverage?.value ?? 0),
+        liquidationPx: p.liquidationPx != null ? Number(p.liquidationPx) : null,
+        marginUsed: Number(p.marginUsed ?? 0),
+    };
+}
+/** Parse an L2 book into a best bid/offer + mid + spread. */
+export function parseBbo(book) {
+    const bidPx = book.levels?.[0]?.[0]?.px;
+    const askPx = book.levels?.[1]?.[0]?.px;
+    const bid = bidPx != null ? Number(bidPx) : null;
+    const ask = askPx != null ? Number(askPx) : null;
+    return {
+        bid,
+        ask,
+        mid: bid != null && ask != null ? (bid + ask) / 2 : null,
+        spread: bid != null && ask != null ? ask - bid : null,
+    };
+}
 function truthy(v) {
     return v === true || v === 1 || v === "1" || v === "true";
 }
@@ -206,6 +235,47 @@ export class Hyperliquid {
         const startTime = opts.startTime ?? endTime - (opts.lookbackMs ?? 24 * 60 * 60 * 1000);
         return this._info.candleSnapshot({ coin, interval, startTime, endTime });
     }
+    /** Recent public trades for a coin. */
+    async recentTrades(coin) {
+        return this._info.recentTrades({ coin });
+    }
+    /** Best bid/offer + mid + spread for a coin (parsed from the L2 book). */
+    async bbo(coin) {
+        return parseBbo((await this.book(coin)));
+    }
+    /** All open positions as clean PositionInfo[] (default: the signer's account). */
+    async positionsList(user) {
+        const s = (await this.positions(user));
+        return (s.assetPositions ?? []).map((ap) => parseHlPosition(ap.position));
+    }
+    /** A single open position for a coin, or null if flat. */
+    async position(coin, user) {
+        return (await this.positionsList(user)).find((p) => p.coin === coin) ?? null;
+    }
+    /** Current hourly funding rate for a coin (fraction, e.g. 0.0000125). */
+    async fundingRate(coin) {
+        return (await this.assetCtx(coin)).funding;
+    }
+    /** Historical funding rates for a coin (default: the last 7 days). */
+    async fundingHistory(coin, opts = {}) {
+        const endTime = opts.endTime ?? Date.now();
+        const startTime = opts.startTime ?? endTime - (opts.lookbackMs ?? 7 * 24 * 60 * 60 * 1000);
+        return this._info.fundingHistory({ coin, startTime, endTime });
+    }
+    /** Funding payments paid/received by an account (default signer; last 7 days). */
+    async userFunding(opts = {}, user) {
+        const endTime = opts.endTime ?? Date.now();
+        const startTime = opts.startTime ?? endTime - (opts.lookbackMs ?? 7 * 24 * 60 * 60 * 1000);
+        return this._info.userFunding({ user: this.requireUser(user), startTime, endTime });
+    }
+    /** Predicted next funding rates across venues (no key). */
+    async predictedFundings() {
+        return this._info.predictedFundings();
+    }
+    /** Portfolio history (PnL/account-value time series) for an account (default: the signer). */
+    async portfolio(user) {
+        return this._info.portfolio({ user: this.requireUser(user) });
+    }
     // ---- trading (key required) ----
     /** Raw order passthrough (the @nktkas `order` shape) for full control. */
     async order(params) {
@@ -281,10 +351,134 @@ export class Hyperliquid {
     async cancel(coin, oid) {
         return this.exchange.cancel({ cancels: [{ a: await this.assetId(coin), o: oid }] });
     }
+    /** Cancel a resting order by its client order id (cloid). */
+    async cancelByCloid(coin, cloid) {
+        return this.exchange.cancelByCloid({ cancels: [{ asset: await this.assetId(coin), cloid }] });
+    }
+    /** Cancel ALL resting orders (optionally only for one coin). Returns the count cancelled. */
+    async cancelAll(coin) {
+        const orders = (await this.openOrders());
+        const targets = coin ? orders.filter((o) => o.coin === coin) : orders;
+        if (!targets.length)
+            return { cancelled: 0 };
+        const cancels = await Promise.all(targets.map(async (o) => ({ a: await this.assetId(o.coin), o: o.oid })));
+        await this.exchange.cancel({ cancels });
+        return { cancelled: targets.length };
+    }
+    /** Modify a resting limit order in place (new size/price/side). */
+    async modifyOrder(oid, coin, isBuy, size, price, opts = {}) {
+        const { id, szDecimals } = await this.lookup(coin);
+        return this.exchange.modify({
+            oid,
+            order: {
+                a: id,
+                b: isBuy,
+                p: formatPrice(price),
+                s: formatSize(size, szDecimals),
+                r: opts.reduceOnly ?? false,
+                t: { limit: { tif: opts.tif ?? "Gtc" } },
+            },
+        });
+    }
+    /**
+     * Place a trigger order (stop / take-profit). `triggerPx` is the activation price;
+     * `tpsl` is "sl" (stop) or "tp". Market trigger by default (fills at market once
+     * armed); reduce-only by default (closing). `isBuy` is the side that executes —
+     * to protect a LONG use isBuy=false (sell), for a SHORT use isBuy=true (buy).
+     */
+    async trigger(coin, isBuy, size, triggerPx, opts) {
+        const { id, szDecimals } = await this.lookup(coin);
+        return this.exchange.order({
+            orders: [
+                {
+                    a: id,
+                    b: isBuy,
+                    p: formatPrice(opts.price ?? triggerPx),
+                    s: formatSize(size, szDecimals),
+                    r: opts.reduceOnly ?? true,
+                    t: { trigger: { isMarket: opts.isMarket ?? true, triggerPx: formatPrice(triggerPx), tpsl: opts.tpsl } },
+                },
+            ],
+            grouping: "na",
+        });
+    }
+    /** Stop-loss trigger (reduce-only market by default). See `trigger` for `isBuy`. */
+    stopLoss(coin, isBuy, size, triggerPx, opts = {}) {
+        return this.trigger(coin, isBuy, size, triggerPx, { ...opts, tpsl: "sl" });
+    }
+    /** Take-profit trigger (reduce-only market by default). See `trigger` for `isBuy`. */
+    takeProfit(coin, isBuy, size, triggerPx, opts = {}) {
+        return this.trigger(coin, isBuy, size, triggerPx, { ...opts, tpsl: "tp" });
+    }
+    /** Dead-man's switch: auto-cancel all orders at `timeMs` (epoch) unless re-armed. Omit to clear. */
+    async scheduleCancel(timeMs) {
+        return this.exchange.scheduleCancel(timeMs ? { time: timeMs } : {});
+    }
+    /** Move USDC from spot into the perp wallet (margin top-up; not a withdrawal). */
+    async transferToPerp(usd) {
+        return this.exchange.usdClassTransfer({ amount: String(usd), toPerp: true });
+    }
+    /** Move USDC from the perp wallet back to spot. */
+    async transferToSpot(usd) {
+        return this.exchange.usdClassTransfer({ amount: String(usd), toPerp: false });
+    }
     /** Set leverage for a coin (cross by default). */
     async updateLeverage(coin, leverage, opts = {}) {
         return this.exchange.updateLeverage({ asset: await this.assetId(coin), isCross: opts.cross ?? true, leverage });
     }
+    /**
+     * Place a TWAP order — slice `size` evenly over `minutes` (5–1440) to reduce impact.
+     * `randomize` jitters slice timing. Returns the @nktkas response (incl. the TWAP id).
+     */
+    async twap(coin, isBuy, size, minutes, opts = {}) {
+        const { id, szDecimals } = await this.lookup(coin);
+        return this.exchange.twapOrder({
+            twap: { a: id, b: isBuy, s: formatSize(size, szDecimals), r: opts.reduceOnly ?? false, m: minutes, t: opts.randomize ?? false },
+        });
+    }
+    /** Cancel a running TWAP by its id (from the `twap()` response). */
+    async cancelTwap(coin, twapId) {
+        return this.exchange.twapCancel({ a: await this.assetId(coin), t: twapId });
+    }
+    // ---- sub-accounts (isolate strategies under one master) ----
+    /** Create a named sub-account (1–16 chars). Returns its address. */
+    async createSubAccount(name) {
+        return this.exchange.createSubAccount({ name });
+    }
+    /** List sub-accounts for an address (default: the signer). */
+    async subAccounts(user) {
+        return this._info.subAccounts({ user: this.requireUser(user) });
+    }
+    /** Move USDC from the master into a sub-account (`usd` in dollars). */
+    async transferToSubAccount(subAccount, usd) {
+        return this.exchange.subAccountTransfer({ subAccountUser: subAccount, isDeposit: true, usd: Math.round(usd * 1e6) });
+    }
+    /** Move USDC from a sub-account back to the master (`usd` in dollars). */
+    async transferFromSubAccount(subAccount, usd) {
+        return this.exchange.subAccountTransfer({ subAccountUser: subAccount, isDeposit: false, usd: Math.round(usd * 1e6) });
+    }
+    // ---- vaults (deposit into / withdraw from a Hyperliquid vault) ----
+    /** Deposit USDC into a vault (`usd` in dollars). */
+    async vaultDeposit(vault, usd) {
+        return this.exchange.vaultTransfer({ vaultAddress: vault, isDeposit: true, usd: Math.round(usd * 1e6) });
+    }
+    /** Withdraw USDC from a vault (`usd` in dollars). */
+    async vaultWithdraw(vault, usd) {
+        return this.exchange.vaultTransfer({ vaultAddress: vault, isDeposit: false, usd: Math.round(usd * 1e6) });
+    }
+    /** Vault details + your equity in it (public read; pass a user or use the signer). */
+    async vaultDetails(vault, user) {
+        return this._info.vaultDetails({ vaultAddress: vault, user: (user ?? this.address ?? undefined) });
+    }
+    // ---- account info ----
+    /** Your fee schedule + 14-day volume (default: the signer). */
+    async userFees(user) {
+        return this._info.userFees({ user: this.requireUser(user) });
+    }
+    /** Status of a single order by its oid (resting/filled/canceled). */
+    async orderStatus(oid, user) {
+        return this._info.orderStatus({ user: this.requireUser(user), oid });
+    }
     // The @nktkas SymbolConverter resolves asset ids + szDecimals across the main
     // perp dex, spot, AND HIP-3 builder dexes (so "xyz:TSLA" → its global asset id).
     symbols() {

package/dist/hyperliquid.test.js

@@ -1,7 +1,7 @@
 // Hyperliquid agent-wallet delegation: per-user agent keys must be deterministic
 // (recomputable, never stored) and the bound client must sign as the agent.
 import { describe, expect, it } from "vitest";
-import { Hyperliquid } from "./hyperliquid.js";
+import { Hyperliquid, parseHlPosition, parseBbo } from "./hyperliquid.js";
 import { localAccount } from "./eip712.js";
 const SECRET = "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d";
 const MASTER = "0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826";
@@ -29,3 +29,19 @@ describe("Hyperliquid agent-wallet delegation", () => {
         expect(() => bare.agentKey("user-1")).toThrow(/agent secret/i);
     });
 });
+describe("Hyperliquid parsers", () => {
+    it("parseHlPosition normalizes a clearinghouse position (side/size/fields)", () => {
+        const long = parseHlPosition({ coin: "BTC", szi: "0.5", entryPx: "60000", positionValue: "31000", unrealizedPnl: "1000", returnOnEquity: "0.12", leverage: { value: 10 }, liquidationPx: "40000", marginUsed: "3100" });
+        expect(long).toMatchObject({ coin: "BTC", size: 0.5, side: "long", entryPx: 60000, unrealizedPnl: 1000, leverage: 10, liquidationPx: 40000 });
+        const short = parseHlPosition({ coin: "ETH", szi: "-2" });
+        expect(short.side).toBe("short");
+        expect(short.size).toBe(2);
+        expect(short.liquidationPx).toBeNull();
+        expect(parseHlPosition({ coin: "X", szi: "0" }).side).toBe("flat");
+    });
+    it("parseBbo derives bid/ask/mid/spread from the L2 book", () => {
+        const bbo = parseBbo({ levels: [[{ px: "99.5" }], [{ px: "100.5" }]] });
+        expect(bbo).toEqual({ bid: 99.5, ask: 100.5, mid: 100, spread: 1 });
+        expect(parseBbo({ levels: [[], []] })).toEqual({ bid: null, ask: null, mid: null, spread: null });
+    });
+});

package/dist/hyperliquidBridge.d.ts

@@ -0,0 +1,30 @@
+import type { Chain } from "./chain.js";
+import type { Hex } from "./hex.js";
+export type HlNetwork = "mainnet" | "testnet";
+export interface HlBridgeConfig {
+    /** Arbitrum chainId the deposit transfer goes out on. */
+    chainId: number;
+    /** Hyperliquid bridge (Bridge2) contract — the USDC transfer recipient. */
+    bridge: Hex;
+    /** USDC token on that chain. */
+    usdc: Hex;
+    usdcDecimals: number;
+    /** Hyperliquid enforces a minimum deposit; below it funds are lost. */
+    minUsdc: number;
+}
+export declare const HL_BRIDGE: Record<HlNetwork, HlBridgeConfig>;
+/**
+ * Convert a human USDC amount (e.g. 25 or "25.5") to base units, without float
+ * error. Rejects more fractional digits than the token supports.
+ */
+export declare function usdcBaseUnits(amount: number | string, decimals?: number): bigint;
+export interface DepositOptions {
+    /** "mainnet" (Arbitrum) or "testnet" (Arbitrum Sepolia). Default "mainnet". */
+    network?: HlNetwork;
+}
+/**
+ * Deposit USDC into Hyperliquid from Arbitrum. `chain` must be a Chain on the
+ * matching Arbitrum network with a funded signer. Returns the deposit tx hash;
+ * the credit appears on the signer's Hyperliquid account shortly after.
+ */
+export declare function depositToHyperliquid(chain: Chain, amount: number | string, opts?: DepositOptions): Promise<Hex>;

package/dist/hyperliquidBridge.js

@@ -0,0 +1,61 @@
+// Verify against Hyperliquid docs before relying on the testnet entry; mainnet
+// Bridge2 + native USDC on Arbitrum are the well-known production addresses.
+export const HL_BRIDGE = {
+    mainnet: {
+        chainId: 42161,
+        bridge: "0x2Df1c51E09aECF9cacB7bc98cB1742757f163dF7",
+        usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+        usdcDecimals: 6,
+        minUsdc: 5,
+    },
+    testnet: {
+        chainId: 421614,
+        bridge: "0x08cfc1B6b2dCF36A1480b99353A354AA8AC56f89",
+        usdc: "0x1baAbB04529D43a73232B713C0FE471f7c7334d5",
+        usdcDecimals: 6,
+        minUsdc: 5,
+    },
+};
+const ERC20_TRANSFER = [
+    {
+        type: "function",
+        name: "transfer",
+        stateMutability: "nonpayable",
+        inputs: [
+            { name: "to", type: "address" },
+            { name: "amount", type: "uint256" },
+        ],
+        outputs: [{ name: "", type: "bool" }],
+    },
+];
+/**
+ * Convert a human USDC amount (e.g. 25 or "25.5") to base units, without float
+ * error. Rejects more fractional digits than the token supports.
+ */
+export function usdcBaseUnits(amount, decimals = 6) {
+    const s = typeof amount === "number" ? amount.toString() : amount.trim();
+    if (!/^\d+(\.\d+)?$/.test(s))
+        throw new Error(`invalid USDC amount: ${amount}`);
+    const [whole, frac = ""] = s.split(".");
+    if (frac.length > decimals)
+        throw new Error(`USDC supports at most ${decimals} decimals`);
+    return BigInt(whole + frac.padEnd(decimals, "0"));
+}
+/**
+ * Deposit USDC into Hyperliquid from Arbitrum. `chain` must be a Chain on the
+ * matching Arbitrum network with a funded signer. Returns the deposit tx hash;
+ * the credit appears on the signer's Hyperliquid account shortly after.
+ */
+export async function depositToHyperliquid(chain, amount, opts = {}) {
+    const cfg = HL_BRIDGE[opts.network ?? "mainnet"];
+    const units = usdcBaseUnits(amount, cfg.usdcDecimals);
+    const min = BigInt(cfg.minUsdc) * 10n ** BigInt(cfg.usdcDecimals);
+    if (units < min)
+        throw new Error(`Hyperliquid minimum deposit is ${cfg.minUsdc} USDC`);
+    return chain.send({
+        address: cfg.usdc,
+        abi: ERC20_TRANSFER,
+        functionName: "transfer",
+        args: [cfg.bridge, units],
+    });
+}

package/dist/index.d.ts

@@ -6,6 +6,8 @@ export { watchLogs } from "./watch.js";
 export type { WatchLogsOptions, WatchLogsResult } from "./watch.js";
 export { defineWatcher } from "./watcher.js";
 export type { WatcherEnv, WatcherMatch, WatcherScope, WatcherContext, WatcherDefinition, WatcherModule, SubscribeOptions, Confidence, MatchStatus, } from "./watcher.js";
+export { Signals, signals, DEFAULT_SIGNALS_URL } from "./signals.js";
+export type { SignalsOptions, Market, SignalMatch, Swap, Launch, EngineSnapshot, MarketFilter, } from "./signals.js";
 export { Relayer } from "./relayer.js";
 export { Queue, queue, queueEnvKey } from "./queue.js";
 export type { RelayerOptions } from "./relayer.js";
@@ -17,12 +19,33 @@ export { Telegram } from "./telegram.js";
 export type { TelegramOptions, BotMessage, SendMessageOptions, ChatJoinRequest } from "./telegram.js";
 export { verifyTelegramInitData, verifyTelegramLoginWidget, parseStartPayload } from "./telegramAuth.js";
 export type { TelegramUser, VerifyOptions } from "./telegramAuth.js";
+export { Email } from "./email.js";
+export type { EmailOptions, EmailMessage, EmailDirection, ListEmailsOptions, SendEmailOptions, SendEmailResult, } from "./email.js";
 export { TelegramLinks, TELEGRAM_LINKS_TABLE } from "./telegramLinks.js";
 export type { TelegramLink } from "./telegramLinks.js";
 export { tokenBalanceOf, meetsGate } from "./gate.js";
 export type { TokenGate } from "./gate.js";
+export { tokenMetadata, ownerOf, tokenURI } from "./reads.js";
+export type { TokenMetadata } from "./reads.js";
+export { resolveUri, fetchTokenMetadata } from "./nft.js";
+export type { NftMetadata, NftAttribute, FetchMetadataOptions } from "./nft.js";
+export { createSiweMessage, verifySiweMessage } from "./siwe.js";
+export type { SiweParams, SiweVerifyResult } from "./siwe.js";
+export { createSession, verifySession } from "./sessions.js";
+export type { SessionOptions } from "./sessions.js";
+export { json, error, withCors, CORS_HEADERS, Router, sse } from "./http.js";
+export type { RouteContext, RouteHandler, SseConnection } from "./http.js";
+export { rateLimit } from "./ratelimit.js";
+export type { KvLike, RateLimitOptions, RateLimitResult } from "./ratelimit.js";
+export { encrypt, decrypt } from "./aes.js";
+export { cached } from "./cache.js";
+export type { CacheOptions } from "./cache.js";
+export { verifyWebhook, signWebhook } from "./webhook.js";
+export type { VerifyWebhookParams, SignatureEncoding } from "./webhook.js";
 export { Hyperliquid } from "./hyperliquid.js";
-export type { HyperliquidOptions, PlaceOrderOptions, MarketOrderOptions, Tif, CandleInterval, CandlesOptions, AssetContext, AccountBalance, } from "./hyperliquid.js";
+export type { HyperliquidOptions, PlaceOrderOptions, MarketOrderOptions, Tif, CandleInterval, CandlesOptions, AssetContext, AccountBalance, PositionInfo, Bbo, } from "./hyperliquid.js";
+export { depositToHyperliquid, usdcBaseUnits, HL_BRIDGE } from "./hyperliquidBridge.js";
+export type { HlNetwork, HlBridgeConfig, DepositOptions } from "./hyperliquidBridge.js";
 export { Polymarket } from "./polymarket.js";
 export type { PolymarketOptions, PolymarketCreds, PlaceOrderParams, Side, OrderType, SignatureType, PriceInterval, PriceHistoryOptions, MarketOutcome, ResolvedMarket, } from "./polymarket.js";
 export { hashTypedData, signTypedData, localAccount } from "./eip712.js";