@parchment-trade/sdk 0.0.0-stage → 1.0.1

package/dist/packages/parchment/monitoring.d.ts

@@ -0,0 +1,369 @@
+/**
+ * `GET stats/monitoring?days=N` : protocol monitoring indexed from on-chain events and
+ * objects. Days are UTC day numbers (`ms / 86_400_000`); every `days` series runs `fromDay` to
+ * `toDay`, oldest first. Amounts are USDC base units unless noted (PARCHMENT ones are named so).
+ *
+ * Not carried: the API's `queue.lossFeeOff` (the loss fee is carved even with a queue, so it
+ * no longer reports anything) and the referral reserve flow / balance (the staking referral
+ * bonus is paid from the treasury side, there is no shared reserve).
+ */
+export interface ParchmentMonitoring {
+    nowMs: bigint;
+    fromDay: bigint;
+    toDay: bigint;
+    /** False while the service is still folding history indexed before these stats existed. */
+    complete: boolean;
+    mintCap: ParchmentMintCapStats;
+    queue: ParchmentQueueStats;
+    exposure: ParchmentMarketExposure[];
+    fees: ParchmentFeeStats;
+    fillLag: ParchmentMarketFillLag[];
+    shortHolds: ParchmentShortHoldStats;
+}
+/** One finalized daily mint-cap epoch. */
+export interface ParchmentMintEpoch {
+    epoch: bigint;
+    /** The pool's net trading gain as two sums (fees excluded). */
+    gainUp: bigint;
+    gainDown: bigint;
+    /** PARCHMENT mint room: `k x max(gain, 0)`. */
+    room: bigint;
+    carryIn: bigint;
+    /** Gross loss mints requested (PARCHMENT). */
+    provisional: bigint;
+    used: bigint;
+    /** `provisional - used`: PARCHMENT burned by the scale. */
+    excess: bigint;
+    scalePpm: bigint;
+    carryOut: bigint;
+}
+/** Loss mints settled on one day. */
+export interface ParchmentMintDay {
+    day: bigint;
+    /** Trader losses that created mint basis. */
+    mintedLoss: bigint;
+    mintedCount: bigint;
+    /** Trader losses the contract flagged (wash or self-liquidation: no mint basis). */
+    flaggedLoss: bigint;
+    flaggedCount: bigint;
+    /** PARCHMENT locked by loss mints. */
+    minted: bigint;
+    /** PARCHMENT burned by the cap scale. */
+    scaleBurned: bigint;
+}
+export interface ParchmentMintCapStats {
+    lastEpoch: ParchmentMintEpoch | null;
+    epochs: ParchmentMintEpoch[];
+    days: ParchmentMintDay[];
+    /** Flagged share of the window's losses. */
+    flaggedShareBps: bigint | null;
+    /** Curve H. */
+    tailProgress: bigint | null;
+}
+/** The payout queue on one day; `entries` / `owedNet` / `oldestAgeMs` are end of day (now, today). */
+export interface ParchmentQueueDay {
+    day: bigint;
+    enqueuedCount: bigint;
+    enqueuedNet: bigint;
+    payments: bigint;
+    paidNet: bigint;
+    completedCount: bigint;
+    entries: bigint;
+    owedNet: bigint;
+    oldestAgeMs: bigint | null;
+}
+export interface ParchmentQueueStats {
+    /** Claims with unpaid net, and that net. */
+    entries: bigint;
+    owedNet: bigint;
+    /** Queue nodes, including claims with only a fee left. */
+    nodes: bigint;
+    /** The exchange's `total_owed` (nets and queued fees). */
+    totalOwed: bigint;
+    oldestEnqueuedMs: bigint | null;
+    oldestAgeMs: bigint | null;
+    days: ParchmentQueueDay[];
+}
+/** One side of a market against its caps; null where the market has no such cap. */
+export interface ParchmentSideExposure {
+    oi: bigint;
+    lockedExposure: bigint;
+    oiCap: bigint | null;
+    exposureCap: bigint | null;
+    /** Largest side OI at which a minimum-notional open still meets the payout-factor floor. */
+    depthCapacity: bigint | null;
+    oiUtilBps: bigint | null;
+    exposureUtilBps: bigint | null;
+    depthUtilBps: bigint | null;
+    /** Thin depth, not the OI cap, bounds this side. */
+    depthBound: boolean | null;
+}
+export interface ParchmentExposureDay {
+    day: bigint;
+    longOi: bigint;
+    shortOi: bigint;
+    longLocked: bigint;
+    shortLocked: bigint;
+}
+export interface ParchmentMarketExposure {
+    marketId: string;
+    symbol: string | null;
+    effectiveDepth: bigint | null;
+    long: ParchmentSideExposure;
+    short: ParchmentSideExposure;
+    days: ParchmentExposureDay[];
+}
+/** Fee and redistribution flows (USDC; `vestPenalty` and the forfeits are PARCHMENT). */
+export interface ParchmentFeeFlows {
+    retained: bigint;
+    retainedStakers: bigint;
+    retainedTreasury: bigint;
+    winFee: bigint;
+    lossFee: bigint;
+    closeToll: bigint;
+    sweep: bigint;
+    sweepStakers: bigint;
+    sweepTreasury: bigint;
+    sweepGrowth: bigint;
+    stakerDeposit: bigint;
+    treasuryWithdrawn: bigint;
+    growthWithdrawn: bigint;
+    vestPenalty: bigint;
+    forfeitsSwept: bigint;
+    forfeitsClaimed: bigint;
+}
+export interface ParchmentFeeDay {
+    day: bigint;
+    flows: ParchmentFeeFlows;
+}
+export interface ParchmentFeeStats {
+    /** Every indexed flow since launch. */
+    totals: ParchmentFeeFlows;
+    days: ParchmentFeeDay[];
+    /** Pool coverage `lpCash / reserve`. */
+    coverageBps: bigint | null;
+    /** Stakers' share of the next retained fee at that coverage. */
+    stakerShareBps: bigint | null;
+    lpCash: bigint | null;
+    reserve: bigint | null;
+    treasuryBalance: bigint | null;
+    stakerBalance: bigint | null;
+    growthBalance: bigint | null;
+}
+/** Price age at two-step fills (ms): fill Clock less the storage price's timestamp (0 when ahead). */
+export interface ParchmentLagStats {
+    count: bigint;
+    p50Ms: bigint | null;
+    p95Ms: bigint | null;
+    maxMs: bigint | null;
+}
+/** A signed gap (ms) over two-step fills; `missing` fills had no observation. */
+export interface ParchmentGapStats {
+    count: bigint;
+    missing: bigint;
+    p50Ms: bigint | null;
+    p95Ms: bigint | null;
+    minMs: bigint | null;
+    maxMs: bigint | null;
+}
+/** Timing of two-step fills (opens and closes). */
+export interface ParchmentFillLags {
+    priceAge: ParchmentLagStats;
+    /** The storage price's timestamp less the signed Lazer update's the fill submitted. */
+    lazerToStorage: ParchmentGapStats;
+    /** The signed Lazer update's timestamp less the order's request time. */
+    requestToLazer: ParchmentGapStats;
+}
+export interface ParchmentFillLagDay {
+    day: bigint;
+    lags: ParchmentFillLags;
+}
+export interface ParchmentMarketFillLag {
+    marketId: string;
+    symbol: string | null;
+    /** Over the window. */
+    window: ParchmentFillLags;
+    days: ParchmentFillLagDay[];
+}
+/** Settlements held under `thresholdMs`: `profit` sums the wins' net, `loss` the price-move losses. */
+export interface ParchmentShortHolds {
+    positions: bigint;
+    /** Distinct wallets (account owners). */
+    wallets: bigint;
+    profit: bigint;
+    loss: bigint;
+}
+export interface ParchmentShortHoldDay {
+    /** The settlement day. */
+    day: bigint;
+    holds: ParchmentShortHolds;
+}
+export interface ParchmentMarketShortHolds {
+    marketId: string;
+    symbol: string | null;
+    window: ParchmentShortHolds;
+    days: ParchmentShortHoldDay[];
+}
+export interface ParchmentShortHoldStats {
+    /** A hold shorter than this (ms) is short. */
+    thresholdMs: bigint;
+    /** Every market over the window (wallets counted once). */
+    window: ParchmentShortHolds;
+    days: ParchmentShortHoldDay[];
+    markets: ParchmentMarketShortHolds[];
+}
+/**
+ * The `data` of `GET stats/monitoring` as it is served (integers still `"123n"` literals) to
+ * {@link ParchmentMonitoring}. Strict: a missing key, a wrong type, a non-canonical or
+ * out-of-range integer is `bad_body` naming its path. Other served keys are not carried.
+ */
+export declare function monitoringView(data: unknown): ParchmentMonitoring;
+/** The service serves at most this many days (`days` above it is clamped there). */
+export declare const MONITORING_MAX_DAYS = 366;
+/** `stats/monitoring` with an optional `days` (a positive integer; the service defaults to 90). */
+export declare function monitoringPath(days?: number | bigint): string;
+/**
+ * One market's trading on one UTC day (or since launch, `allTime`). USDC base units.
+ * `volume` = `openedNotional + closedNotional`: the notional opened plus the notional of the
+ * positions closed or liquidated (at their open notional), the same definition as
+ * `markets/stats` `volume24h`. `liquidatedNotional` is the part of `closedNotional` that was
+ * liquidated; `fills` counts two-step order fills.
+ */
+export interface ParchmentMarketFlow {
+    volume: bigint;
+    openedNotional: bigint;
+    closedNotional: bigint;
+    liquidatedNotional: bigint;
+    liquidations: bigint;
+    fills: bigint;
+}
+export interface ParchmentMarketFlowDay extends ParchmentMarketFlow {
+    day: bigint;
+}
+export interface ParchmentMarketActivity {
+    marketId: string;
+    symbol: string | null;
+    /** Every indexed flow since launch. */
+    allTime: ParchmentMarketFlow;
+    /** One row per day, `fromDay` to `toDay` (zeros on a quiet day). */
+    days: ParchmentMarketFlowDay[];
+}
+/** USDC moved into (`DepositEventV1`) and out of (`WithdrawEventV1`) trading accounts. */
+export interface ParchmentCollateralFlow {
+    deposits: bigint;
+    depositCount: bigint;
+    withdrawals: bigint;
+    withdrawalCount: bigint;
+}
+export interface ParchmentCollateralFlowDay extends ParchmentCollateralFlow {
+    day: bigint;
+}
+/**
+ * `GET stats/activity?days=N`: daily per-market volume, liquidations and fills, and daily
+ * collateral deposits vs withdrawals, each with its since-launch total (so a chart can draw the
+ * all-time running total under any window: the total less the days after each day).
+ */
+export interface ParchmentStatsActivity {
+    nowMs: bigint;
+    fromDay: bigint;
+    toDay: bigint;
+    /** False while the service is still folding history indexed before these stats existed. */
+    complete: boolean;
+    markets: ParchmentMarketActivity[];
+    collateral: {
+        allTime: ParchmentCollateralFlow;
+        days: ParchmentCollateralFlowDay[];
+    };
+}
+/**
+ * The `data` of `GET stats/activity` as served (integers `"123n"` literals) to
+ * {@link ParchmentStatsActivity}. Strict like {@link monitoringView}: a missing key, a wrong type or a
+ * bad integer is `bad_body` naming its path.
+ */
+export declare function statsActivityView(data: unknown): ParchmentStatsActivity;
+/** `stats/activity` with an optional `days` (a positive integer; the service defaults to 90, at most {@link MONITORING_MAX_DAYS}). */
+export declare function statsActivityPath(days?: number | bigint): string;
+/** The windows `GET stats/staking-history` serves. */
+export declare const STAKING_HISTORY_WINDOWS: readonly ["7", "30", "90", "all"];
+export type ParchmentStakingHistoryDays = (typeof STAKING_HISTORY_WINDOWS)[number];
+/**
+ * One staking pool snapshot (the service records one every 15 minutes). Cumulative since the
+ * service's baseline: `rewardsVestedUsdc` (USDC base units, 6 decimals) and `parchDripVested`
+ * (PARCHMENT base units, 9 decimals) only grow; `totalStaked` is the pool's stake then (PARCHMENT
+ * base units). `parchmentUsdWad` is the PARCHMENT/USD quote at that snapshot (1e18 = $1), null
+ * when the snapshot had none.
+ */
+export interface ParchmentStakingHistoryPoint {
+    tsMs: bigint;
+    totalStaked: bigint;
+    rewardsVestedUsdc: bigint;
+    parchDripVested: bigint;
+    parchmentUsdWad: bigint | null;
+}
+/**
+ * `GET stats/staking-history?days=7|30|90|all`: the pool's realized staking rate over the window
+ * and the snapshots behind it. `aprWad` (1e18 = 100%) is the USD value of the rewards vested in the
+ * observed span (USDC plus the PARCHMENT drip at the current quote) over the time-weighted average
+ * stake at that quote, annualized; null when there is no quote or no observed span. `apyWad` is that
+ * APR compounded once per observed span, null when the APR is or when the APY is past the
+ * representable range (never the APR in its place). `partial` is a window the snapshots do not
+ * cover (or whose last snapshot is over an hour old); `annualized` is a partial window that still
+ * produced an APR. Points are oldest first, at most 500 (the service thins longer windows).
+ */
+export interface ParchmentStakingHistory {
+    days: ParchmentStakingHistoryDays;
+    partial: boolean;
+    annualized: boolean;
+    fromMs: bigint;
+    toMs: bigint;
+    observedMs: bigint;
+    /** Null for `all`. */
+    windowMs: bigint | null;
+    aprWad: bigint | null;
+    apyWad: bigint | null;
+    rewardUsdc: bigint;
+    rewardParchment: bigint;
+    avgStake: bigint;
+    parchmentUsdWad: bigint | null;
+    parchmentUsdTsMs: bigint | null;
+    parchmentUsdSource: string | null;
+    points: ParchmentStakingHistoryPoint[];
+    /**
+     * The exact per-UTC-day aggregate (parchment-service `staking_daily`), oldest first: every day
+     * overlapping the window (for `all`, every day, merged into runs of consecutive days past 500).
+     * Absent (`undefined`) from a service that predates it; `[]` while the service has not built it.
+     */
+    daily?: ParchmentStakingDay[];
+}
+/**
+ * One UTC day of the exact daily staking aggregate. The service replays every indexed stake,
+ * unstake, reward deposit and forfeit sweep through the contract's accrual, so `rewardUsdc` (USDC
+ * base units) and `rewardParchment` (PARCHMENT base units) are exactly what vested to stakers in
+ * `[fromMs, toMs]`, and `avgStake` is the stake integrated over every change in that span, divided
+ * by `observedMs`. `aprWad` (1e18 = 100%) is the USD value of those rewards (PARCHMENT at
+ * `parchmentUsdWad`: the day's last snapshot quote, else the current one) over the time-weighted
+ * stake at the same quote, annualized over `observedMs`; null without a quote or without stake.
+ * `dayMs` is the day's UTC midnight (the first day of a merged run); `final` is a closed day (the
+ * open day runs to the indexer's clock). A partial day (`observedMs` under a day) is the pool's
+ * first day, the open day, or a span the service could not verify.
+ */
+export interface ParchmentStakingDay {
+    dayMs: bigint;
+    fromMs: bigint;
+    toMs: bigint;
+    observedMs: bigint;
+    final: boolean;
+    rewardUsdc: bigint;
+    rewardParchment: bigint;
+    avgStake: bigint;
+    parchmentUsdWad: bigint | null;
+    aprWad: bigint | null;
+}
+/**
+ * The `data` of `GET stats/staking-history` as served (integers `"123n"` literals) to
+ * {@link ParchmentStakingHistory}. Strict like {@link monitoringView}: a missing key, a wrong type or
+ * a bad integer is `bad_body` naming its path.
+ */
+export declare function stakingHistoryView(data: unknown): ParchmentStakingHistory;
+/** `stats/staking-history?days=` for one of {@link STAKING_HISTORY_WINDOWS}; anything else is `bad_request`. */
+export declare function stakingHistoryPath(days: ParchmentStakingHistoryDays): string;

