@depthhq/maker-sdk 0.1.0 → 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/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/client/client.d.ts

@@ -4,6 +4,8 @@ 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";
@@ -11,8 +13,11 @@ 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"]>;
@@ -99,7 +104,7 @@ export declare class MakerClient {
     };
     marketAccount(): PublicKey;
     grantAddress(operator?: anchor.web3.PublicKey): PublicKey;
-    read<T>(name: string, address: PublicKey): Promise<T>;
+    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;

package/dist/client/types.d.ts

@@ -3,7 +3,9 @@ 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;
+    wallet: DepthWallet & {
+        signMessage?: (message: Uint8Array) => Promise<Uint8Array>;
+    };
     maker?: PublicKey;
     makerOwner?: PublicKey;
     appId?: PublicKey | string;

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;

package/dist/hedge/setup.d.ts

@@ -0,0 +1,22 @@
+import { type AbstractWallet } from "@nktkas/hyperliquid/signing";
+export declare function verify_hyperliquid(options: {
+    account: `0x${string}`;
+    agent: `0x${string}`;
+    network: "testnet" | "mainnet";
+    maxLeverage: number;
+}): Promise<void>;
+export declare function setup_hyperliquid(options: {
+    wallet?: AbstractWallet;
+    accountKey?: `0x${string}`;
+    account?: `0x${string}`;
+    agent?: `0x${string}`;
+    agentKey?: `0x${string}`;
+    network?: "testnet" | "mainnet";
+    leverage: number;
+    agentName?: string;
+}): Promise<{
+    account: `0x${string}`;
+    agent: `0x${string}`;
+    network: "testnet" | "mainnet";
+    leverage: number;
+}>;

package/dist/hedge/types.d.ts

@@ -0,0 +1,89 @@
+export type HedgePolicy = {
+    ratioBps: number;
+    thresholdNotional: bigint;
+    maxUnhedgedNotional: bigint;
+    maxOrderNotional: bigint;
+    batchMs: number;
+    maxUnhedgedMs: number;
+    maxSlippageBps: number;
+    maxPriceAgeMs: number;
+    orderTtlMs: number;
+    maxLeverage: number;
+};
+export type HedgeLevel = {
+    priceE8: bigint;
+    size: bigint;
+};
+export type HedgeBook = {
+    timestamp: number;
+    bids: HedgeLevel[];
+    asks: HedgeLevel[];
+};
+export type HedgeAccount = {
+    timestamp: number;
+    position: bigint;
+    availableMargin: bigint;
+    leverage: number;
+    openOrders: string[];
+};
+export type HedgeOrder = {
+    cloid: string;
+    nonce: number;
+    expiresAt: number;
+    buy: boolean;
+    size: bigint;
+    limitPriceE8: bigint;
+    reduceOnly: boolean;
+};
+export type HedgeReceipt = {
+    status: "filled" | "cancelled" | "rejected" | "open" | "unknown";
+    orderId?: number;
+    filledSize: bigint;
+    averagePriceE8?: bigint;
+    fee?: bigint;
+    hashes?: string[];
+    reason?: string;
+};
+export type HedgeRecord = HedgeOrder & HedgeReceipt & {
+    completedAt: number;
+};
+export type HedgeState = {
+    identity: string;
+    depthAccount?: string;
+    nonce: number;
+    unhedgedSince?: number;
+    pending?: HedgeOrder;
+    history: HedgeRecord[];
+};
+export type HedgeSnapshot = {
+    venue: "hyperliquid";
+    network: "testnet" | "mainnet";
+    account: string;
+    updatedAt: number;
+    phase: "balanced" | "waiting" | "pending" | "blocked";
+    reason?: string;
+    depthPosition?: bigint;
+    externalPosition?: bigint;
+    unhedgedPosition?: bigint;
+    pending?: HedgeOrder;
+    history: HedgeRecord[];
+};
+export interface HedgeAdapter {
+    readonly identity: string;
+    readonly network: "testnet" | "mainnet";
+    readonly address: string;
+    readonly sizeStep: bigint;
+    readonly minNotional: bigint;
+    book(): Promise<HedgeBook>;
+    costs(): Promise<{
+        takerFeeBps: number;
+        hourlyFundingBps: number;
+    }>;
+    account(): Promise<HedgeAccount>;
+    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 abs: (value: bigint) => bigint;
+export declare const notional: (size: bigint, priceE8: bigint) => bigint;

package/dist/hedge/wallet.d.ts

@@ -0,0 +1,8 @@
+import type { AbstractViemJsonRpcAccount } from "@nktkas/hyperliquid/signing";
+export type EthereumProvider = {
+    request(input: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+};
+export declare function connect_hyperliquid(provider: EthereumProvider): Promise<AbstractViemJsonRpcAccount>;

package/dist/index.d.ts

@@ -7,3 +7,11 @@ export type { BackstopSnapshot } from "./backstop/backstop.js";
 export type { QuoteSnapshot } from "./quote/quote.js";
 export type { FlatQuoteInput, BackstopInput, MakerOptions, QuoteInput, QuoteRequest, QuoteTier, } from "./client/types.js";
 export type { FillPage } from "./fill/history.js";
+export { MakerAccess } from "./hedge/access.js";
+export type { MakerHedgeView } from "./hedge/access.js";
+export { MakerAutomation } from "./automation/automation.js";
+export { automationConfig, automationWire, automationView, } from "./automation/types.js";
+export type { AutomationConfig, AutomationView } from "./automation/types.js";
+export { setup_hyperliquid } from "./hedge/setup.js";
+export { connect_hyperliquid } from "./hedge/wallet.js";
+export type { EthereumProvider } from "./hedge/wallet.js";