@depthhq/maker-sdk 0.0.0-stage → 0.1.2

package/dist/automation/automation.d.ts

@@ -0,0 +1,24 @@
+import type { AbstractWallet } from "@nktkas/hyperliquid/signing";
+import type { MakerClient } from "../client/client.js";
+import { WalletSession } from "../hedge/access.js";
+import { type AutomationConfig, type AutomationView } from "./types.js";
+export declare class MakerAutomation extends WalletSession {
+    private readonly maker;
+    constructor(maker: MakerClient);
+    private view;
+    summary(): Promise<AutomationView | null>;
+    configure(config: AutomationConfig, revision?: number): Promise<AutomationView>;
+    approve(profile: AutomationView, options?: {
+        grantSeconds?: number;
+        operatorFundingLamports?: bigint;
+        hedgeWallet?: AbstractWallet;
+    }): Promise<{
+        profile: AutomationView;
+        signatures: string[];
+    }>;
+    private waitFunding;
+    private command;
+    start(revision?: number): Promise<AutomationView>;
+    pause(revision?: number): Promise<AutomationView>;
+    resume(revision?: number): Promise<AutomationView>;
+}

package/dist/automation/types.d.ts

@@ -0,0 +1,40 @@
+import { type BotPolicy } from "../bot/policy.js";
+import type { HedgePolicy } from "../hedge/types.js";
+import type { MakerHedgeView } from "../hedge/access.js";
+export type AutomationConfig = {
+    quote: BotPolicy;
+    hedge?: {
+        account: `0x${string}`;
+        policy: HedgePolicy;
+    };
+};
+export type Wire<T> = T extends bigint ? string : T extends object ? {
+    [K in keyof T]: Wire<T[K]>;
+} : T;
+export type AutomationView = {
+    owner: string;
+    environment: "devnet" | "mainnet-beta";
+    revision: number;
+    operator: string;
+    agent: `0x${string}`;
+    config: Wire<AutomationConfig>;
+    desired: "running" | "paused";
+    phase: "configured" | "starting" | "running" | "pausing" | "paused" | "blocked";
+    updatedAt: number;
+    reason?: string;
+    bot?: {
+        phase: "active" | "pending" | "idle" | "stopped";
+        reason?: string;
+        quoteId?: string;
+        fillCount: number;
+    };
+    hedge: MakerHedgeView;
+    funding?: {
+        signature: string;
+        lamports: string;
+        status: "pending" | "confirmed" | "expired" | "failed";
+    };
+};
+export declare function automationConfig(value: unknown): AutomationConfig;
+export declare const automationWire: (config: AutomationConfig) => Wire<AutomationConfig>;
+export declare function automationView(value: unknown, owner: string, environment: string): AutomationView | null;

package/dist/backstop/backstop.d.ts

@@ -0,0 +1,35 @@
+import { PublicKey } from "@solana/web3.js";
+import type { MakerClient } from "../client/client.js";
+import type { BackstopInput } from "../client/types.js";
+export type BackstopSnapshot = {
+    offerId: PublicKey;
+    status: string;
+    capacity: bigint;
+    margin: bigint;
+    expiresAt: number;
+};
+type ConfirmOptions = {
+    timeoutMs?: number;
+    pollMs?: number;
+};
+export declare class BackstopHandle {
+    readonly id: PublicKey;
+    private readonly client;
+    readonly signature?: string | undefined;
+    constructor(id: PublicKey, client: MakerClient, signature?: string | undefined);
+    static offer(client: MakerClient, input: BackstopInput): Promise<BackstopHandle>;
+    status(): Promise<BackstopSnapshot>;
+    confirm(options?: ConfirmOptions): Promise<{
+        offerId: PublicKey;
+        snapshot: BackstopSnapshot;
+    }>;
+    release(): Promise<BackstopRelease>;
+    close(): Promise<string>;
+}
+export declare class BackstopRelease {
+    private readonly offer;
+    readonly signature?: string | undefined;
+    constructor(offer: BackstopHandle, signature?: string | undefined);
+    confirm(options?: ConfirmOptions): Promise<BackstopSnapshot>;
+}
+export {};

package/dist/bot/bot.d.ts