package/dist/packages/parchment/monitoring.js

@@ -0,0 +1,259 @@
+import { normalizeAddress } from "../../general/utils/address.js";
+import { ParchmentApiError } from "../../general/utils/errors.js";
+import { parseJsBigInt } from "../../general/utils/jsBigInt.js";
+const bad = (message) => new ParchmentApiError(0, "bad_body", message);
+function obj(value, path) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw bad(`${path}: expected an object`);
+    return value;
+}
+function field(o, key, path) {
+    if (!(key in o))
+        throw bad(`${path}.${key} is missing`);
+    return o[key];
+}
+function int(o, key, path, kind = "u64") {
+    return parseJsBigInt(field(o, key, path), `${path}.${key}`, kind);
+}
+function intOrNull(o, key, path, kind = "u64") {
+    const value = field(o, key, path);
+    return value === null ? null : parseJsBigInt(value, `${path}.${key}`, kind);
+}
+function bool(o, key, path) {
+    const value = field(o, key, path);
+    if (typeof value !== "boolean")
+        throw bad(`${path}.${key} must be a boolean`);
+    return value;
+}
+function boolOrNull(o, key, path) {
+    return field(o, key, path) === null ? null : bool(o, key, path);
+}
+function textOrNull(o, key, path) {
+    const value = field(o, key, path);
+    if (value !== null && typeof value !== "string")
+        throw bad(`${path}.${key} must be a string`);
+    return value;
+}
+function marketId(o, path) {
+    const value = field(o, "marketId", path);
+    try {
+        if (typeof value === "string")
+            return normalizeAddress(value);
+    }
+    catch {
+    }
+    throw bad(`${path}.marketId is not an object id`);
+}
+function list(o, key, path, item) {
+    const value = field(o, key, path);
+    if (!Array.isArray(value))
+        throw bad(`${path}.${key}: expected a list`);
+    return value.map((v, i) => {
+        const at = `${path}.${key}[${i}]`;
+        return item(obj(v, at), at);
+    });
+}
+function child(o, key, path, read) {
+    return read(obj(field(o, key, path), `${path}.${key}`), `${path}.${key}`);
+}
+function ints(o, path, keys, kind) {
+    return Object.fromEntries(keys.map((k) => [k, int(o, k, path, kind)]));
+}
+function nullableInts(o, path, keys, kind) {
+    return Object.fromEntries(keys.map((k) => [k, intOrNull(o, k, path, kind)]));
+}
+const mintEpoch = (o, p) => ({
+    ...ints(o, p, ["epoch", "room", "provisional", "used", "excess", "scalePpm"], "u64"),
+    ...ints(o, p, ["gainUp", "gainDown", "carryIn", "carryOut"], "u128"),
+});
+const mintDay = (o, p) => ({
+    ...ints(o, p, ["day", "mintedCount", "flaggedCount"], "u64"),
+    ...ints(o, p, ["mintedLoss", "flaggedLoss", "minted", "scaleBurned"], "u128"),
+});
+const mintCap = (o, p) => ({
+    lastEpoch: field(o, "lastEpoch", p) === null ? null : child(o, "lastEpoch", p, mintEpoch),
+    epochs: list(o, "epochs", p, mintEpoch),
+    days: list(o, "days", p, mintDay),
+    ...nullableInts(o, p, ["flaggedShareBps", "tailProgress"], "u64"),
+});
+const queueDay = (o, p) => ({
+    ...ints(o, p, ["day", "enqueuedCount", "payments", "completedCount", "entries"], "u64"),
+    ...ints(o, p, ["enqueuedNet", "paidNet", "owedNet"], "u128"),
+    oldestAgeMs: intOrNull(o, "oldestAgeMs", p),
+});
+const queue = (o, p) => ({
+    ...ints(o, p, ["entries", "nodes"], "u64"),
+    ...ints(o, p, ["owedNet", "totalOwed"], "u128"),
+    ...nullableInts(o, p, ["oldestEnqueuedMs", "oldestAgeMs"], "u64"),
+    days: list(o, "days", p, queueDay),
+});
+const side = (o, p) => ({
+    ...ints(o, p, ["oi", "lockedExposure"], "u64"),
+    ...nullableInts(o, p, ["oiCap", "exposureCap", "depthCapacity", "oiUtilBps", "exposureUtilBps", "depthUtilBps"], "u64"),
+    depthBound: boolOrNull(o, "depthBound", p),
+});
+const exposureDay = (o, p) => ints(o, p, ["day", "longOi", "shortOi", "longLocked", "shortLocked"], "u64");
+const marketExposure = (o, p) => ({
+    marketId: marketId(o, p),
+    symbol: textOrNull(o, "symbol", p),
+    effectiveDepth: intOrNull(o, "effectiveDepth", p),
+    long: child(o, "long", p, side),
+    short: child(o, "short", p, side),
+    days: list(o, "days", p, exposureDay),
+});
+const FEE_FLOW_KEYS = [
+    "retained",
+    "retainedStakers",
+    "retainedTreasury",
+    "winFee",
+    "lossFee",
+    "closeToll",
+    "sweep",
+    "sweepStakers",
+    "sweepTreasury",
+    "sweepGrowth",
+    "stakerDeposit",
+    "treasuryWithdrawn",
+    "growthWithdrawn",
+    "vestPenalty",
+    "forfeitsSwept",
+    "forfeitsClaimed",
+];
+const feeFlows = (o, p) => ints(o, p, FEE_FLOW_KEYS, "u128");
+const fees = (o, p) => ({
+    totals: child(o, "totals", p, feeFlows),
+    days: list(o, "days", p, (d, dp) => ({ day: int(d, "day", dp), flows: child(d, "flows", dp, feeFlows) })),
+    ...nullableInts(o, p, ["coverageBps", "stakerShareBps", "lpCash", "treasuryBalance", "stakerBalance", "growthBalance"], "u64"),
+    reserve: intOrNull(o, "reserve", p, "u128"),
+});
+const lag = (o, p) => ({
+    count: int(o, "count", p),
+    ...nullableInts(o, p, ["p50Ms", "p95Ms", "maxMs"], "u64"),
+});
+const gap = (o, p) => ({
+    ...ints(o, p, ["count", "missing"], "u64"),
+    ...nullableInts(o, p, ["p50Ms", "p95Ms", "minMs", "maxMs"], "i64"),
+});
+const fillLags = (o, p) => ({
+    priceAge: child(o, "priceAge", p, lag),
+    lazerToStorage: child(o, "lazerToStorage", p, gap),
+    requestToLazer: child(o, "requestToLazer", p, gap),
+});
+const marketFillLag = (o, p) => ({
+    marketId: marketId(o, p),
+    symbol: textOrNull(o, "symbol", p),
+    window: child(o, "window", p, fillLags),
+    days: list(o, "days", p, (d, dp) => ({ day: int(d, "day", dp), lags: child(d, "lags", dp, fillLags) })),
+});
+const holds = (o, p) => ({
+    ...ints(o, p, ["positions", "wallets"], "u64"),
+    ...ints(o, p, ["profit", "loss"], "u128"),
+});
+const holdDay = (o, p) => ({ day: int(o, "day", p), holds: child(o, "holds", p, holds) });
+const shortHolds = (o, p) => ({
+    thresholdMs: int(o, "thresholdMs", p),
+    window: child(o, "window", p, holds),
+    days: list(o, "days", p, holdDay),
+    markets: list(o, "markets", p, (m, mp) => ({
+        marketId: marketId(m, mp),
+        symbol: textOrNull(m, "symbol", mp),
+        window: child(m, "window", mp, holds),
+        days: list(m, "days", mp, holdDay),
+    })),
+});
+export function monitoringView(data) {
+    const p = "data";
+    const o = obj(data, p);
+    return {
+        ...ints(o, p, ["nowMs", "fromDay", "toDay"], "u64"),
+        complete: bool(o, "complete", p),
+        mintCap: child(o, "mintCap", p, mintCap),
+        queue: child(o, "queue", p, queue),
+        exposure: list(o, "exposure", p, marketExposure),
+        fees: child(o, "fees", p, fees),
+        fillLag: list(o, "fillLag", p, marketFillLag),
+        shortHolds: child(o, "shortHolds", p, shortHolds),
+    };
+}
+export const MONITORING_MAX_DAYS = 366;
+export function monitoringPath(days) {
+    if (days === undefined)
+        return "stats/monitoring";
+    const ok = typeof days === "bigint" ? days > 0n : Number.isSafeInteger(days) && days > 0;
+    if (!ok)
+        throw new ParchmentApiError(0, "bad_request", "days must be a positive integer");
+    return `stats/monitoring?days=${days}`;
+}
+const marketFlow = (o, p) => ({
+    ...ints(o, p, ["volume", "openedNotional", "closedNotional", "liquidatedNotional"], "u128"),
+    ...ints(o, p, ["liquidations", "fills"], "u64"),
+});
+const collateralFlow = (o, p) => ({
+    ...ints(o, p, ["deposits", "withdrawals"], "u128"),
+    ...ints(o, p, ["depositCount", "withdrawalCount"], "u64"),
+});
+export function statsActivityView(data) {
+    const p = "data";
+    const o = obj(data, p);
+    return {
+        ...ints(o, p, ["nowMs", "fromDay", "toDay"], "u64"),
+        complete: bool(o, "complete", p),
+        markets: list(o, "markets", p, (m, mp) => ({
+            marketId: marketId(m, mp),
+            symbol: textOrNull(m, "symbol", mp),
+            allTime: child(m, "allTime", mp, marketFlow),
+            days: list(m, "days", mp, (d, dp) => ({ day: int(d, "day", dp), ...marketFlow(d, dp) })),
+        })),
+        collateral: child(o, "collateral", p, (c, cp) => ({
+            allTime: child(c, "allTime", cp, collateralFlow),
+            days: list(c, "days", cp, (d, dp) => ({ day: int(d, "day", dp), ...collateralFlow(d, dp) })),
+        })),
+    };
+}
+export function statsActivityPath(days) {
+    return monitoringPath(days).replace(/^stats\/monitoring/, "stats/activity");
+}
+export const STAKING_HISTORY_WINDOWS = ["7", "30", "90", "all"];
+function stakingDays(o, path) {
+    const value = field(o, "days", path);
+    const hit = STAKING_HISTORY_WINDOWS.find((d) => d === value);
+    if (hit === undefined)
+        throw bad(`${path}.days must be one of ${STAKING_HISTORY_WINDOWS.join(", ")}`);
+    return hit;
+}
+const stakingPoint = (o, p) => ({
+    tsMs: int(o, "tsMs", p, "i64"),
+    ...ints(o, p, ["totalStaked", "rewardsVestedUsdc", "parchDripVested"], "u128"),
+    parchmentUsdWad: intOrNull(o, "parchmentUsdWad", p, "u128"),
+});
+const stakingDay = (o, p) => ({
+    ...ints(o, p, ["dayMs", "fromMs", "toMs"], "i64"),
+    observedMs: int(o, "observedMs", p, "u128"),
+    final: bool(o, "final", p),
+    ...ints(o, p, ["rewardUsdc", "rewardParchment", "avgStake"], "u128"),
+    ...nullableInts(o, p, ["parchmentUsdWad", "aprWad"], "u128"),
+});
+export function stakingHistoryView(data) {
+    const p = "data";
+    const o = obj(data, p);
+    return {
+        days: stakingDays(o, p),
+        partial: bool(o, "partial", p),
+        annualized: bool(o, "annualized", p),
+        ...ints(o, p, ["fromMs", "toMs"], "i64"),
+        observedMs: int(o, "observedMs", p, "u128"),
+        windowMs: intOrNull(o, "windowMs", p, "i64"),
+        ...nullableInts(o, p, ["aprWad", "apyWad"], "u128"),
+        ...ints(o, p, ["rewardUsdc", "rewardParchment", "avgStake"], "u128"),
+        parchmentUsdWad: intOrNull(o, "parchmentUsdWad", p, "u128"),
+        parchmentUsdTsMs: intOrNull(o, "parchmentUsdTsMs", p, "i64"),
+        parchmentUsdSource: textOrNull(o, "parchmentUsdSource", p),
+        points: list(o, "points", p, stakingPoint),
+        ...(o.daily === undefined ? {} : { daily: list(o, "daily", p, stakingDay) }),
+    };
+}
+export function stakingHistoryPath(days) {
+    if (!STAKING_HISTORY_WINDOWS.includes(days))
+        throw new ParchmentApiError(0, "bad_request", "days must be 7, 30, 90, or all");
+    return `stats/staking-history?days=${days}`;
+}

