Reference

/** Base-unit integer string, such as "1000000" for 1 USDC. Never a JavaScript number. */
type BaseUnitString = string;

/** Non-negative decimal with up to 12 fractional digits, such as "0.5" or "150.25". Not base units. */
type DecimalString = string;

type DlmmShape = "spot" | "curve" | "bidAsk";
type VaultStatus = "normal" | "paused" | "reduceOnly";

/** An optional sub-range of a position. Both ends inclusive, given together or not at all. */
type InclusiveBinSelection = { lowerBinId: number; upperBinId: number } | { lowerBinId?: never; upperBinId?: never };

interface PhoenixOrderId {
  priceInTicks: string; // u64 integer string
  orderSequenceNumber: string; // u64 integer string
}

type Outcome =
  | { kind: "confirmed"; signatures: string[]; created?: Created }
  | { kind: "refused"; signatures: string[]; reason: string }
  | { kind: "failed"; signatures: string[]; signature?: string; code: string; message: string }
  | { kind: "unresolved"; signatures: string[]; pending: string[] };

interface Created {
  vault?: string; // from vault/initialize
  child?: string; // from escrow/create
  position?: string; // from dlmm/initialize or dlmm/open
}

type Progress =
  | { kind: "building"; action: string }
  | { kind: "sent"; signature: string; status: "pending" | "unknown" }
  | { kind: "confirmed"; signature: string };

interface ExecuteOptions {
  onProgress?: (progress: Progress) => void | Promise<void>;
  sleep?: (ms: number) => Promise<void>; // test hook
  now?: () => number; // test hook
}

interface TransactionSigner {
  publicKey: PublicKey;
  signTransaction(tx: VersionedTransaction): Promise<VersionedTransaction>;
}

function createHedgeClient(options: HedgeClientOptions): HedgeClient

const hedge = createHedgeClient({
  apiKey: process.env.HEDGE_API_KEY ?? "",
  maxPriorityFeeLamports: 500_000n, // 0.0005 SOL
});

listVaults(): Promise<VaultSummary[]>

getVault(vault: string): Promise<VaultDetail>

getHoldings(vault: string): Promise<Holdings>

getStrategies(vault: string): Promise<Strategy[]>

getNavHistory(vault: string, limit?: number): Promise<NavHistoryPoint[]>

getRequests(vault: string): Promise<RequestQueue>

getStrategyHistory(vault: string): Promise<StrategyHistoryItem[]>

getPhoenix(vault: string): Promise<PhoenixManager>

getQuote(request: QuoteRequest): Promise<Quote>

interface QuoteRequest {
  vault: string;
  inputMint: string;
  outputMint: string;
  amount: string; // base units of inputMint
  slippageBps: number;
}

getToken(vault: string, mint: string): Promise<TokenDetail>

searchPools(vault: string, query: string, page?: number): Promise<PoolSearchPage>

getPool(vault: string, lbPair: string): Promise<PoolInfo>

execute(request: ActionRequest, signer: TransactionSigner, options?: ExecuteOptions): Promise<Outcome>

onboardPhoenix(vault: string, signer: TransactionSigner, options?: ExecuteOptions): Promise<Outcome>

build(action: string, body: Record<string, unknown>): Promise<BuiltStep[]>
send(signedTransactionBase64: string, ticket: string): Promise<SendResult>
status(receipt: string): Promise<TransactionStatus>

function keypairSigner(keypair: Keypair): TransactionSigner

function keypairFromFile(path: string): Keypair

function inspectTransaction(base64: string, policy: SigningPolicy): VersionedTransaction

interface SigningPolicy {
  manager: PublicKey;
  programId: string;
  maxPriorityFeeLamports: bigint; // price × compute unit limit, rounded up to lamports
  maxComputeUnitPriceMicroLamports?: bigint; // optional extra cap on the price alone
}

const policy: SigningPolicy = {
  manager: signer.publicKey,
  programId: HEDGE_VAULT_PROGRAM_ID,
  maxPriorityFeeLamports: DEFAULT_MAX_PRIORITY_FEE_LAMPORTS,
};
for (const step of await hedge.build("jupiter/swap", body)) inspectTransaction(step.transaction, policy);

function inspectPhoenixOnboardTransaction(base64: string, policy: SigningPolicy): VersionedTransaction

function binRangeForPrices(pool: PoolPricing, minPrice: number, maxPrice: number): PriceRange

interface PriceRange {
  lowerBinId: number;
  upperBinId: number; // exclusive, as dlmm/open expects
  binCount: number;
  sides: "x" | "y" | "both";
  lowPrice: number; // actual price of the first bin
  highPrice: number; // actual price of the last bin
}

function binPrice(pool: PoolPricing, binId: number): number

function flipSide(tokenXMint: string, depositMint: string): "x" | "y"

function flipRange(selection: InclusiveBinRange, activeBinId: number, side: FlipSide): InclusiveBinRange | null

function parseUnits(display: string, decimals: number): string

function formatUnits(baseUnits: string, decimals: number): string

parseUnits("1.5", 6); // "1500000"
formatUnits("1500000", 6); // "1.5"

try {
  await hedge.getStrategyHistory(vault);
} catch (error) {
  if (error instanceof ApiError && error.code === "HistoryUnavailable") console.log("No history database");
  else throw error;
}