@@ -0,0 +1,42 @@
+import type { MakerClient } from "../client/client.js";
+import { BotStore } from "./store.js";
+import { type BotPolicy } from "./policy.js";
+import { HedgeEngine } from "../hedge/engine.js";
+export type BotSnapshot = {
+    phase: "active" | "pending" | "idle" | "stopped";
+    reason?: string;
+    quoteId?: string;
+    fillCount: number;
+};
+export declare class MakerBot {
+    readonly maker: MakerClient;
+    readonly policy: BotPolicy;
+    readonly store: BotStore;
+    readonly hedge?: HedgeEngine | undefined;
+    private state?;
+    private position?;
+    private dirty;
+    private busy;
+    private stopping;
+    private pricing?;
+    private hedgeLease?;
+    private pricingDirty;
+    private constructor();
+    static create(options: {
+        maker: MakerClient;
+        policy: BotPolicy;
+        stateDirectory: string;
+        hedge?: HedgeEngine;
+    }): Promise<MakerBot>;
+    private saveHedge;
+    private hedgeTick;
+    private snapshot;
+    private requestId;
+    private reconcile;
+    private fills;
+    private cancel;
+    tick(): Promise<BotSnapshot>;
+    stop(): void;
+    close(): Promise<void>;
+}
+export declare const create_maker_bot: typeof MakerBot.create;

package/dist/bot/policy.d.ts

@@ -0,0 +1,41 @@
+import type { QuoteInput, MarketState } from "../client/types.js";
+import type { PositionSnapshot } from "@depthhq/sdk";
+import { type HedgeBook } from "../hedge/types.js";
+export type BotPolicy = {
+    maxCapacity: bigint;
+    maxInventoryNotional: bigint;
+    spreadBps: number;
+    repriceBps: number;
+    lifetimeSeconds: number;
+    refreshSeconds: number;
+    gasReserveLamports?: bigint;
+    inventorySkewBps?: number;
+    executionCostBps?: number;
+    fundingHours?: number;
+};
+export type BotPricing = {
+    book: HedgeBook;
+    externalPosition: bigint;
+    maxPriceAgeMs: number;
+    takerFeeBps: number;
+    hourlyFundingBps: number;
+};
+export type BotMarket = MarketState & {
+    oraclePriceE8: {
+        toString(): string;
+    };
+    fundingIndex: {
+        toString(): string;
+    };
+    incident: Record<string, unknown>;
+    lastFundingTimestamp: {
+        toNumber(): number;
+    };
+    config: MarketState["config"] & {
+        maxQuoteDeviationBps: number;
+        fundingIntervalSeconds: number;
+    };
+};
+export declare function validateBotPolicy(policy: BotPolicy): void;
+export declare function quoteHealth(market: BotMarket, now: number): string | undefined;
+export declare function botQuote(policy: BotPolicy, market: BotMarket, position: PositionSnapshot, nonce: bigint, now: number, pricing?: BotPricing): QuoteInput | undefined;

package/dist/bot/store.d.ts

@@ -0,0 +1,32 @@
+import type { QuoteInput } from "../client/types.js";
+import type { HedgeState } from "../hedge/types.js";
+export type BotState = {
+    genesis: string;
+    maker: string;
+    operator: string;
+    cursor?: string;
+    quote?: string;
+    request?: QuoteInput;
+    referencePrice?: bigint;
+    replacement?: {
+        prior: string;
+        nonce: bigint;
+    };
+    fills: Record<string, {
+        signature: string;
+        slot: number;
+    }>;
+    hedge?: HedgeState;
+};
+export declare class BotStore {
+    readonly genesis: string;
+    readonly maker: string;
+    readonly operator: string;
+    readonly path: string;
+    private lock?;
+    constructor(genesis: string, maker: string, operator: string, directory: string);
+    acquire(): Promise<void>;
+    release(): Promise<void>;
+    load(): Promise<BotState>;
+    save(state: BotState): Promise<void>;
+}

package/dist/chain/arcium.d.ts

@@ -0,0 +1,18 @@
+import * as anchor from "@anchor-lang/core";
+import type { Connection, PublicKey } from "@solana/web3.js";
+type MxeState = {
+    cluster: number;
+    mxeProgramId: PublicKey;
+};
+export declare function mxeAccount(provider: anchor.AnchorProvider): {
+    fetch(address: PublicKey): Promise<MxeState>;
+};
+export declare function queueAccounts(provider: anchor.AnchorProvider, connection: Connection, name: string, offset: anchor.BN): Promise<{
+    computationAccount: anchor.web3.PublicKey;
+    clusterAccount: anchor.web3.PublicKey;
+    mxeAccount: anchor.web3.PublicKey;
+    mempoolAccount: anchor.web3.PublicKey;
+    executingPool: anchor.web3.PublicKey;
+    compDefAccount: anchor.web3.PublicKey;
+}>;
+export {};

