SDK Reference

// All public exports are available from the package root
import {
  // types
  Quote, RFQ, MakerConfig, RiskConfig,
  RFQJson, QuoteJson, PositionPreview,
  RelayMessage, RFQBroadcastMessage, QuoteSubmitMessage, QuoteBroadcastMessage,
  quoteToJson, quoteFromJson, rfqToJson, rfqFromJson,
  // eip712
  buildDomain, QUOTE_TYPES, quoteToTypedDataValue, hashQuoteStruct, hashQuoteTypedData,
  // signing
  signQuote, signQuoteWithKey,
  // verification
  verifyQuoteSignature, recoverQuoteSigner,
  // nonce
  NonceManager,
  // pricing
  StubPricingEngine, MarketData, PricingResult, PricingEngine, VolSurfaceParams,
  // risk
  RiskState, checkRisk, computeNotional, RiskCheckResult, ExpiryBucket,
  // rfqHash
  computeRfqId, computeRfqIdFromJson,
} from "@hyperquote/sdk-maker";

interface Quote {
  maker: string;          // address -- the maker (quote signer, buyer in V1)
  taker: string;          // address -- target taker, or address(0) for open
  underlying: string;     // address -- WHYPE in V1
  collateral: string;     // address -- USDC/USDH/USDT0
  isCall: boolean;        // true = Covered Call, false = Cash-Secured Put
  isMakerSeller: boolean; // V1: must be false
  strike: bigint;         // 1e18 fixed-point USD per underlying
  quantity: bigint;       // underlying base units (10^18 for WHYPE)
  premium: bigint;        // collateral base units (10^cDec)
  expiry: bigint;         // option expiry timestamp (must be 08:00 UTC)
  deadline: bigint;       // quote validity deadline (unix timestamp)
  nonce: bigint;          // maker nonce for replay protection
}

interface RFQ {
  requester: string;    // address -- the taker requesting quotes
  underlying: string;   // address -- asset for the option
  collateral: string;   // address -- collateral token
  isCall: boolean;      // true = CC, false = CSP
  strike: bigint;       // 1e18 fixed-point
  quantity: bigint;     // underlying base units
  expiry: bigint;       // must be 08:00 UTC
  minPremium: bigint;   // minimum acceptable premium in collateral units
  timestamp: bigint;    // when the RFQ was created (unix)
}

interface MakerConfig {
  privateKey: string;
  chainId: number;
  engineAddress: string;
  rpcUrl?: string;
  relayWsUrl?: string;
  allowedUnderlying: string[];
  collateralTokens: Record<string, { decimals: number; symbol: string }>;
  risk: RiskConfig;
  quoteDeadlineSecs: number;
}

interface RiskConfig {
  maxNotionalPerCollateral: Record<string, bigint>;
  maxTenorSecs: number;
  maxStrikeDeviationPct: number;
  maxDeltaPerExpiry: number;
  minPremium: Record<string, bigint>;
}

interface PositionPreview {
  isCall: boolean;
  strike: bigint;
  quantity: bigint;
  premium: bigint;
  expiry: bigint;
  collateralRequired: bigint;  // what the seller must lock
  maxLoss: bigint;             // worst-case for seller
  breakeven: bigint;           // strike +/- premium adjusted
  notional: bigint;            // strike * quantity in collateral units
}

type RelayMessageType =
  | "RFQ_SUBMIT" | "RFQ_BROADCAST" | "QUOTE_SUBMIT"
  | "QUOTE_BROADCAST" | "PING" | "PONG" | "ERROR";
 
interface RelayMessage {
  type: RelayMessageType;
  data: unknown;
}
 
interface RFQBroadcastMessage {
  type: "RFQ_BROADCAST";
  data: { rfqId: string; rfq: RFQJson };
}
 
interface QuoteSubmitMessage {
  type: "QUOTE_SUBMIT";
  data: { rfqId: string; quote: QuoteJson; makerSig: string };
}
 
interface QuoteBroadcastMessage {
  type: "QUOTE_BROADCAST";
  data: { rfqId: string; quote: QuoteJson; makerSig: string };
}