package/dist/packages/parchment/notes.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Note parchment-service attaches to request-open / request-close (and `-as-delegate`) tx bytes,
+ * byte-for-byte the service `tx::ORDER_NOTE` and the legacy API `ORDER_TX_NOTE`. Also served as
+ * `orderTxNote` by `GET /api/parchment/limits`. These requests carry no price.
+ */
+export declare const ORDER_TX_NOTE = "Two-step order: the request escrows margin plus the execution fee; a keeper fills it at the first signed mid after the request (no spread) or refunds it. Poll GET /v1/orders/{orderId}.";

package/dist/packages/parchment/notes.js

@@ -0,0 +1 @@
+export const ORDER_TX_NOTE = "Two-step order: the request escrows margin plus the execution fee; a keeper fills it at the first signed mid after the request (no spread) or refunds it. Poll GET /v1/orders/{orderId}.";

package/dist/packages/parchment/onboarding.d.ts

@@ -0,0 +1,50 @@
+import type { Transaction, TransactionObjectArgument } from "@mysten/sui/transactions";
+type ObjectInput = string | TransactionObjectArgument;
+export interface OneSignatureOnboardingCalls {
+    /** Core `parchment` package id (call target; the `exchange` module). */
+    packageId: string;
+    /** Collateral coin type `C` (USDC; `new_account` aborts `exchange::ENotUsdc` otherwise). */
+    coinType: string;
+    exchange: ObjectInput;
+    config: ObjectInput;
+    /** `Coin<C>` to deposit into the new account (a non-zero coin, `exchange::EZero` otherwise). Omit to skip the deposit. */
+    deposit?: ObjectInput;
+    /** Session key and optional close delegate to authorize on the new account. Omit to skip the grant. */
+    delegate?: {
+        address: string;
+        expiryMs: bigint | number;
+        closeDelegate?: string;
+    };
+    /** Transaction sender; `share_account` sends it the `AccountCap`. */
+    sender: string;
+}
+/**
+ * One-signature onboarding (Option A) in one PTB: `exchange::new_account<C>(exchange, config)` returns
+ * `(Account, AccountCap, AccountReceipt)`; then `exchange::deposit<C>(exchange, config, account, cap, coin)`
+ * when `deposit` is given, `exchange::grant_delegate<C>(exchange, account, config, cap, delegate, expiry_ms, clock)`
+ * when `delegate` is given (or `grant_session_and_close_delegate` when it has a `closeDelegate`), and `exchange::share_account<C>(account, cap, receipt)` (the receipt is a hot potato,
+ * so the account is always shared in this transaction; `exchange::EReceiptMismatch` 12 for another account's
+ * receipt). `share_account` also sends the cap to the transaction sender: `AccountCap` is key-only, so a PTB
+ * `TransferObjects` cannot move it.
+ */
+export declare function addOneSignatureOnboardingCalls(tx: Transaction, input: OneSignatureOnboardingCalls): void;
+export interface AccountIdInput {
+    /** The `Exchange<C>` the account is derived from. */
+    exchangeId: string;
+    /** The ORIGINAL `parchment` package id (the one that defines `account::AccountKey`), not a later version. */
+    originalPackageId: string;
+    owner: string;
+    /**
+     * The opener's derivation nonce: 0 for a wallet's first account; after it transferred accounts away
+     * (`account_transfer::transfer_account`), the number of accounts it opened before (the service's
+     * `nextAccountNonce`). Default 0.
+     */
+    nonce?: bigint | number;
+}
+/**
+ * The id of `owner`'s `Account` on `exchangeId`, known before it exists: `account::create` claims it with
+ * `derived_object::claim(exchange, AccountKey { owner, nonce })`, for `open_account` and `new_account` alike. Lets a
+ * client key per-account state (e.g. a session key granted in the onboarding PTB) before the index serves the account.
+ */
+export declare function deriveAccountId(input: AccountIdInput): string;
+export {};