package/dist/chain/random.d.ts

@@ -0,0 +1 @@
+export declare function randomBytes(length: number): Uint8Array;

package/dist/client/client.d.ts

@@ -0,0 +1,181 @@
+import * as anchor from "@anchor-lang/core";
+import { SOL_USD_MARKET_ID } from "@depthhq/bindings";
+import { DepthView } from "@depthhq/sdk/views";
+import { DepthRecovery } from "@depthhq/sdk/recovery";
+import type { FillSnapshot } from "@depthhq/sdk/views";
+import { PublicKey } from "@solana/web3.js";
+import { MakerAccess } from "../hedge/access.js";
+import { MakerAutomation } from "../automation/automation.js";
+import { DepthClient, FundingClient } from "@depthhq/sdk";
+import type { AmountSelector, CloseInput, ReductionInput, ReverseInput, TradeInput } from "@depthhq/sdk";
+import { BackstopHandle } from "../backstop/backstop.js";
+import { FillHistory } from "../fill/history.js";
+import { QuoteHandle } from "../quote/quote.js";
+import { QuoteReplacement } from "../quote/replacement.js";
+import type { GrantState, BackstopInput, MakerOptions, ResolvedMakerOptions, QuoteRequest, QuoteState } from "./types.js";
+export declare function retryQuote<T>(action: () => Promise<T>, deadline: number): Promise<T>;
+export declare class MakerClient {
+    readonly options: ResolvedMakerOptions;
+    readonly hedges: MakerAccess;
+    readonly automation: MakerAutomation;
+    readonly provider: anchor.AnchorProvider;
+    readonly program: anchor.Program;
+    readonly position: ReturnType<MakerClient["positionActions"]>;
+    readonly marketAddress: anchor.web3.PublicKey;
+    readonly quoteQueueAddress: anchor.web3.PublicKey;
+    readonly protocolAddress: anchor.web3.PublicKey;
+    readonly backstop: ((id: PublicKey) => BackstopHandle) & {
+        offer: (input: BackstopInput) => Promise<BackstopHandle>;
+    };
+    private ownerClient?;
+    private owned;
+    get funding(): FundingClient;
+    get recovery(): DepthRecovery;
+    private constructor();
+    static create(options: MakerOptions): Promise<MakerClient>;
+    private accountActions;
+    readonly account: (() => {
+        history: (options?: Parameters<DepthClient["account"]["history"]>[0]) => Promise<import("@depthhq/sdk").PendingPage>;
+        cancelOpen: () => Promise<string>;
+        open: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        openMarket: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        summary: () => Promise<import("@depthhq/sdk").BalanceSnapshot>;
+        pending: () => Promise<import("@depthhq/sdk").PendingPage>;
+        deposit: (sourceOrAmount: PublicKey | bigint, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").DepositHandle>;
+        withdrawalHandle: (clientNonce: bigint) => import("@depthhq/sdk").WithdrawalHandle;
+        depositHandle: (nonce: bigint) => import("@depthhq/sdk").DepositHandle;
+        withdraw: (destinationOrAmount: PublicKey | AmountSelector, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").WithdrawalHandle>;
+        allocate: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        release: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        transferHandle: (nonce: bigint) => import("@depthhq/sdk").TransferHandle;
+    }) & {
+        history: (options?: Parameters<DepthClient["account"]["history"]>[0]) => Promise<import("@depthhq/sdk").PendingPage>;
+        cancelOpen: () => Promise<string>;
+        open: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        openMarket: () => Promise<{
+            address: PublicKey;
+            signature: string;
+        }>;
+        summary: () => Promise<import("@depthhq/sdk").BalanceSnapshot>;
+        pending: () => Promise<import("@depthhq/sdk").PendingPage>;
+        deposit: (sourceOrAmount: PublicKey | bigint, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").DepositHandle>;
+        withdrawalHandle: (clientNonce: bigint) => import("@depthhq/sdk").WithdrawalHandle;
+        depositHandle: (nonce: bigint) => import("@depthhq/sdk").DepositHandle;
+        withdraw: (destinationOrAmount: PublicKey | AmountSelector, amount?: bigint, clientNonce?: bigint) => Promise<import("@depthhq/sdk").WithdrawalHandle>;
+        allocate: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        release: (input: bigint | {
+            marketId: typeof SOL_USD_MARKET_ID;
+            amount: AmountSelector;
+        }, clientNonce?: bigint) => Promise<import("@depthhq/sdk").TransferHandle>;
+        transferHandle: (nonce: bigint) => import("@depthhq/sdk").TransferHandle;
+    };
+    readonly positions: {
+        list: () => Promise<{
+            items: {
+                id: anchor.web3.PublicKey;
+                marketId: string;
+            }[];
+            nextCursor: null;
+        }>;
+    };
+    readonly trade: {
+        submit: (input: TradeInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+        reduce: (input: ReductionInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+        close: (input: CloseInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+        reverse: (input: ReverseInput) => Promise<import("@depthhq/sdk").DepthOperation>;
+    };
+    marketAccount(): PublicKey;
+    grantAddress(operator?: anchor.web3.PublicKey): PublicKey;
+    read<T>(name: string, address: PublicKey, commitment?: "confirmed" | "finalized"): Promise<T>;
+    quoteState(id: PublicKey): Promise<QuoteState>;
+    queue(name: string, computationOffset: anchor.BN): Promise<{
+        computationAccount: anchor.web3.PublicKey;
+        clusterAccount: anchor.web3.PublicKey;
+        mxeAccount: anchor.web3.PublicKey;
+        mempoolAccount: anchor.web3.PublicKey;
+        executingPool: anchor.web3.PublicKey;
+        compDefAccount: anchor.web3.PublicKey;
+    }>;
+    private grantFor;
+    readonly operator: {
+        list: () => Promise<{
+            id: anchor.web3.PublicKey;
+            state: GrantState;
+        }[]>;
+        authorize: (input: {
+            operator: PublicKey;
+            maxCapacity: bigint;
+            expiresAt: number;
+            canView: boolean;
+        }) => Promise<string>;
+        revoke: (operator: PublicKey) => Promise<string>;
+    };
+    readonly quote: {
+        replacement: (prior: PublicKey, clientNonce: bigint) => QuoteReplacement;
+        publish: (request: QuoteRequest) => Promise<QuoteHandle>;
+        get: (id: PublicKey) => QuoteHandle;
+        list: (options?: {
+            cursor?: string;
+            limit?: number;
+        }) => Promise<{
+            items: {
+                id: anchor.web3.PublicKey;
+                nonce: bigint;
+                status: string;
+                replacementNonce: bigint | undefined;
+                handle: QuoteHandle;
+            }[];
+            nextCursor: string | null;
+        }>;
+        active: () => Promise<QuoteHandle[]>;
+        replace: (prior: PublicKey, input: QuoteRequest, options?: {
+            timeoutMs?: number;
+            pollMs?: number;
+        }) => Promise<QuoteHandle>;
+    };
+    private flatQuote;
+    private viewGrant;
+    requestMarketView(): Promise<DepthView>;
+    requestFillView(order: PublicKey): Promise<DepthView>;
+    requestQuoteView(quote: PublicKey): Promise<DepthView>;
+    private requestView;
+    private positionActions;
+    readonly fills: {
+        list: (options?: Parameters<FillHistory["list"]>[0]) => Promise<import("../fill/history.js").FillPage>;
+        subscribe: (options: {
+            marketId: typeof SOL_USD_MARKET_ID;
+            onFill: (fill: {
+                id: string;
+                signature: string;
+                slot: number;
+                execution: FillSnapshot;
+            }) => Promise<void>;
+            onError: (error: unknown) => void;
+            pollMs?: number;
+        }) => Promise<() => void>;
+        get: (order: PublicKey, options?: {
+            timeoutMs: number;
+            pollMs?: number;
+        }) => Promise<FillSnapshot>;
+    };
+    private validateQuote;
+}
+export declare function createDepthMaker(options: MakerOptions): Promise<MakerClient>;

package/dist/client/types.d.ts

@@ -0,0 +1,100 @@
+import type { ConnectionOptions, ResolvedConnection, DepthWallet } from "@depthhq/sdk";
+import type * as anchor from "@anchor-lang/core";
+import type { PublicKey } from "@solana/web3.js";
+import { SOL_USD_MARKET_ID } from "@depthhq/bindings";
+export type MakerOptions = ConnectionOptions & {
+    wallet: DepthWallet & {
+        signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+    };
+    maker?: PublicKey;
+    makerOwner?: PublicKey;
+    appId?: PublicKey | string;
+    cursorDirectory?: string;
+};
+export type ResolvedMakerOptions = ResolvedConnection & Omit<MakerOptions, keyof ConnectionOptions | "maker" | "appId"> & {
+    maker: PublicKey;
+    appId?: PublicKey;
+};
+export type QuoteTier = {
+    size: bigint;
+    bidE8: bigint;
+    askE8: bigint;
+};
+export type QuoteInput = {
+    tiers: QuoteTier[];
+    maxCapacity: bigint;
+    expiresAt: number;
+    clientNonce: bigint;
+};
+export type FlatQuoteInput = {
+    marketId: typeof SOL_USD_MARKET_ID;
+    bidE8: bigint;
+    askE8: bigint;
+    maxCapacity: bigint;
+    validForSeconds: number;
+    clientNonce?: bigint;
+};
+export type QuoteRequest = QuoteInput | FlatQuoteInput;
+export type QuoteState = {
+    status: Record<string, unknown>;
+    maker: PublicKey;
+    operator: PublicKey;
+    operatorVersion: anchor.BN;
+    market: PublicKey;
+    nonce: anchor.BN;
+    capacity: anchor.BN;
+    expiry: anchor.BN;
+    attachedOrders: number;
+    replacementNonce: anchor.BN | null;
+};
+export type MarketState = {
+    revision: anchor.BN;
+    status: Record<string, unknown>;
+    settlementMint: PublicKey;
+    vault: PublicKey;
+    oracleTimestamp: anchor.BN;
+    pendingOrders: number;
+    backstopOffer: PublicKey;
+    activeQuoteCount: number;
+    activeQuotes: PublicKey[];
+    quotedNotional: anchor.BN;
+    config: {
+        quoteTiers: anchor.BN[];
+        initialMarginBps: number;
+        maxAccountNotional: anchor.BN;
+        maxMarketNotional: anchor.BN;
+        maxQuoteLifetimeSeconds: number;
+        maxOracleAgeSeconds: number;
+        backstopMinCollateral: anchor.BN;
+    };
+};
+export type QuoteQueueState = {
+    market: PublicKey;
+    count: number;
+    entries: PublicKey[];
+};
+export type BackstopInput = {
+    marketId: typeof SOL_USD_MARKET_ID;
+    maxCapacity: bigint;
+    validForSeconds: number;
+    clientNonce?: bigint;
+};
+export type BackstopState = {
+    maker: PublicKey;
+    market: PublicKey;
+    nonce: anchor.BN;
+    capacity: anchor.BN;
+    margin: anchor.BN;
+    expiry: anchor.BN;
+    status: Record<string, unknown>;
+};
+export type GrantState = {
+    active: boolean;
+    canView: boolean;
+    maker: PublicKey;
+    operator: PublicKey;
+    market: PublicKey;
+    maxCapacity: anchor.BN;
+    expiresAt: anchor.BN;
+    version: anchor.BN;
+};

package/dist/fill/browser.d.ts

@@ -0,0 +1,8 @@
+export declare class BrowserCursorStore {
+    readonly key: string;
+    constructor(genesis: string, maker: string);
+    private database;
+    load(): Promise<string | undefined>;
+    save(cursor: string): Promise<void>;
+}
+export declare function createCursorStore(genesis: string, maker: string, _directory?: string): BrowserCursorStore;

package/dist/fill/cursor.d.ts

@@ -0,0 +1,8 @@
+export declare class FillCursorStore {
+    readonly genesis: string;
+    readonly maker: string;
+    readonly path: string;
+    constructor(genesis: string, maker: string, directory?: string);
+    load(): Promise<string | undefined>;
+    save(cursor: string): Promise<void>;
+}

package/dist/fill/history.d.ts

@@ -0,0 +1,25 @@
+import type { MakerClient } from "../client/client.js";
+export type FillPage = {
+    fills: {
+        id: string;
+        signature: string;
+        slot: number;
+    }[];
+    cursor?: string;
+    head?: string;
+};
+export declare class FillHistory {
+    private readonly client;
+    constructor(client: MakerClient);
+    list(options?: {
+        before?: string;
+        until?: string;
+        limit?: number;
+    }): Promise<FillPage>;
+    subscribe(listener: (fill: FillPage["fills"][number]) => Promise<void>, options: {
+        cursor?: string;
+        pollMs?: number;
+        saveCursor: (cursor: string) => Promise<void>;
+        onError: (error: unknown) => void;
+    }): () => void;
+}

package/dist/fill/store.d.ts

@@ -0,0 +1,2 @@
+import { FillCursorStore } from "./cursor.js";
+export declare function createCursorStore(genesis: string, maker: string, directory?: string): FillCursorStore;

package/dist/hedge/access.d.ts

@@ -0,0 +1,40 @@
+import type { PublicKey } from "@solana/web3.js";
+type Wire<T> = T extends bigint ? string : T extends Array<infer U> ? Wire<U>[] : T extends object ? {
+    [K in keyof T]: Wire<T[K]>;
+} : T;
+export type MakerHedgeView = {
+    enabled: boolean;
+    maker: string;
+    snapshot: Wire<import("./types.js").HedgeSnapshot> | null;
+};
+export declare const accessMessage: (wallet: string, nonce: string, expiresAt: number, scope?: string) => string;
+export declare class WalletSession {
+    protected readonly options: {
+        serviceUrl?: string;
+        wallet: {
+            publicKey: PublicKey;
+            signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+        };
+    };
+    private readonly scope;
+    private readonly prefix;
+    protected token?: {
+        value: string;
+        expiresAt: number;
+    };
+    constructor(options: {
+        serviceUrl?: string;
+        wallet: {
+            publicKey: PublicKey;
+            signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+        };
+    }, scope?: string, prefix?: string);
+    protected request(path: string, init?: RequestInit): Promise<any>;
+    authorize(): Promise<void>;
+    protected authorizedRequest(path: string, body?: unknown): Promise<any>;
+    disconnect(): void;
+}
+export declare class MakerAccess extends WalletSession {
+    summary(): Promise<MakerHedgeView>;
+}
+export {};

package/dist/hedge/amount.d.ts

@@ -0,0 +1,2 @@
+export declare function units(value: string, decimals: number, exact?: boolean): bigint;
+export declare function decimal(value: bigint, decimals: number): string;

package/dist/hedge/engine.d.ts

@@ -0,0 +1,9 @@
+import { type HedgeAdapter, type HedgePolicy, type HedgeSnapshot, type HedgeState } from "./types.js";
+export declare class HedgeEngine {
+    readonly adapter: HedgeAdapter;
+    readonly policy: HedgePolicy;
+    snapshot?: HedgeSnapshot;
+    private busy;
+    constructor(adapter: HedgeAdapter, policy: HedgePolicy);
+    tick(state: HedgeState, save: () => Promise<void>, depthPosition: bigint | undefined, timestamp?: number, reconcileOnly?: boolean): Promise<HedgeSnapshot>;
+}

package/dist/hedge/hyperliquid.d.ts

@@ -0,0 +1,35 @@
+import { type AbstractWallet } from "@nktkas/hyperliquid/signing";
+import type { HedgeAccount, HedgeAdapter, HedgeBook, HedgeOrder, HedgeReceipt } from "./types.js";
+export { units, decimal } from "./amount.js";
+export declare class HyperliquidAdapter implements HedgeAdapter {
+    readonly network: "testnet" | "mainnet";
+    readonly address: `0x${string}`;
+    private readonly wallet;
+    private readonly transport;
+    private readonly info;
+    private readonly asset;
+    private readonly sizeDecimals;
+    readonly minNotional = 10000000n;
+    readonly identity: string;
+    readonly sizeStep: bigint;
+    private readonly cache;
+    private cached;
+    private constructor();
+    static create(options: {
+        wallet?: AbstractWallet;
+        agentKey?: `0x${string}`;
+        account: `0x${string}`;
+        network?: "testnet" | "mainnet";
+    }): Promise<HyperliquidAdapter>;
+    book(): Promise<HedgeBook>;
+    account(): Promise<HedgeAccount>;
+    costs(): Promise<{
+        takerFeeBps: number;
+        hourlyFundingBps: number;
+    }>;
+    price(value: bigint, buy: boolean): bigint;
+    submit(order: HedgeOrder): Promise<HedgeReceipt>;
+    receipt(order: HedgeOrder): Promise<HedgeReceipt>;
+    cancel(order: HedgeOrder, nonce?: number): Promise<void>;
+}
+export declare const create_hyperliquid: typeof HyperliquidAdapter.create;

package/dist/hedge/policy.d.ts

@@ -0,0 +1,4 @@
+import type { HedgeBook, HedgePolicy } from "./types.js";
+export declare function validateHedgePolicy(policy: HedgePolicy): void;
+export declare function validateBook(book: HedgeBook, now: number, maxAge: number): void;
+export declare function executionPrice(levels: HedgeBook["bids"], size: bigint): bigint;

package/dist/hedge/schema.d.ts

@@ -0,0 +1,2 @@
+import type { MakerHedgeView } from "./access.js";
+export declare function hedgeView(value: unknown, owner: string): MakerHedgeView;