function quoteToJson(q: Quote): QuoteJson
function quoteFromJson(j: QuoteJson): Quote
function rfqToJson(r: RFQ): RFQJson
function rfqFromJson(j: RFQJson): RFQ

function buildDomain(chainId: number, verifyingContract: string): TypedDataDomain

const QUOTE_TYPES: Record<string, TypedDataField[]>

function quoteToTypedDataValue(q: Quote): Record<string, unknown>

function hashQuoteStruct(q: Quote): string

function hashQuoteTypedData(domain: TypedDataDomain, q: Quote): string

async function signQuote(
  wallet: Wallet,
  quote: Quote,
  chainId: number,
  engineAddress: string,
): Promise<string>

import { Wallet } from "ethers";
import { signQuote } from "@hyperquote/sdk-maker";
 
const wallet = new Wallet("0x59c6995e998f97a5a...");
const signature = await signQuote(wallet, quote, 31337, "0x5FbDB...");
// signature: "0x1a2b3c..." (132 chars total)

async function signQuoteWithKey(
  privateKey: string,
  quote: Quote,
  chainId: number,
  engineAddress: string,
): Promise<string>

function verifyQuoteSignature(
  quote: Quote,
  signature: string,
  chainId: number,
  engineAddress: string,
): boolean

function recoverQuoteSigner(
  quote: Quote,
  signature: string,
  chainId: number,
  engineAddress: string,
): string

class NonceManager {
  constructor(
    makerAddress: string,
    engineAddress: string,
    provider: JsonRpcProvider,
  )
 
  async init(): Promise<void>
  nextNonce(): bigint
  currentNonce(): bigint
  async resync(): Promise<void>
}

import { JsonRpcProvider } from "ethers";
import { NonceManager } from "@hyperquote/sdk-maker";
 
const provider = new JsonRpcProvider("http://127.0.0.1:8545");
const nonceManager = new NonceManager(makerAddress, engineAddress, provider);
 
await nonceManager.init();
const nonce = nonceManager.nextNonce(); // 0n
const nonce2 = nonceManager.nextNonce(); // 1n
 
// After calling incrementNonce() on-chain:
await nonceManager.resync();

interface MarketData {
  spotPrice: bigint;        // current spot price (1e18 = $1)
  ivBps: number;            // implied volatility in basis points (8000 = 80%)
  riskFreeRateBps: number;  // risk-free rate in basis points (500 = 5%)
}

interface PricingResult {
  premium: bigint;    // collateral base units (10^cDec)
  delta: number;      // BSM delta (e.g., -0.42 for a put)
  fairValue: bigint;  // theoretical value before spread
  ivUsed: number;     // implied vol actually used (after skew)
}

interface PricingEngine {
  price(rfq: RFQ, market: MarketData, cDec: number): PricingResult;
}

class StubPricingEngine implements PricingEngine {
  constructor(volSurface?: VolSurfaceParams)
  price(rfq: RFQ, market: MarketData, cDec: number): PricingResult
}

interface VolSurfaceParams {
  atmVolBps: number;          // default: 8000 (80%)
  skewBpsPerPctOtm: number;  // default: 50 (0.5% per 1% OTM)
  spreadBps: number;          // default: 200 (2% of notional)
}

class RiskState {
  expiryBuckets: Map<bigint, ExpiryBucket>
  notionalByCollateral: Map<string, bigint>
 
  recordQuote(
    collateral: string,
    expiry: bigint,
    notional: bigint,
    delta: number,
    isCall: boolean,
  ): void
}

interface ExpiryBucket {
  deltaExposure: number;  // signed delta (positive for calls, negative for puts)
  notional: bigint;       // total notional for this expiry
}

interface RiskCheckResult {
  passed: boolean;
  reason?: string;  // human-readable failure reason (only set when passed=false)
}

function checkRisk(
  rfq: RFQ,
  market: MarketData,
  config: RiskConfig,
  state: RiskState,
  cDec: number,
  delta: number,
): RiskCheckResult

function computeNotional(
  strike: bigint,
  quantity: bigint,
  uDec: number,
  cDec: number,
): bigint

function computeRfqId(rfq: RFQ): string

function computeRfqIdFromJson(rfqJson: RFQJson): string