@parchment-trade/sdk 0.0.0-stage → 1.0.1

package/dist/packages/parchment/stakingEvents.js

@@ -0,0 +1,71 @@
+import { bcs } from "@mysten/sui/bcs";
+export const STAKING_DURATION_CAPS_UPDATED_EVENT_BCS = bcs.struct("StakingDurationCapsUpdatedEventV1", {
+    pool_id: bcs.Address,
+    max_reward_stream_ms: bcs.u64(),
+    max_min_stake_lock_ms: bcs.u64(),
+});
+export function decodeStakingDurationCapsUpdatedEvent(bytes) {
+    try {
+        return STAKING_DURATION_CAPS_UPDATED_EVENT_BCS.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+export const LOCKED_WEIGHT_SYNCED_EVENT_BCS = bcs.struct("LockedWeightSyncedEventV1", {
+    pool_id: bcs.Address,
+    owner: bcs.Address,
+    balance: bcs.u64(),
+    weight: bcs.u64(),
+    total_weight: bcs.u64(),
+    moved: bcs.u64(),
+    owed: bcs.u64(),
+});
+export const LOCKED_YIELD_CLAIMED_EVENT_BCS = bcs.struct("LockedYieldClaimedEventV1", {
+    pool_id: bcs.Address,
+    owner: bcs.Address,
+    amount: bcs.u64(),
+    owed: bcs.u64(),
+});
+export const LOCKED_YIELD_FORFEITED_EVENT_BCS = bcs.struct("LockedYieldForfeitedEventV1", {
+    pool_id: bcs.Address,
+    owner: bcs.Address,
+    amount: bcs.u64(),
+    stream_end_ms: bcs.u64(),
+});
+export const LOCKED_WEIGHT_BPS_UPDATED_EVENT_BCS = bcs.struct("LockedWeightBpsUpdatedEventV1", {
+    pool_id: bcs.Address,
+    bps: bcs.u64(),
+});
+export function decodeLockedWeightSyncedEvent(bytes) {
+    try {
+        return LOCKED_WEIGHT_SYNCED_EVENT_BCS.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+export function decodeLockedYieldClaimedEvent(bytes) {
+    try {
+        return LOCKED_YIELD_CLAIMED_EVENT_BCS.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+export function decodeLockedYieldForfeitedEvent(bytes) {
+    try {
+        return LOCKED_YIELD_FORFEITED_EVENT_BCS.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+export function decodeLockedWeightBpsUpdatedEvent(bytes) {
+    try {
+        return LOCKED_WEIGHT_BPS_UPDATED_EVENT_BCS.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,46 @@
+import type { Transaction, TransactionObjectArgument, TransactionResult } from "@mysten/sui/transactions";
+type ObjectInput = string | TransactionObjectArgument;
+type Integer = bigint | number | string;
+type Level = Integer | null;
+/** Direct Move call inputs. `packageId` is the `parchment_triggers` package id. */
+export interface TriggerOpenCall {
+    packageId: string;
+    coinType: string;
+    exchange: ObjectInput;
+    market: ObjectInput;
+    account: ObjectInput;
+    config: ObjectInput;
+    margin: Integer;
+    leverage: Integer;
+    isLong: boolean;
+    minFactorBps: Integer;
+    acceptablePriceWad: Integer;
+    builderId: number | null;
+    tp: Level;
+    sl: Level;
+    clock: ObjectInput;
+}
+export interface TriggerOpenWithCapCall extends TriggerOpenCall {
+    cap: ObjectInput;
+    topUp: ObjectInput;
+}
+export interface TriggerEditCall {
+    packageId: string;
+    coinType: string;
+    account: ObjectInput;
+    position: Integer;
+    tp: Level;
+    sl: Level;
+    revision: Integer;
+}
+export interface TriggerEditWithCapCall extends TriggerEditCall {
+    cap: ObjectInput;
+}
+export interface TriggerEditAsDelegateCall extends TriggerEditCall {
+    clock: ObjectInput;
+}
+export declare function addRequestOpenWithTriggersCall(tx: Transaction, input: TriggerOpenWithCapCall): TransactionResult;
+export declare function addRequestOpenWithTriggersAsDelegateCall(tx: Transaction, input: TriggerOpenCall): TransactionResult;
+export declare function addSetTriggerLevelsCall(tx: Transaction, input: TriggerEditWithCapCall): void;
+export declare function addSetTriggerLevelsAsDelegateCall(tx: Transaction, input: TriggerEditAsDelegateCall): void;
+export {};

package/dist/packages/parchment/triggerCalls.js

@@ -0,0 +1,36 @@
+import { bcs } from "@mysten/sui/bcs";
+const object = (tx, value) => typeof value === "string" ? tx.object(value) : value;
+const level = (tx, value) => tx.pure(bcs.option(bcs.u128()).serialize(value));
+export function addRequestOpenWithTriggersCall(tx, input) {
+    return tx.moveCall({
+        target: `${input.packageId}::triggers::request_open_with_triggers`, typeArguments: [input.coinType],
+        arguments: [object(tx, input.exchange), object(tx, input.market), object(tx, input.account), object(tx, input.cap),
+            object(tx, input.config), tx.pure.u64(input.margin), tx.pure.u64(input.leverage), tx.pure.bool(input.isLong),
+            tx.pure.u64(input.minFactorBps), tx.pure.u128(input.acceptablePriceWad),
+            tx.pure(bcs.option(bcs.u32()).serialize(input.builderId)), object(tx, input.topUp), level(tx, input.tp),
+            level(tx, input.sl), object(tx, input.clock)],
+    });
+}
+export function addRequestOpenWithTriggersAsDelegateCall(tx, input) {
+    return tx.moveCall({
+        target: `${input.packageId}::triggers::request_open_with_triggers_as_delegate`, typeArguments: [input.coinType],
+        arguments: [object(tx, input.exchange), object(tx, input.market), object(tx, input.account), object(tx, input.config),
+            tx.pure.u64(input.margin), tx.pure.u64(input.leverage), tx.pure.bool(input.isLong), tx.pure.u64(input.minFactorBps),
+            tx.pure.u128(input.acceptablePriceWad), tx.pure(bcs.option(bcs.u32()).serialize(input.builderId)),
+            level(tx, input.tp), level(tx, input.sl), object(tx, input.clock)],
+    });
+}
+export function addSetTriggerLevelsCall(tx, input) {
+    tx.moveCall({
+        target: `${input.packageId}::triggers::set_trigger_levels`, typeArguments: [input.coinType],
+        arguments: [object(tx, input.account), object(tx, input.cap), tx.pure.u64(input.position),
+            level(tx, input.tp), level(tx, input.sl), tx.pure.u64(input.revision)],
+    });
+}
+export function addSetTriggerLevelsAsDelegateCall(tx, input) {
+    tx.moveCall({
+        target: `${input.packageId}::triggers::set_trigger_levels_as_delegate`, typeArguments: [input.coinType],
+        arguments: [object(tx, input.account), tx.pure.u64(input.position), level(tx, input.tp), level(tx, input.sl),
+            tx.pure.u64(input.revision), object(tx, input.clock)],
+    });
+}

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

@@ -0,0 +1,22 @@
+/** BCS for `triggers::Event<TriggerLevelsCommitted>`. Prices are WAD values. */
+export declare const TRIGGER_LEVELS_COMMITTED_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    account: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    market: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    side: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+    request_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    tp: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+    sl: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+}, string>;
+/** BCS for `triggers::Event<TriggerLevelsSetEvent>`. */
+export declare const TRIGGER_LEVELS_SET_EVENT_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    account: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    position: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    tp: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+    sl: import("@mysten/sui/bcs").BcsType<string | null, string | number | bigint | null | undefined, "Option<u128>">;
+    revision: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    sender: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, string>;
+export type TriggerLevelsCommitted = ReturnType<typeof TRIGGER_LEVELS_COMMITTED_BCS.parse>;
+export type TriggerLevelsSetEvent = ReturnType<typeof TRIGGER_LEVELS_SET_EVENT_BCS.parse>;
+export declare function decodeTriggerLevelsCommitted(bytes: Uint8Array): TriggerLevelsCommitted | null;
+export declare function decodeTriggerLevelsSetEvent(bytes: Uint8Array): TriggerLevelsSetEvent | null;

package/dist/packages/parchment/triggerEvents.js

@@ -0,0 +1,33 @@
+import { bcs } from "@mysten/sui/bcs";
+export const TRIGGER_LEVELS_COMMITTED_BCS = bcs.struct("TriggerLevelsCommitted", {
+    account: bcs.Address,
+    market: bcs.Address,
+    side: bcs.bool(),
+    request_id: bcs.Address,
+    tp: bcs.option(bcs.u128()),
+    sl: bcs.option(bcs.u128()),
+});
+export const TRIGGER_LEVELS_SET_EVENT_BCS = bcs.struct("TriggerLevelsSetEvent", {
+    account: bcs.Address,
+    position: bcs.u64(),
+    tp: bcs.option(bcs.u128()),
+    sl: bcs.option(bcs.u128()),
+    revision: bcs.u64(),
+    sender: bcs.Address,
+});
+export function decodeTriggerLevelsCommitted(bytes) {
+    try {
+        return TRIGGER_LEVELS_COMMITTED_BCS.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+}
+export function decodeTriggerLevelsSetEvent(bytes) {
+    try {
+        return TRIGGER_LEVELS_SET_EVENT_BCS.parse(bytes);
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -0,0 +1,113 @@
+/** Signed text version line. Lines are joined by `\n` with no trailing newline. */
+export declare const TRIGGER_PROOF_VERSION = "Parchment trigger v1";
+/** Proof lifetime the client requests: five minutes, inside the service's ten-minute window. */
+export declare const TRIGGER_PROOF_TTL_MS: number;
+export type TriggerKind = "tp" | "sl";
+/**
+ * The position a proof is for: an open position, or the one the open request in transaction
+ * `openTxDigest` creates when it fills. Sign the open first, then this proof over the signed
+ * transaction's digest, save it ({@link Parchment.setTriggers}), and only then send the open: the
+ * legs are stored before the open can execute. `marketId` and `isLong` are the open's; the legs
+ * attach only to an open of that market and side. `openTxBytesBase64` is that signed transaction (BCS
+ * `TransactionData`, base64): the service reads its epoch bound from it. It is sent next to the proof, not
+ * signed, so the message needs none; {@link triggerRequestBody} requires it whenever a leg is set.
+ */
+export type TriggerTarget = {
+    positionId: bigint;
+} | {
+    openTxDigest: string;
+    marketId: string;
+    isLong: boolean;
+    openTxBytesBase64?: string;
+} | TriggerIntentTarget;
+/**
+ * A prepared open intent: the legs for an open that is still being built, before its digest exists. Sign the
+ * proof over a fresh {@link newTriggerIntentId}, save it with `POST /triggers/prepare`
+ * ({@link triggerPrepareBody}) while the open is built, then bind the signed open to it with
+ * `POST /triggers/bind` ({@link triggerBindBody}). The open's sender must be the owner or the key that signed
+ * this proof; its own signature over the open authorizes the bind. One id binds one transaction.
+ */
+export interface TriggerIntentTarget {
+    /** 32 lowercase hex digits (16 random bytes), used once. */
+    intentId: string;
+    marketId: string;
+    isLong: boolean;
+}
+export interface TriggerProofInput {
+    owner: string;
+    accountId: string;
+    target: TriggerTarget;
+    /** Take-profit price, 1e18 base units. Null clears it. */
+    takeProfitWad: bigint | null;
+    /** Stop-loss price, 1e18 base units. Null clears it. */
+    stopLossWad: bigint | null;
+    /** Absolute expiry, unix milliseconds. */
+    expiresAtMs: bigint;
+}
+/** Wallet (or any key) that can sign a personal message. The owner signs the proof. */
+export interface TriggerSigner {
+    signPersonalMessage: (message: Uint8Array) => Promise<{
+        signature: string;
+    }>;
+}
+export interface TriggerProof extends TriggerProofInput {
+    message: string;
+    signature: string;
+}
+/**
+ * The personal message the owner signs to set both legs of one position. Seven lines, `\n`-joined,
+ * no trailing newline: `Parchment trigger v1`, owner, account id, `position <id>` or
+ * `open <open tx digest> <market id> long|short` or `intent <intent id> <market id> long|short`, `tp <price>` or
+ * `tp none`, `sl <price>` or
+ * `sl none`, expiry ms. Addresses are `0x` plus 64 lowercase hex digits; numbers are plain
+ * decimals; the digest is base58.
+ */
+export declare function triggerProofMessage(input: TriggerProofInput): string;
+/**
+ * The owner signs {@link triggerProofMessage}; `expiresAtMs` is `nowMs` plus {@link TRIGGER_PROOF_TTL_MS}.
+ * The whole request is checked first, without the signature ({@link triggerRequestBody}'s checks, including
+ * an open target's `openTxBytesBase64` against its digest; for an intent target, {@link triggerPrepareBody}'s),
+ * so a request the service would refuse never prompts the wallet for a signature.
+ */
+export declare function signTriggerProof(signer: TriggerSigner, input: Omit<TriggerProofInput, "expiresAtMs">, nowMs?: number): Promise<TriggerProof>;
+/** JSON body for `POST /triggers`: the signed fields with integers as js_bigint literals. */
+export declare function triggerRequestBody(proof: TriggerProof): Record<string, string | boolean | null>;
+/** A fresh random intent id (16 bytes from the platform CSPRNG, as 32 lowercase hex digits). */
+export declare function newTriggerIntentId(): string;
+/**
+ * JSON body for `POST /triggers/prepare`: a signed proof whose target is a {@link TriggerIntentTarget}. Prices and
+ * the expiry are plain decimal strings, exactly as signed. A prepared intent needs at least one leg.
+ */
+export declare function triggerPrepareBody(proof: TriggerProof): Record<string, string | boolean | null>;
+/** What `POST /triggers/bind` names: the prepared intent and the signed open that carries it. */
+export interface TriggerBindInput {
+    owner: string;
+    accountId: string;
+    intentId: string;
+    /** The signed open `Transaction` (BCS, base64), exactly as it is sent. */
+    openTxBytesBase64: string;
+    /** Its signatures (base64); the sender's must be one (a sponsor's may ride along). */
+    signatures: string[];
+}
+/** JSON body for `POST /triggers/bind`. */
+export declare function triggerBindBody(input: TriggerBindInput): {
+    owner: string;
+    accountId: string;
+    intentId: string;
+    openTxBytesBase64: string;
+    signatures: string[];
+};
+/**
+ * Fraction of the entry-to-liquidation distance. A stop in that last slice is near liquidation:
+ * `|stop - liq| <= NEAR_LIQ_DISTANCE_FRACTION * |entry - liq|`.
+ */
+export declare const NEAR_LIQ_DISTANCE_FRACTION = 0.2;
+export type StopPlacement = "ok" | "near" | "past";
+/**
+ * `past`: a long stop at or under liquidation, or a short stop at or over it.
+ * `near`: still on the safe side, inside the last {@link NEAR_LIQ_DISTANCE_FRACTION} of the
+ * entry-to-liquidation distance. A long's liquidation can be exactly 0 (1x): that is a real
+ * level. `ok` when the stop, the liquidation or the entry is unknown (null, NaN, negative) or the
+ * entry is not on the safe side of liquidation. All prices share one unit.
+ */
+export declare function stopAgainstLiquidation(side: "long" | "short", stop: number, liquidation: number | null | undefined, entry: number | null | undefined): StopPlacement;

package/dist/packages/parchment/triggers.js

@@ -0,0 +1,183 @@
+import { TransactionDataBuilder } from "@mysten/sui/transactions";
+import { fromBase58, fromBase64, toBase58 } from "@mysten/sui/utils";
+import { U64_MAX, normalizeAddress } from "../../general/utils/address.js";
+import { ParchmentApiError } from "../../general/utils/errors.js";
+import { toJsBigInt } from "../../general/utils/jsBigInt.js";
+export const TRIGGER_PROOF_VERSION = "Parchment trigger v1";
+export const TRIGGER_PROOF_TTL_MS = 5 * 60 * 1000;
+const U128_MAX = (1n << 128n) - 1n;
+export function triggerProofMessage(input) {
+    return [
+        TRIGGER_PROOF_VERSION,
+        normalizeAddress(input.owner),
+        normalizeAddress(input.accountId),
+        targetLine(input.target),
+        legLine("tp", input.takeProfitWad),
+        legLine("sl", input.stopLossWad),
+        bounded(input.expiresAtMs, "expiresAtMs", U64_MAX).toString(),
+    ].join("\n");
+}
+export async function signTriggerProof(signer, input, nowMs = Date.now()) {
+    const proof = { ...input, expiresAtMs: BigInt(Math.floor(nowMs) + TRIGGER_PROOF_TTL_MS) };
+    const message = triggerProofMessage(proof);
+    if ("intentId" in proof.target)
+        unsignedPrepareBody(proof);
+    else
+        unsignedRequestBody(proof);
+    const { signature } = await signer.signPersonalMessage(new TextEncoder().encode(message));
+    if (typeof signature !== "string" || signature.length === 0) {
+        throw new ParchmentApiError(0, "bad_signature", "trigger signature is empty");
+    }
+    return { ...proof, message, signature };
+}
+export function triggerRequestBody(proof) {
+    return { ...unsignedRequestBody(proof), signature: proof.signature };
+}
+function unsignedRequestBody(proof) {
+    triggerProofMessage(proof);
+    const leg = (v) => (v === null ? null : toJsBigInt(v));
+    if ("intentId" in proof.target) {
+        throw new ParchmentApiError(0, "bad_request", "a prepared intent is saved with triggerPrepareBody (POST /triggers/prepare)");
+    }
+    return {
+        owner: normalizeAddress(proof.owner),
+        accountId: normalizeAddress(proof.accountId),
+        ...("positionId" in proof.target
+            ? { positionId: toJsBigInt(proof.target.positionId) }
+            : {
+                openTxDigest: txDigest(proof.target.openTxDigest),
+                marketId: normalizeAddress(proof.target.marketId),
+                isLong: proof.target.isLong,
+                ...(proof.takeProfitWad === null && proof.stopLossWad === null && proof.target.openTxBytesBase64 === undefined
+                    ? {}
+                    : { openTxBytesBase64: openTxBytes(proof.target.openTxBytesBase64, proof.target.openTxDigest) }),
+            }),
+        takeProfitWad: leg(proof.takeProfitWad),
+        stopLossWad: leg(proof.stopLossWad),
+        expiresAtMs: toJsBigInt(proof.expiresAtMs),
+    };
+}
+function targetLine(target) {
+    if ("positionId" in target)
+        return `position ${bounded(target.positionId, "positionId", U64_MAX)}`;
+    if (typeof target.isLong !== "boolean")
+        throw new ParchmentApiError(0, "bad_request", "isLong must be a boolean");
+    const side = target.isLong ? "long" : "short";
+    if ("intentId" in target)
+        return `intent ${intentId(target.intentId)} ${normalizeAddress(target.marketId)} ${side}`;
+    return `open ${txDigest(target.openTxDigest)} ${normalizeAddress(target.marketId)} ${side}`;
+}
+function intentId(id) {
+    if (typeof id !== "string" || !/^[0-9a-f]{32}$/.test(id)) {
+        throw new ParchmentApiError(0, "bad_request", "intentId must be 32 lowercase hex digits");
+    }
+    return id;
+}
+export function newTriggerIntentId() {
+    const bytes = new Uint8Array(16);
+    globalThis.crypto.getRandomValues(bytes);
+    return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+export function triggerPrepareBody(proof) {
+    const body = unsignedPrepareBody(proof);
+    if (typeof proof.signature !== "string" || proof.signature.length === 0) {
+        throw new ParchmentApiError(0, "bad_signature", "trigger signature is empty");
+    }
+    return { ...body, signature: proof.signature };
+}
+function unsignedPrepareBody(proof) {
+    const target = proof.target;
+    if (!("intentId" in target))
+        throw new ParchmentApiError(0, "bad_request", "a prepare needs an intent target");
+    triggerProofMessage(proof);
+    if (proof.takeProfitWad === null && proof.stopLossWad === null) {
+        throw new ParchmentApiError(0, "bad_request", "a prepared intent needs a take-profit or a stop-loss");
+    }
+    const leg = (v) => (v === null ? null : v.toString());
+    return {
+        owner: normalizeAddress(proof.owner),
+        accountId: normalizeAddress(proof.accountId),
+        intentId: target.intentId,
+        marketId: normalizeAddress(target.marketId),
+        isLong: target.isLong,
+        takeProfitWad: leg(proof.takeProfitWad),
+        stopLossWad: leg(proof.stopLossWad),
+        expiresAtMs: proof.expiresAtMs.toString(),
+    };
+}
+export function triggerBindBody(input) {
+    let decodes = false;
+    try {
+        decodes = typeof input.openTxBytesBase64 === "string" && TransactionDataBuilder.getDigestFromBytes(fromBase64(input.openTxBytesBase64)).length > 0;
+    }
+    catch {
+        decodes = false;
+    }
+    if (!decodes)
+        throw new ParchmentApiError(0, "bad_request", "openTxBytesBase64 must be the signed open transaction");
+    if (!Array.isArray(input.signatures) || input.signatures.length === 0 || input.signatures.some((s) => typeof s !== "string" || s.length === 0)) {
+        throw new ParchmentApiError(0, "bad_signature", "the signed open's signatures are required");
+    }
+    return {
+        owner: normalizeAddress(input.owner),
+        accountId: normalizeAddress(input.accountId),
+        intentId: intentId(input.intentId),
+        openTxBytesBase64: input.openTxBytesBase64,
+        signatures: [...input.signatures],
+    };
+}
+function txDigest(digest) {
+    let bytes;
+    try {
+        bytes = fromBase58(digest);
+    }
+    catch {
+        bytes = new Uint8Array();
+    }
+    if (typeof digest !== "string" || bytes.length !== 32 || toBase58(bytes) !== digest) {
+        throw new ParchmentApiError(0, "bad_request", "openTxDigest must be a transaction digest");
+    }
+    return digest;
+}
+function openTxBytes(bytesBase64, digest) {
+    let matches = false;
+    try {
+        matches = typeof bytesBase64 === "string" && TransactionDataBuilder.getDigestFromBytes(fromBase64(bytesBase64)) === digest;
+    }
+    catch {
+        matches = false;
+    }
+    if (!matches)
+        throw new ParchmentApiError(0, "bad_request", "openTxBytesBase64 must be the signed open transaction");
+    return bytesBase64;
+}
+function legLine(name, price) {
+    if (price === null)
+        return `${name} none`;
+    if (bounded(price, name === "tp" ? "takeProfitWad" : "stopLossWad", U128_MAX) === 0n) {
+        throw new ParchmentApiError(0, "bad_price", "trigger price must be non-zero");
+    }
+    return `${name} ${price}`;
+}
+function bounded(value, field, max) {
+    if (typeof value !== "bigint" || value < 0n || value > max) {
+        throw new ParchmentApiError(0, "bad_amount", `${field} is out of range`);
+    }
+    return value;
+}
+export const NEAR_LIQ_DISTANCE_FRACTION = 0.2;
+export function stopAgainstLiquidation(side, stop, liquidation, entry) {
+    const known = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0;
+    if (!known(liquidation) || !known(stop) || stop === 0)
+        return "ok";
+    if (side === "short" && liquidation === 0)
+        return "ok";
+    if (side === "long" ? stop <= liquidation : stop >= liquidation)
+        return "past";
+    if (!known(entry))
+        return "ok";
+    const span = side === "long" ? entry - liquidation : liquidation - entry;
+    if (!(span > 0))
+        return "ok";
+    return Math.abs(stop - liquidation) <= NEAR_LIQ_DISTANCE_FRACTION * span ? "near" : "ok";
+}

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

@@ -0,0 +1,111 @@
+import { type ApiParchmentExitEarlyBoundedTxBody, type ApiParchmentExitEarlyTxBody, type ApiParchmentReleaseUnlockedTxBody, type ApiParchmentSweepTxBody, type ApiParchmentSweepSurplusTxBody, type ApiParchmentClaimPendingMintTxBody, type ApiParchmentBindReferrerTxBody, type ApiParchmentBindTradingReferrerTxBody, type ApiParchmentTransferAccountTxBody, type ApiParchmentClaimQuestTxBody, type ApiParchmentClaimTxBody, type ApiParchmentClosePreviewBody, type ApiParchmentCancelOrderTxBody, type ApiParchmentEmergencyCloseAsDelegateTxBody, type ApiParchmentEmergencyCloseTxBody, type ApiParchmentExpireOrderTxBody, type ApiParchmentCloseRetiredAsDelegateTxBody, type ApiParchmentCloseRetiredTxBody, type ApiParchmentOrderRefTxBody, type ApiParchmentRequestCloseAsDelegateTxBody, type ApiParchmentRequestCloseTxBody, type ApiParchmentRequestOpenAsDelegateTxBody, type ApiParchmentRequestOpenTxBody, type ParchmentDelegateLiveness, type ApiParchmentDepositTxBody, type ApiParchmentGameTxBody, type ApiParchmentGrantDelegateTxBody, type ApiParchmentGrantCloseDelegateTxBody, type ApiParchmentGrantSessionAndTriggerTxBody, type ApiParchmentRevokeSessionAndTriggerTxBody, type ApiParchmentInstallTreasuryTxBody, type ApiParchmentAuthRegisterTxBody, type ApiParchmentLiquidateTxBody, type ApiParchmentLpHarvestTxBody, type ApiParchmentOpenAccountTxBody, type ApiParchmentOpenCratesTxBody, type ApiParchmentOpenPreviewBody, type ApiParchmentRegisterBuilderTxBody, type ApiParchmentSetBuilderCreateFeeTxBody, type ApiParchmentCreateBuilderTxBody, type ApiParchmentSetBuilderFeeTxBody, type ApiParchmentBuilderOwnerTxBody, type ApiParchmentTransferBuilderTxBody, type ApiParchmentApproveBuilderTxBody, type ApiParchmentRevokeBuilderApprovalTxBody, type ApiParchmentRevokeDelegateTxBody, type ApiParchmentSetBuilderPayoutTxBody, type ApiParchmentStakeTxBody, type ApiParchmentUnstakeTxBody, type ApiParchmentWithdrawTxBody } from "./parchmentTypes.js";
+export declare function openPreviewBody(input: ApiParchmentOpenPreviewBody): Record<string, unknown>;
+export declare function closePreviewBody(input: ApiParchmentClosePreviewBody): Record<string, unknown>;
+export declare function openAccountTxBody(input: ApiParchmentOpenAccountTxBody): Record<string, unknown>;
+/** `?builder=` code. Not an object id. Register-builder passes the service's `code_bytes` code `bad_code` for the length. */
+export declare function builderCode(value: string, lengthCode?: string): string;
+export declare function depositTxBody(input: ApiParchmentDepositTxBody): Record<string, unknown>;
+export declare function withdrawTxBody(input: ApiParchmentWithdrawTxBody): Record<string, unknown>;
+/** `order::request_open`. No oracle update: the keeper fills at the oracle mid. */
+export declare function requestOpenTxBody(input: ApiParchmentRequestOpenTxBody): Record<string, unknown>;
+/** Margin past `now + fill_deadline_ms` a delegation must outlive before the SDK builds a delegate request. */
+export declare const DELEGATE_FILL_MARGIN_MS = 60000n;
+/**
+ * Delegate-liveness pre-flight, mirroring on-chain `order::EDelegateExpiresBeforeDeadline` (order 28):
+ * refuses with `delegate_expires_before_deadline` unless the delegation expires after
+ * `now + fillDeadlineMs + DELEGATE_FILL_MARGIN_MS`. Renew the session key, then retry.
+ */
+export declare function assertDelegateLiveThroughFill(delegation: ParchmentDelegateLiveness): void;
+/** `order::request_open_as_delegate`. No AccountCap, no wallet top-up. Checks `delegation` first when given. */
+export declare function requestOpenAsDelegateTxBody(input: ApiParchmentRequestOpenAsDelegateTxBody): Record<string, unknown>;
+/** `order::request_close`. */
+export declare function requestCloseTxBody(input: ApiParchmentRequestCloseTxBody): Record<string, unknown>;
+/** `order::request_close_as_delegate`. No AccountCap, no wallet top-up. Checks `delegation` first when given. */
+export declare function requestCloseAsDelegateTxBody(input: ApiParchmentRequestCloseAsDelegateTxBody): Record<string, unknown>;
+/** `order::cancel`. */
+export declare function cancelOrderTxBody(input: ApiParchmentCancelOrderTxBody): Record<string, unknown>;
+/** `order::cancel_as_delegate`. */
+export declare function orderRefTxBody(input: ApiParchmentOrderRefTxBody): Record<string, unknown>;
+/**
+ * Permissionless `order::expire`. Every expiry takes an expiry price (`oracle::begin_expiry_price` on a
+ * verified signed update), on every market. When `update` is omitted, the service attaches a cached
+ * signed update that normalizes to the storage print, not the latest message. A caller update is
+ * used only when it is that print. Forwards the optional `marketId` fallback and signed update.
+ */
+export declare function expireOrderTxBody(input: ApiParchmentExpireOrderTxBody): Record<string, unknown>;
+/** `order::emergency_close`. Needs a signed oracle update. */
+export declare function emergencyCloseTxBody(input: ApiParchmentEmergencyCloseTxBody): Record<string, unknown>;
+/** `order::emergency_close_as_delegate`. No AccountCap. */
+export declare function emergencyCloseAsDelegateTxBody(input: ApiParchmentEmergencyCloseAsDelegateTxBody): Record<string, unknown>;
+/** `trade::close_retired`. One-step close on a retired market. */
+export declare function closeRetiredTxBody(input: ApiParchmentCloseRetiredTxBody): Record<string, unknown>;
+/** `trade::close_retired_as_delegate`. No AccountCap. */
+export declare function closeRetiredAsDelegateTxBody(input: ApiParchmentCloseRetiredAsDelegateTxBody): Record<string, unknown>;
+export declare function liquidateTxBody(input: ApiParchmentLiquidateTxBody): Record<string, unknown>;
+/** Default batch is 8. A caller value outside 1..=8 is rejected. */
+export declare function sweepBatch(value: string | bigint | undefined): string;
+export declare function sweepTxBody(input: ApiParchmentSweepTxBody): Record<string, unknown>;
+export declare function sweepSurplusTxBody(input: ApiParchmentSweepSurplusTxBody): Record<string, unknown>;
+export declare function claimPendingMintTxBody(input: ApiParchmentClaimPendingMintTxBody): Record<string, unknown>;
+/** Default batch is 32. A caller value outside 1..=128 is rejected. */
+export declare function harvestBatch(value: string | bigint | undefined): string;
+export declare function lpHarvestTxBody(input: ApiParchmentLpHarvestTxBody): Record<string, unknown>;
+export declare function bindReferrerTxBody(input: ApiParchmentBindReferrerTxBody): Record<string, unknown>;
+export declare function bindTradingReferrerTxBody(input: ApiParchmentBindTradingReferrerTxBody): Record<string, unknown>;
+/**
+ * `POST /v1/tx/transfer-account`. A zero recipient is a local `zero_recipient` and the sender itself a local
+ * `self_transfer` (chain `account_transfer::EZeroRecipient` / `holder_book::ERecipientHasAccount`).
+ */
+export declare function transferAccountTxBody(input: ApiParchmentTransferAccountTxBody): Record<string, unknown>;
+export declare function stakeTxBody(input: ApiParchmentStakeTxBody): Record<string, unknown>;
+export declare function unstakeTxBody(input: ApiParchmentUnstakeTxBody): Record<string, unknown>;
+export declare function claimTxBody(input: ApiParchmentClaimTxBody): Record<string, unknown>;
+export declare function releaseUnlockedTxBody(input: ApiParchmentReleaseUnlockedTxBody): Record<string, unknown>;
+export declare function exitEarlyTxBody(input: ApiParchmentExitEarlyTxBody): Record<string, unknown>;
+/** `locked_mint::max_buckets()`: no ledger holds more entries. */
+export declare const MAX_LOCKED_ENTRIES = 244;
+/**
+ * The approved entries' `unlock_ms` and the most penalty, as decimal strings. An entry
+ * is `(unlock_ms, vest_ms)`; a listed `unlock_ms` exits every exitable entry
+ * with that unlock (the penalty bound still applies to all of them).
+ */
+export declare function exitEarlyBoundedTxBody(input: ApiParchmentExitEarlyBoundedTxBody): Record<string, unknown>;
+/** The service grants its configured close-only delegate: the body names none. */
+export declare function grantCloseDelegateTxBody(input: ApiParchmentGrantCloseDelegateTxBody): Record<string, unknown>;
+/** `sessionDelegate` + `expiryMs`; the service adds its configured close-only delegate (a client one is refused). */
+export declare function grantSessionAndTriggerTxBody(input: ApiParchmentGrantSessionAndTriggerTxBody): Record<string, unknown>;
+export declare function revokeSessionAndTriggerTxBody(input: ApiParchmentRevokeSessionAndTriggerTxBody): Record<string, unknown>;
+export declare function grantDelegateTxBody(input: ApiParchmentGrantDelegateTxBody): Record<string, unknown>;
+/** the service's `share_bps_of`: 0..=5000 (the contract's hard cap), else `bad_share`. */
+/** The 1% hard cap on a builder fee, in bps of profit (`constants::max_builder_fee_bps_hard`). */
+export declare const BUILDER_FEE_HARD_BPS = 100n;
+/**
+ * Ceiling of the admin-set self-serve creation price, $100 in USDC base units
+ * (`constants::max_builder_create_fee`). The live price is `getConfig().builders.createFee`.
+ */
+export declare const MAX_BUILDER_CREATE_FEE = 100000000n;
+export declare function registerBuilderTxBody(input: ApiParchmentRegisterBuilderTxBody): Record<string, unknown>;
+/**
+ * `config::set_builder_create_fee` (admin): the self-serve creation price in USDC base units,
+ * `0n` (free) to {@link MAX_BUILDER_CREATE_FEE}; else `bad_amount`. the service's order: amount -> authority cap.
+ */
+export declare function setBuilderCreateFeeTxBody(input: ApiParchmentSetBuilderCreateFeeTxBody): Record<string, unknown>;
+export declare function installTreasuryTxBody(input: ApiParchmentInstallTreasuryTxBody): Record<string, unknown>;
+export declare function authRegisterTxBody(input: ApiParchmentAuthRegisterTxBody): Record<string, unknown>;
+export declare function setBuilderPayoutTxBody(input: ApiParchmentSetBuilderPayoutTxBody): Record<string, unknown>;
+/** `builder::create_builder`: code -> payout -> feeBps -> coin, in the service's order. */
+export declare function createBuilderTxBody(input: ApiParchmentCreateBuilderTxBody): Record<string, unknown>;
+/** `builder::set_builder_fee` (owner): up to the owner limit, or lower than an admin-set fee. */
+export declare function setBuilderFeeTxBody(input: ApiParchmentSetBuilderFeeTxBody): Record<string, unknown>;
+/** `builder::pause_builder` / `resume_builder` (owner). Neither lifts an admin suspend. */
+export declare function builderOwnerTxBody(input: ApiParchmentBuilderOwnerTxBody): Record<string, unknown>;
+/** `builder::transfer_owner`: one transaction by the current owner. */
+export declare function transferBuilderTxBody(input: ApiParchmentTransferBuilderTxBody): Record<string, unknown>;
+/** `builder::approve_builder` (AccountCap): the trader agrees to pay up to `maxFeeBps` of profit. */
+export declare function approveBuilderTxBody(input: ApiParchmentApproveBuilderTxBody): Record<string, unknown>;
+/** `builder::revoke_builder_approval` (AccountCap). */
+export declare function revokeBuilderApprovalTxBody(input: ApiParchmentRevokeBuilderApprovalTxBody): Record<string, unknown>;
+export declare function gameTxBody(input: ApiParchmentGameTxBody): Record<string, unknown>;
+export declare function claimQuestTxBody(input: ApiParchmentClaimQuestTxBody): Record<string, unknown>;
+export declare function openCratesTxBody(input: ApiParchmentOpenCratesTxBody): Record<string, unknown>;
+export declare function revokeDelegateTxBody(input: ApiParchmentRevokeDelegateTxBody): Record<string, unknown>;