@parchment-trade/sdk 0.0.0-stage → 1.0.1

package/dist/packages/parchment/parchment.js

@@ -0,0 +1,975 @@
+import { I64_MAX, U64_MAX, baseUnit, equityRange, historyCursor, i64Ms, idCursor, limitParam, normalizeAddress } from "../../general/utils/address.js";
+import { PUBLIC_INTS } from "./publicInts.js";
+import { monitoringPath, monitoringView, stakingHistoryPath, stakingHistoryView, statsActivityPath, statsActivityView, } from "./monitoring.js";
+import { Caller, requestTimeoutMs } from "../../general/utils/caller.js";
+import { decodeJsBigInts } from "../../general/utils/jsBigInt.js";
+import { ParchmentApiError } from "../../general/utils/errors.js";
+import { requireSplitPackageIds } from "./packageIds.js";
+import { UNCHECKED_TX, untrustedConfigPackages } from "./txIntent.js";
+import { ParchmentAccount } from "./parchmentAccount.js";
+import { ParchmentMarket } from "./parchmentMarket.js";
+import { LEADERBOARD_METRICS, LEADERBOARD_PERIODS, LOCKED_LEDGER_STATUSES, PARCHMENT_CANDLES_BATCH_MAX_MARKETS } from "./parchmentTypes.js";
+import { sponsorBody } from "./sponsor.js";
+import { bindReferrerTxBody, bindTradingReferrerTxBody, transferAccountTxBody, builderCode, claimQuestTxBody, claimTxBody, exitEarlyBoundedTxBody, exitEarlyTxBody, releaseUnlockedTxBody, closePreviewBody, depositTxBody, gameTxBody, openCratesTxBody, grantDelegateTxBody, grantCloseDelegateTxBody, grantSessionAndTriggerTxBody, revokeSessionAndTriggerTxBody, installTreasuryTxBody, authRegisterTxBody, liquidateTxBody, sweepTxBody, sweepSurplusTxBody, claimPendingMintTxBody, lpHarvestTxBody, openAccountTxBody, openPreviewBody, registerBuilderTxBody, createBuilderTxBody, setBuilderCreateFeeTxBody, setBuilderFeeTxBody, builderOwnerTxBody, transferBuilderTxBody, approveBuilderTxBody, revokeBuilderApprovalTxBody, revokeDelegateTxBody, setBuilderPayoutTxBody, stakeTxBody, unstakeTxBody, withdrawTxBody, cancelOrderTxBody, emergencyCloseAsDelegateTxBody, closeRetiredTxBody, closeRetiredAsDelegateTxBody, emergencyCloseTxBody, expireOrderTxBody, orderRefTxBody, requestCloseAsDelegateTxBody, requestCloseTxBody, requestOpenAsDelegateTxBody, requestOpenTxBody, } from "./txBodies.js";
+import { signTriggerProof, triggerRequestBody } from "./triggers.js";
+function int(value, field) {
+    if (typeof value !== "bigint")
+        throw new ParchmentApiError(0, "bad_body", `${field} must be an integer`);
+    return value;
+}
+function intOrNull(value, field) {
+    return value === null || value === undefined ? null : int(value, field);
+}
+function decimalText(value, field) {
+    if (typeof value !== "string")
+        throw new ParchmentApiError(0, "bad_body", `${field} must be a decimal string`);
+    return baseUnit(value, field);
+}
+const BUILDER_STATUSES = ["active", "paused", "suspended", "tombstoned"];
+function builderView(data) {
+    if ((data?.code !== null && typeof data?.code !== "string") ||
+        typeof data.active !== "boolean" ||
+        typeof data.selfServe !== "boolean" ||
+        typeof data.revokeOpen !== "boolean" ||
+        !BUILDER_STATUSES.includes(data.status)) {
+        throw new ParchmentApiError(0, "bad_body", "builder response is incomplete");
+    }
+    return {
+        id: int(data.id, "id"),
+        code: data.code,
+        payout: data.payout === null || data.payout === undefined ? null : servedAddress(data.payout),
+        owner: data.owner === null || data.owner === undefined ? null : servedAddress(data.owner),
+        active: data.active,
+        status: data.status,
+        selfServe: data.selfServe,
+        feeBps: int(data.feeBps, "feeBps"),
+        revokeOpen: data.revokeOpen,
+        pending: int(data.pending, "pending"),
+        totalEarned: int(data.totalEarned, "totalEarned"),
+    };
+}
+function choice(value, allowed, field, code) {
+    const text = typeof value === "string" ? value.trim() : value;
+    if (!allowed.includes(text)) {
+        throw new ParchmentApiError(0, code, `${field} must be ${allowed.join(", ")}`);
+    }
+    return text;
+}
+function intList(value, field) {
+    return list(value, field, int);
+}
+function servedAddress(value) {
+    if (typeof value === "string") {
+        try {
+            return normalizeAddress(value);
+        }
+        catch {
+        }
+    }
+    throw new ParchmentApiError(0, "bad_body", "response address is missing or malformed");
+}
+function bool(value, field) {
+    if (typeof value !== "boolean")
+        throw new ParchmentApiError(0, "bad_body", `${field} must be a boolean`);
+    return value;
+}
+function textOrNull(value, field) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value !== "string")
+        throw new ParchmentApiError(0, "bad_body", `${field} must be a string`);
+    return value;
+}
+function orderCursor(value) {
+    if (value === undefined || value === null || (typeof value === "string" && value.trim() === ""))
+        return undefined;
+    const cursor = typeof value === "string" ? value.trim() : "";
+    if (!/^[A-Za-z0-9:._-]{1,128}$/.test(cursor)) {
+        throw new ParchmentApiError(0, "bad_request", "cursor is not a valid orders page token");
+    }
+    return cursor;
+}
+function triggerCursor(value) {
+    if (value === undefined || value === null || (typeof value === "string" && value.trim() === ""))
+        return undefined;
+    const cursor = typeof value === "string" ? value.trim() : "";
+    if (!/^[A-Za-z0-9:]{1,200}$/.test(cursor)) {
+        throw new ParchmentApiError(0, "bad_request", "cursor is not a valid triggers page token");
+    }
+    return cursor;
+}
+function addressCursor(value, field) {
+    if (value === undefined || value === null || (typeof value === "string" && value.trim() === ""))
+        return undefined;
+    if (typeof value !== "string")
+        throw new ParchmentApiError(0, "bad_request", `${field} must be an address`);
+    try {
+        return normalizeAddress(value);
+    }
+    catch {
+        throw new ParchmentApiError(0, "bad_request", `${field} must be an address`);
+    }
+}
+function batchMarketIds(marketIds) {
+    if (!Array.isArray(marketIds))
+        throw new ParchmentApiError(0, "bad_request", "marketIds must be a list of market ids");
+    const ids = [...new Set(marketIds.map((id) => normalizeAddress(id)))];
+    if (ids.length === 0)
+        throw new ParchmentApiError(0, "bad_request", "marketIds must name at least one market");
+    if (ids.length > PARCHMENT_CANDLES_BATCH_MAX_MARKETS) {
+        throw new ParchmentApiError(0, "too_many_markets", `marketIds names ${ids.length} markets; at most ${PARCHMENT_CANDLES_BATCH_MAX_MARKETS}`);
+    }
+    return ids;
+}
+function candlesBatchSeries(item, field) {
+    if (typeof item?.marketId !== "string")
+        throw new ParchmentApiError(0, "bad_body", `${field}.marketId must be a string`);
+    if (Array.isArray(item.candles))
+        return { marketId: item.marketId, candles: item.candles };
+    const error = item.error;
+    if (typeof error?.code !== "string" || typeof error.message !== "string") {
+        throw new ParchmentApiError(0, "bad_body", `${field} needs candles or an error with code and message`);
+    }
+    return { marketId: item.marketId, error: { code: error.code, message: error.message } };
+}
+function list(value, field, each) {
+    if (!Array.isArray(value))
+        throw new ParchmentApiError(0, "bad_body", `${field} must be a list`);
+    return value.map((item, index) => each(item, `${field}[${index}]`));
+}
+function feeAchievement(data, field) {
+    return {
+        id: int(data?.id, `${field}.id`),
+        name: textOrNull(data?.name, `${field}.name`),
+        feesRequired: int(data?.feesRequired, `${field}.feesRequired`),
+        feesNeeded: int(data?.feesNeeded, `${field}.feesNeeded`),
+        xp: int(data?.xp, `${field}.xp`),
+        mintAmount: int(data?.mintAmount, `${field}.mintAmount`),
+        eligibleMint: int(data?.eligibleMint, `${field}.eligibleMint`),
+        mintAtUnlock: int(data?.mintAtUnlock, `${field}.mintAtUnlock`),
+        active: bool(data?.active, `${field}.active`),
+        unlocked: bool(data?.unlocked, `${field}.unlocked`),
+        ...(data?.unlockable === undefined ? {} : { unlockable: bool(data.unlockable, `${field}.unlockable`) }),
+    };
+}
+function gameView(data) {
+    const view = {
+        walletAddress: servedAddress(data.walletAddress),
+        xp: int(data.xp, "xp"),
+        seasonXp: int(data.seasonXp, "seasonXp"),
+        seasonId: int(data.seasonId, "seasonId"),
+        tier: int(data.tier, "tier"),
+        streak: int(data.streak, "streak"),
+        winStreak: int(data.winStreak, "winStreak"),
+        crates: int(data.crates, "crates"),
+        trades: int(data.trades, "trades"),
+    };
+    for (const key of ["achievements", "questsDone", "cosmetics"]) {
+        if (data[key] !== undefined)
+            view[key] = intList(data[key], key);
+    }
+    for (const key of ["minted", "mintedToday", "pendingMint", "feeCredit", "feeCreditUsed", "achievementMintFractionBps"]) {
+        if (data[key] !== undefined)
+            view[key] = int(data[key], key);
+    }
+    if (data.lastDailyDay !== undefined)
+        view.lastDailyDay = intOrNull(data.lastDailyDay, "lastDailyDay");
+    if (data.dailyClaimedToday !== undefined)
+        view.dailyClaimedToday = bool(data.dailyClaimedToday, "dailyClaimedToday");
+    if (data.feeAchievements !== undefined) {
+        view.feeAchievements = list(data.feeAchievements, "feeAchievements", feeAchievement);
+    }
+    if (data.lockedLedgerStatus !== undefined) {
+        if (!LOCKED_LEDGER_STATUSES.includes(data.lockedLedgerStatus)) {
+            throw new ParchmentApiError(0, "bad_body", "lockedLedgerStatus must be current, rebuilding or failed");
+        }
+        view.lockedLedgerStatus = data.lockedLedgerStatus;
+    }
+    for (const key of [
+        "lockedBalance",
+        "lockWindowBalance",
+        "nextUnlockMs",
+        "vestingBalance",
+        "releasableNow",
+        "earlyExitPaidNow",
+        "earlyExitPenaltyNow",
+    ]) {
+        if (data[key] !== undefined)
+            view[key] = intOrNull(data[key], key);
+    }
+    if (data.earlyExitUnlocks !== undefined) {
+        view.earlyExitUnlocks = data.earlyExitUnlocks === null ? null : intList(data.earlyExitUnlocks, "earlyExitUnlocks");
+    }
+    return view;
+}
+function dripView(data) {
+    const out = {};
+    for (const key of ["parchDripRemaining", "parchDripNow", "parchDripLastMs", "parchDripEndMs", "totalWeight", "lockedWeight", "lockedOwedTotal"]) {
+        if (data[key] !== undefined)
+            out[key] = int(data[key], key);
+    }
+    if (data.lockedWeightBps !== undefined)
+        out.lockedWeightBps = intOrNull(data.lockedWeightBps, "lockedWeightBps");
+    return out;
+}
+function lockedYieldView(data) {
+    const out = {};
+    for (const key of ["lockedWeight", "lockedSyncedBalance", "lockedPending", "lockedOwed", "totalWeight"]) {
+        if (data[key] !== undefined && data[key] !== null)
+            out[key] = int(data[key], key);
+    }
+    return out;
+}
+function definitionsView(data) {
+    return {
+        quests: list(data?.quests, "quests", (q, f) => ({
+            id: int(q?.id, `${f}.id`),
+            name: textOrNull(q?.name, `${f}.name`),
+            kind: int(q?.kind, `${f}.kind`),
+            param: int(q?.param, `${f}.param`),
+            xp: int(q?.xp, `${f}.xp`),
+            cosmetic: intOrNull(q?.cosmetic, `${f}.cosmetic`),
+            active: bool(q?.active, `${f}.active`),
+            startMs: int(q?.startMs, `${f}.startMs`),
+            endMs: int(q?.endMs, `${f}.endMs`),
+            seasonId: int(q?.seasonId, `${f}.seasonId`),
+        })),
+        achievements: list(data?.achievements, "achievements", (a, f) => ({
+            id: int(a?.id, `${f}.id`),
+            name: textOrNull(a?.name, `${f}.name`),
+            kind: int(a?.kind, `${f}.kind`),
+            param: int(a?.param, `${f}.param`),
+            xp: int(a?.xp, `${f}.xp`),
+            mintAmount: int(a?.mintAmount, `${f}.mintAmount`),
+            cosmetic: intOrNull(a?.cosmetic, `${f}.cosmetic`),
+            active: bool(a?.active, `${f}.active`),
+        })),
+        cosmetics: list(data?.cosmetics, "cosmetics", (c, f) => ({
+            id: int(c?.id, `${f}.id`),
+            name: textOrNull(c?.name, `${f}.name`) ?? "",
+        })),
+        achievementMintFractionBps: int(data?.achievementMintFractionBps, "achievementMintFractionBps"),
+    };
+}
+function statsView(data, field) {
+    return {
+        trades: int(data?.trades, `${field}.trades`),
+        closes: int(data?.closes, `${field}.closes`),
+        wins: int(data?.wins, `${field}.wins`),
+        volume: int(data?.volume, `${field}.volume`),
+        pnl: int(data?.pnl, `${field}.pnl`),
+        winRateBps: intOrNull(data?.winRateBps, `${field}.winRateBps`),
+        xp: int(data?.xp, `${field}.xp`),
+        tier: int(data?.tier, `${field}.tier`),
+        winStreak: int(data?.winStreak, `${field}.winStreak`),
+    };
+}
+function leaderboardRow(data, field) {
+    const row = {
+        rank: int(data?.rank, `${field}.rank`),
+        walletAddress: servedAddress(data?.walletAddress),
+        value: int(data?.value, `${field}.value`),
+    };
+    if (data?.stats !== undefined)
+        row.stats = statsView(data.stats, `${field}.stats`);
+    return row;
+}
+function feedEntry(data, field) {
+    const entry = {
+        walletAddress: servedAddress(data?.walletAddress),
+        marketId: servedAddress(data?.marketId),
+        positionId: int(data?.positionId, `${field}.positionId`),
+        pnl: int(data?.pnl, `${field}.pnl`),
+        notional: int(data?.notional, `${field}.notional`),
+        atMs: int(data?.atMs, `${field}.atMs`),
+    };
+    if (data?.side !== undefined) {
+        if (data.side !== null && data.side !== "long" && data.side !== "short") {
+            throw new ParchmentApiError(0, "bad_body", `${field}.side must be long or short`);
+        }
+        entry.side = data.side;
+    }
+    if (data?.isLong !== undefined)
+        entry.isLong = data.isLong === null ? null : bool(data.isLong, `${field}.isLong`);
+    if (data?.leverage !== undefined)
+        entry.leverage = intOrNull(data.leverage, `${field}.leverage`);
+    if (data?.kind !== undefined)
+        entry.kind = textOrNull(data.kind, `${field}.kind`) ?? undefined;
+    if (data?.exitWad !== undefined)
+        entry.exitWad = intOrNull(data.exitWad, `${field}.exitWad`);
+    return entry;
+}
+function feedView(data, field) {
+    if (!Array.isArray(data?.entries)) {
+        throw new ParchmentApiError(0, "bad_body", `${field} entries must be a list`);
+    }
+    return { entries: data.entries.map((entry, index) => feedEntry(entry, `${field}[${index}]`)) };
+}
+function msParam(value) {
+    if (value === undefined)
+        return undefined;
+    const text = typeof value === "string" ? value.trim()
+        : typeof value === "bigint" || (typeof value === "number" && Number.isSafeInteger(value)) ? value.toString() : "";
+    if (!/^[0-9]{1,19}$/.test(text) || BigInt(text) > I64_MAX) {
+        throw new ParchmentApiError(0, "bad_time", "nowMs must be 0..=9223372036854775807 ms");
+    }
+    return text;
+}
+function query(pairs) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(pairs)) {
+        if (value !== undefined)
+            params.set(key, value);
+    }
+    const text = params.toString();
+    return text ? `?${text}` : "";
+}
+export class Parchment extends Caller {
+    static async create(options) {
+        return new Parchment(options);
+    }
+    constructor(options) {
+        options = mergeRequestOptions(options, options);
+        super(options, "parchment");
+        requestTimeoutMs(options.timeoutMs);
+    }
+    withRequestOptions(options) {
+        return new Parchment(mergeRequestOptions(this.config, options));
+    }
+    async getConfig() {
+        const config = await this.fetchApi("config", PUBLIC_INTS.config);
+        const trust = this.config.txTrust;
+        if (trust && trust !== UNCHECKED_TX) {
+            const untrusted = untrustedConfigPackages(config, trust.packages);
+            if (untrusted.length > 0) {
+                throw new ParchmentApiError(0, "untrusted_package", `config names package ids outside txTrust: ${untrusted.join(", ")}`);
+            }
+        }
+        return requireSplitPackageIds(config);
+    }
+    getLimits() {
+        return this.fetchApi("limits", PUBLIC_INTS.none);
+    }
+    async getMarkets() {
+        const markets = await this.fetchApiField("markets", "markets", PUBLIC_INTS.markets);
+        return { markets: markets.map((market) => new ParchmentMarket(this.config, market)) };
+    }
+    async getMarket(input) {
+        const market = await this.fetchApiField(`markets/${normalizeAddress(input.marketId)}`, "market", PUBLIC_INTS.market);
+        return new ParchmentMarket(this.config, market);
+    }
+    async getPriceHistory(input) {
+        const qs = query({
+            fromMs: input.fromMs === undefined ? undefined : i64Ms(input.fromMs, "fromMs"),
+            toMs: input.toMs === undefined ? undefined : i64Ms(input.toMs, "toMs"),
+            limit: limitParam(input.limit),
+        });
+        return this.fetchApi(`markets/${normalizeAddress(input.marketId)}/prices${qs}`, PUBLIC_INTS.priceHistory);
+    }
+    async getCandles(input) {
+        const qs = query({
+            resolution: input.resolution,
+            fromMs: input.fromMs === undefined ? undefined : i64Ms(input.fromMs, "fromMs"),
+            toMs: input.toMs === undefined ? undefined : i64Ms(input.toMs, "toMs"),
+            limit: limitParam(input.limit),
+        });
+        return this.fetchApi(`markets/${normalizeAddress(input.marketId)}/candles${qs}`, PUBLIC_INTS.candles);
+    }
+    async getCandlesBatch(input) {
+        const qs = query({
+            resolution: input.resolution,
+            markets: batchMarketIds(input.marketIds).join(","),
+            fromMs: input.fromMs === undefined ? undefined : i64Ms(input.fromMs, "fromMs"),
+            toMs: input.toMs === undefined ? undefined : i64Ms(input.toMs, "toMs"),
+            limit: limitParam(input.limit),
+        });
+        const data = await this.fetchApi(`markets/candles${qs}`, PUBLIC_INTS.candlesBatch);
+        if (typeof data?.resolution !== "string")
+            throw new ParchmentApiError(0, "bad_body", "resolution must be a string");
+        return {
+            resolution: data.resolution,
+            serverTimeMs: int(data.serverTimeMs, "serverTimeMs"),
+            series: list(data.series, "series", candlesBatchSeries),
+        };
+    }
+    getPrices() {
+        return this.fetchApi("prices", PUBLIC_INTS.prices);
+    }
+    pricesStreamUrl(input = {}) {
+        const ids = input.marketIds?.map((id) => normalizeAddress(id));
+        return this.urlForApiCall(`prices/stream${query({ markets: ids?.length ? ids.join(",") : undefined })}`);
+    }
+    tradesStreamUrl(input = {}) {
+        return this.urlForApiCall(`trades/stream${query({ after: input.after?.toString() })}`);
+    }
+    async getAccount(input) {
+        const qs = query({
+            limit: limitParam(input.limit),
+            accountsCursor: addressCursor(input.accountsCursor, "accountsCursor"),
+            positionsCursor: idCursor(input.positionsCursor, "positionsCursor"),
+            claimsCursor: idCursor(input.claimsCursor, "claimsCursor"),
+        });
+        const data = await this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}${qs}`, PUBLIC_INTS.account);
+        return new ParchmentAccount(this.config, data);
+    }
+    async getPositions(input) {
+        const qs = query({ cursor: idCursor(input.cursor, "cursor"), limit: limitParam(input.limit) });
+        return this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/positions${qs}`, PUBLIC_INTS.positions);
+    }
+    async getEquityHistory(input) {
+        return this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/equity${query({ range: equityRange(input.range) })}`, PUBLIC_INTS.equityHistory);
+    }
+    async getHistory(input) {
+        const qs = query({
+            cursor: historyCursor(input.cursor),
+            limit: limitParam(input.limit),
+        });
+        return this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/history${qs}`, PUBLIC_INTS.history);
+    }
+    getLp() {
+        return this.fetchApi("lp", PUBLIC_INTS.lp);
+    }
+    async getStakingPool() {
+        const data = await this.fetchApi("staking", PUBLIC_INTS.stakingPool);
+        if (data === null)
+            return null;
+        return {
+            poolId: servedAddress(data.poolId),
+            configId: data.configId === null ? null : servedAddress(data.configId),
+            totalStaked: int(data.totalStaked, "totalStaked"),
+            accRewardPerShare: decimalText(data.accRewardPerShare, "accRewardPerShare"),
+            streamRemaining: int(data.streamRemaining, "streamRemaining"),
+            streamLastMs: int(data.streamLastMs, "streamLastMs"),
+            streamEndMs: int(data.streamEndMs, "streamEndMs"),
+            streamVestedNow: int(data.streamVestedNow, "streamVestedNow"),
+            rewardStreamMs: int(data.rewardStreamMs, "rewardStreamMs"),
+            minStakeLockMs: int(data.minStakeLockMs, "minStakeLockMs"),
+            rewards: int(data.rewards, "rewards"),
+            referralReserve: int(data.referralReserve, "referralReserve"),
+            nowMs: int(data.nowMs, "nowMs"),
+            ...dripView(data),
+        };
+    }
+    async getStaker(input) {
+        const data = await this.fetchApi(`staking/${normalizeAddress(input.walletAddress)}`, PUBLIC_INTS.staker);
+        if (typeof data.locked !== "boolean") {
+            throw new ParchmentApiError(0, "bad_body", "locked must be a boolean");
+        }
+        return {
+            owner: servedAddress(data.owner),
+            staked: int(data.staked, "staked"),
+            rewardDebt: decimalText(data.rewardDebt, "rewardDebt"),
+            stakedAtMs: int(data.stakedAtMs, "stakedAtMs"),
+            unlockAtMs: int(data.unlockAtMs, "unlockAtMs"),
+            locked: data.locked,
+            pendingReward: int(data.pendingReward, "pendingReward"),
+            ...(data.parchPending === undefined || data.parchPending === null ? {} : { parchPending: int(data.parchPending, "parchPending") }),
+            ...(data.pendingRewardExact === undefined || data.pendingRewardExact === null
+                ? {}
+                : { pendingRewardExact: bool(data.pendingRewardExact, "pendingRewardExact") }),
+            ...lockedYieldView(data),
+            nowMs: int(data.nowMs, "nowMs"),
+        };
+    }
+    async getQueue() {
+        const data = await this.fetchApi("queue", PUBLIC_INTS.queue);
+        return {
+            length: int(data.length, "length"),
+            totalOwed: int(data.totalOwed, "totalOwed"),
+            lpCash: intOrNull(data.lpCash, "lpCash"),
+            instantlyPayable: intOrNull(data.instantlyPayable, "instantlyPayable"),
+        };
+    }
+    async getAccountQueue(input) {
+        const data = await this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/queue`, PUBLIC_INTS.accountQueue);
+        if (typeof data.hasClaim !== "boolean") {
+            throw new ParchmentApiError(0, "bad_body", "hasClaim must be a boolean");
+        }
+        return {
+            hasClaim: data.hasClaim,
+            net: int(data.net, "net"),
+            owner: servedAddress(data.owner),
+            rank: intOrNull(data.rank, "rank"),
+        };
+    }
+    async getReferrals(input) {
+        const qs = query({
+            limit: limitParam(input.limit),
+            directCursor: addressCursor(input.directCursor, "directCursor"),
+            secondLevelCursor: addressCursor(input.secondLevelCursor, "secondLevelCursor"),
+        });
+        return this.fetchApi(`referrals/${normalizeAddress(input.walletAddress)}${qs}`, PUBLIC_INTS.referrals);
+    }
+    async getTradingReferral(input) {
+        const data = await this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/trading-referral`, PUBLIC_INTS.tradingReferral);
+        if (data.referrer !== null && typeof data.referrer !== "string") {
+            throw new ParchmentApiError(0, "bad_body", "referrer must be an address or null");
+        }
+        return {
+            referrer: data.referrer === null ? null : servedAddress(data.referrer),
+            refereeCount: int(data.refereeCount, "refereeCount"),
+            totalEarned: int(data.totalEarned, "totalEarned"),
+            pending: int(data.pending, "pending"),
+        };
+    }
+    async getBuilder(input) {
+        const code = builderCode(input.code, input.code === "" ? "bad_request" : "bad_code");
+        if (code === "." || code === "..")
+            throw new ParchmentApiError(0, "bad_request", "invalid builder code");
+        const data = await this.fetchApi(`builders/${encodeURIComponent(code)}`, PUBLIC_INTS.builder);
+        return builderView(data);
+    }
+    async getOwnedBuilders(input) {
+        const data = await this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/builders`, PUBLIC_INTS.builders);
+        if (!Array.isArray(data))
+            throw new ParchmentApiError(0, "bad_body", "builder list is not a list");
+        return data.map(builderView);
+    }
+    async getBuilderAllowance(input) {
+        const data = await this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/builder-allowance`, PUBLIC_INTS.builderAllowance);
+        return {
+            created: int(data.created, "created"),
+            limit: int(data.limit, "limit"),
+            remaining: int(data.remaining, "remaining"),
+        };
+    }
+    async getBuilderApprovals(input) {
+        const data = await this.fetchApi(`accounts/${normalizeAddress(input.accountId)}/builder-approvals`, PUBLIC_INTS.builderApprovals);
+        if (!Array.isArray(data))
+            throw new ParchmentApiError(0, "bad_body", "approval list is not a list");
+        return data.map((a) => ({
+            accountId: servedAddress(a.accountId),
+            builderId: int(a.builderId, "builderId"),
+            maxFeeBps: int(a.maxFeeBps, "maxFeeBps"),
+        }));
+    }
+    async getAccountBuilder(input) {
+        const data = await this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/builder`, PUBLIC_INTS.builder);
+        if (data === null)
+            return null;
+        return builderView(data);
+    }
+    async getGameDefinitions() {
+        return definitionsView(await this.fetchApi("game/definitions", PUBLIC_INTS.gameDefinitions));
+    }
+    async getGame(input) {
+        const data = await this.fetchApi(`game/${normalizeAddress(input.walletAddress)}`, PUBLIC_INTS.game);
+        return gameView(data);
+    }
+    async getLeaderboard(input) {
+        const period = choice(input.period, LEADERBOARD_PERIODS, "period", "bad_period");
+        const by = choice(input.by, LEADERBOARD_METRICS, "by", "bad_metric");
+        const owner = input.walletAddress === undefined ? undefined : normalizeAddress(input.walletAddress);
+        const cursor = idCursor(input.cursor, "cursor", U64_MAX, "bad_cursor");
+        const limit = limitParam(input.limit);
+        const nowMs = msParam(input.nowMs);
+        const data = await this.fetchApi(`leaderboards${query({ period, by, owner, cursor, limit, nowMs })}`, PUBLIC_INTS.leaderboard);
+        if (!Array.isArray(data?.rows)) {
+            throw new ParchmentApiError(0, "bad_body", "rows must be a list");
+        }
+        return {
+            period,
+            by,
+            rows: data.rows.map((row, index) => leaderboardRow(row, `rows[${index}]`)),
+            viewer: data.viewer == null ? null : leaderboardRow(data.viewer, "viewer"),
+            nextCursor: intOrNull(data.nextCursor, "nextCursor"),
+        };
+    }
+    async getWhaleFeed(input = {}) {
+        const qs = query({ limit: limitParam(input.limit) });
+        return feedView(await this.fetchApi(`feed/whales${qs}`, PUBLIC_INTS.feed), "whales");
+    }
+    async getRektFeed(input = {}) {
+        const qs = query({ limit: limitParam(input.limit) });
+        return feedView(await this.fetchApi(`feed/rekt${qs}`, PUBLIC_INTS.feed), "rekt");
+    }
+    async getPnlCard(input) {
+        const raw = typeof input.positionId === "bigint" ? input.positionId.toString()
+            : typeof input.positionId === "string" ? input.positionId.trim() : "";
+        if (raw.length === 0)
+            throw new ParchmentApiError(0, "position_required", "positionId is required");
+        if (!/^[0-9]+$/.test(raw)) {
+            throw new ParchmentApiError(0, "bad_position", "positionId must be a base-unit integer");
+        }
+        if (raw.length > 39 || BigInt(raw) > (1n << 128n) - 1n) {
+            throw new ParchmentApiError(0, "bad_position", "positionId is not an unsigned integer");
+        }
+        const positionId = raw;
+        const data = await this.fetchApi(`cards/pnl${query({ positionId })}`, PUBLIC_INTS.pnlCard);
+        if (typeof data?.isLong !== "boolean") {
+            throw new ParchmentApiError(0, "bad_body", "isLong must be a boolean");
+        }
+        return {
+            positionId: int(data.positionId, "positionId"),
+            walletAddress: servedAddress(data.walletAddress),
+            marketId: servedAddress(data.marketId),
+            pnl: int(data.pnl, "pnl"),
+            pnlPct: int(data.pnlPct, "pnlPct"),
+            isLong: data.isLong,
+            ...(typeof data.settled === "boolean" ? { settled: data.settled } : {}),
+        };
+    }
+    getProtocol() {
+        return this.fetchApi("protocol", PUBLIC_INTS.protocol);
+    }
+    async getRecentPositions(input = {}) {
+        const qs = query({ limit: limitParam(input.limit) });
+        const data = await this.fetchApi(`positions/recent${qs}`, PUBLIC_INTS.recentPositions);
+        if (!Array.isArray(data?.entries))
+            throw new ParchmentApiError(0, "bad_body", "entries must be a list");
+        return data.entries.map((e) => ({
+            ...e,
+            walletAddress: servedAddress(e.walletAddress),
+            marketId: e.marketId === null ? null : servedAddress(e.marketId),
+        }));
+    }
+    getMarketStats() {
+        return this.fetchApi("markets/stats", PUBLIC_INTS.marketStats);
+    }
+    async getMonitoring(input = {}) {
+        return monitoringView(await this.fetchApi(monitoringPath(input.days), PUBLIC_INTS.none));
+    }
+    async getStatsActivity(input = {}) {
+        return statsActivityView(await this.fetchApi(statsActivityPath(input.days), PUBLIC_INTS.none));
+    }
+    async getStakingHistory(input) {
+        return stakingHistoryView(await this.fetchApi(stakingHistoryPath(input.days), PUBLIC_INTS.none));
+    }
+    getLpQueue() {
+        return this.fetchApi("lp/queue", PUBLIC_INTS.lpQueue);
+    }
+    async getOrders(owner, input = {}) {
+        const qs = query({
+            status: input.status,
+            limit: limitParam(input.limit),
+            cursor: orderCursor(input.cursor),
+        });
+        return this.fetchApi(`accounts/${normalizeAddress(owner)}/orders${qs}`, PUBLIC_INTS.orders);
+    }
+    async getOrder(orderId, signal) {
+        const id = normalizeAddress(orderId);
+        const order = await this.fetchApiField(`orders/${id}`, "order", PUBLIC_INTS.order, signal);
+        return checkedOrder(order, id);
+    }
+    async waitForOrder(orderId, { timeoutMs = 10_000, pollMs = 500, signal: callerSignal } = {}) {
+        normalizeAddress(orderId);
+        const clientSignal = this.config.signal;
+        const signal = clientSignal && callerSignal ? AbortSignal.any([callerSignal, clientSignal]) : (callerSignal ?? clientSignal);
+        signal?.throwIfAborted();
+        const pollInterval = Number.isFinite(pollMs) && pollMs > 0 ? pollMs : 500;
+        if (Number.isNaN(timeoutMs))
+            timeoutMs = 10_000;
+        const deadline = Date.now() + timeoutMs;
+        const timeout = new AbortController();
+        const timer = setTimeout(() => timeout.abort(), Math.min(Math.max(0, timeoutMs), 2_147_483_647));
+        const stop = signal ? AbortSignal.any([signal, timeout.signal]) : timeout.signal;
+        let lastError;
+        try {
+            for (;;) {
+                try {
+                    const order = await this.getOrder(orderId, stop);
+                    if (order.status !== "pending")
+                        return order;
+                    lastError = undefined;
+                }
+                catch (error) {
+                    signal?.throwIfAborted();
+                    if (!timeout.signal.aborted)
+                        lastError = error;
+                }
+                const timedOut = () => {
+                    const suffix = lastError instanceof Error ? ` (last error: ${lastError.message})` : "";
+                    return new Error(`Timed out after ${timeoutMs} ms waiting for order ${orderId} to leave pending${suffix}`);
+                };
+                const remaining = deadline - Date.now();
+                if (remaining <= 0 || timeout.signal.aborted)
+                    throw timedOut();
+                const hint = lastError instanceof ParchmentApiError ? (lastError.retryAfterMs ?? 0) : 0;
+                if (hint >= remaining)
+                    throw timedOut();
+                await sleep(Math.min(Math.max(pollInterval, hint), remaining), stop);
+                signal?.throwIfAborted();
+                if (deadline - Date.now() <= 0 || timeout.signal.aborted)
+                    throw timedOut();
+            }
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    getPreviewOpen(input) {
+        return this.fetchApi("previews/open", PUBLIC_INTS.previewOpen, openPreviewBody(input));
+    }
+    getPreviewClose(input) {
+        return this.fetchApi("previews/close", PUBLIC_INTS.previewClose, closePreviewBody(input));
+    }
+    getOpenAccountTx(input) {
+        return this.fetchApiTxObject("transactions/open-account", openAccountTxBody(input));
+    }
+    getDepositTx(input) {
+        return this.fetchApiTxObject("transactions/deposit", depositTxBody(input));
+    }
+    getWithdrawTx(input) {
+        return this.fetchApiTxObject("transactions/withdraw", withdrawTxBody(input));
+    }
+    getRequestOpenTx(input) {
+        return this.fetchApiTxObject("transactions/request-open", requestOpenTxBody(input));
+    }
+    getRequestOpenAsDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/request-open-as-delegate", requestOpenAsDelegateTxBody(input));
+    }
+    getRequestCloseTx(input) {
+        return this.fetchApiTxObject("transactions/request-close", requestCloseTxBody(input));
+    }
+    getRequestCloseAsDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/request-close-as-delegate", requestCloseAsDelegateTxBody(input));
+    }
+    getCancelOrderTx(input) {
+        return this.fetchApiTxObject("transactions/cancel-order", cancelOrderTxBody(input));
+    }
+    getCancelOrderAsDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/cancel-order-as-delegate", orderRefTxBody(input));
+    }
+    getExpireOrderTx(input) {
+        return this.fetchApiTxObject("transactions/expire-order", expireOrderTxBody(input));
+    }
+    getEmergencyCloseTx(input) {
+        return this.fetchApiTxObject("transactions/emergency-close", emergencyCloseTxBody(input));
+    }
+    getEmergencyCloseAsDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/emergency-close-as-delegate", emergencyCloseAsDelegateTxBody(input));
+    }
+    getCloseRetiredTx(input) {
+        return this.fetchApiTxObject("transactions/close-retired", closeRetiredTxBody(input));
+    }
+    getCloseRetiredAsDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/close-retired-as-delegate", closeRetiredAsDelegateTxBody(input));
+    }
+    getLiquidateTx(input) {
+        const path = input.retired ? "transactions/liquidate-retired" : "transactions/liquidate";
+        return this.fetchApiTxObject(path, liquidateTxBody(input));
+    }
+    getSweepTx(input) {
+        return this.fetchApiTxObject("transactions/sweep", sweepTxBody(input));
+    }
+    getSweepSurplusTx(input) {
+        return this.fetchApiTxObject("transactions/sweep-surplus", sweepSurplusTxBody(input));
+    }
+    getClaimPendingMintTx(input) {
+        return this.fetchApiTxObject("transactions/claim-pending-mint", claimPendingMintTxBody(input));
+    }
+    getHarvestTx(input) {
+        return this.fetchApiTxObject("transactions/harvest", lpHarvestTxBody(input));
+    }
+    getBindReferrerTx(input) {
+        return this.fetchApiTxObject("transactions/bind-referrer", bindReferrerTxBody(input));
+    }
+    getBindTradingReferrerTx(input) {
+        return this.fetchApiTxObject("transactions/bind-trading-referrer", bindTradingReferrerTxBody(input));
+    }
+    async getTransferAccountTx(input) {
+        return this.fetchApiTxObject("transactions/transfer-account", transferAccountTxBody(input));
+    }
+    getStakeTx(input) {
+        return this.fetchApiTxObject("transactions/stake", stakeTxBody(input));
+    }
+    getUnstakeTx(input) {
+        return this.fetchApiTxObject("transactions/unstake", unstakeTxBody(input));
+    }
+    getClaimTx(input) {
+        return this.fetchApiTxObject("transactions/claim", claimTxBody(input));
+    }
+    async getReleaseUnlockedTx(input) {
+        const built = await this.fetchApiTxObject("transactions/release-unlocked", releaseUnlockedTxBody(input));
+        return input.syncLocked ? this.appendSyncLocked(built, input.who ?? input.walletAddress) : built;
+    }
+    async getExitEarlyTx(input) {
+        const built = await this.fetchApiTxObject("transactions/exit-early", exitEarlyTxBody(input));
+        return input.syncLocked ? this.appendSyncLocked(built, input.walletAddress) : built;
+    }
+    async getExitEarlyBoundedTx(input) {
+        const built = await this.fetchApiTxObject("transactions/exit-early-bounded", exitEarlyBoundedTxBody(input));
+        return input.syncLocked ? this.appendSyncLocked(built, input.walletAddress) : built;
+    }
+    getGrantDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/grant-delegate", grantDelegateTxBody(input));
+    }
+    getRevokeDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/revoke-delegate", revokeDelegateTxBody(input));
+    }
+    getGrantSessionAndTriggerTx(input) {
+        return this.fetchApiTxObject("transactions/grant-session-and-trigger", grantSessionAndTriggerTxBody(input));
+    }
+    getRevokeSessionAndTriggerTx(input) {
+        return this.fetchApiTxObject("transactions/revoke-session-and-trigger", revokeSessionAndTriggerTxBody(input));
+    }
+    getGrantCloseDelegateTx(input) {
+        return this.fetchApiTxObject("transactions/grant-close-delegate", grantCloseDelegateTxBody(input));
+    }
+    async getTriggers(input) {
+        const qs = query({ cursor: triggerCursor(input.cursor), limit: limitParam(input.limit) });
+        return this.fetchApi(`accounts/${normalizeAddress(input.walletAddress)}/triggers${qs}`, PUBLIC_INTS.triggers);
+    }
+    async setTriggers(input, signer, nowMs) {
+        const proof = await signTriggerProof(signer, input, nowMs);
+        return this.fetchApi("triggers", PUBLIC_INTS.trigger, triggerRequestBody(proof));
+    }
+    getRegisterBuilderTx(input) {
+        return this.fetchApiTxObject("transactions/register-builder", registerBuilderTxBody(input));
+    }
+    getSetBuilderPayoutTx(input) {
+        return this.fetchApiTxObject("transactions/set-builder-payout", setBuilderPayoutTxBody(input));
+    }
+    getCreateBuilderTx(input) {
+        return this.fetchApiTxObject("transactions/create-builder", createBuilderTxBody(input));
+    }
+    getSetBuilderCreateFeeTx(input) {
+        return this.fetchApiTxObject("transactions/set-builder-create-fee", setBuilderCreateFeeTxBody(input));
+    }
+    getSetBuilderFeeTx(input) {
+        return this.fetchApiTxObject("transactions/set-builder-fee", setBuilderFeeTxBody(input));
+    }
+    getPauseBuilderTx(input) {
+        return this.fetchApiTxObject("transactions/pause-builder", builderOwnerTxBody(input));
+    }
+    getResumeBuilderTx(input) {
+        return this.fetchApiTxObject("transactions/resume-builder", builderOwnerTxBody(input));
+    }
+    getTransferBuilderTx(input) {
+        return this.fetchApiTxObject("transactions/transfer-builder", transferBuilderTxBody(input));
+    }
+    getApproveBuilderTx(input) {
+        return this.fetchApiTxObject("transactions/approve-builder", approveBuilderTxBody(input));
+    }
+    getRevokeBuilderApprovalTx(input) {
+        return this.fetchApiTxObject("transactions/revoke-builder-approval", revokeBuilderApprovalTxBody(input));
+    }
+    getInstallTreasuryTx(input) {
+        return this.fetchApiTxObject("transactions/install-treasury", installTreasuryTxBody(input));
+    }
+    getAuthRegisterTx(input) {
+        return this.fetchApiTxObject("transactions/auth-register", authRegisterTxBody(input));
+    }
+    getGameAttachTx(input) {
+        return this.fetchApiTxObject("transactions/game-attach", authRegisterTxBody(input));
+    }
+    async sponsorTransaction(input, signal) {
+        const body = sponsorBody(input);
+        const data = await this.fetchApi("sponsor", PUBLIC_INTS.sponsored, body, signal);
+        for (const field of ["txBytesBase64", "sponsorSignature"]) {
+            if (typeof data?.[field] !== "string" || data[field].length === 0) {
+                throw new ParchmentApiError(0, "bad_tx", `sponsor response has no ${field}`);
+            }
+        }
+        return data;
+    }
+    getClaimDailyTx(input) {
+        return this.fetchApiTxObject("transactions/claim-daily", gameTxBody(input));
+    }
+    getOpenCrateTx(input) {
+        return this.fetchApiTxObject("transactions/open-crate", gameTxBody(input));
+    }
+    getOpenCratesTx(input) {
+        return this.fetchApiTxObject("transactions/open-crates", openCratesTxBody(input));
+    }
+    getClaimQuestTx(input) {
+        return this.fetchApiTxObject("transactions/claim-quest", claimQuestTxBody(input));
+    }
+    getCollectMintTx(input) {
+        return this.fetchApiTxObject("transactions/collect-mint", gameTxBody(input));
+    }
+}
+function mergeRequestOptions(config, options) {
+    const out = { ...config };
+    for (const key of ["timeoutMs", "signal"]) {
+        const value = options[key];
+        if (value === null)
+            delete out[key];
+        else if (value !== undefined)
+            out[key] = value;
+    }
+    return out;
+}
+function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            return resolve();
+        const timer = setTimeout(done, ms);
+        function done() {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", done);
+            resolve();
+        }
+        signal.addEventListener("abort", done, { once: true });
+    });
+}
+export function parseLivePrice(data) {
+    let value;
+    try {
+        value = JSON.parse(data);
+    }
+    catch {
+        throw new ParchmentApiError(0, "bad_body", "live price is not JSON");
+    }
+    const v = value;
+    if (!v || typeof v !== "object" || typeof v.marketId !== "string" || (v.symbol !== null && typeof v.symbol !== "string")) {
+        throw new ParchmentApiError(0, "bad_body", "live price needs marketId and symbol");
+    }
+    if (v.priceWad == null || v.timestampMs == null) {
+        throw new ParchmentApiError(0, "bad_body", "live price needs priceWad and timestampMs");
+    }
+    return decodeJsBigInts(v, PUBLIC_INTS.livePrice);
+}
+const TRADE_ACTIONS = ["open", "close", "liquidate"];
+const TRADE_SIDES = ["long", "short", null];
+export function parseTrade(data) {
+    let value;
+    try {
+        value = JSON.parse(data);
+    }
+    catch {
+        throw new ParchmentApiError(0, "bad_body", "trade is not JSON");
+    }
+    const v = value;
+    if (!v ||
+        typeof v !== "object" ||
+        !TRADE_ACTIONS.includes(v.action) ||
+        !TRADE_SIDES.includes(v.side) ||
+        typeof v.marketId !== "string" ||
+        typeof v.owner !== "string" ||
+        (v.symbol !== null && typeof v.symbol !== "string")) {
+        throw new ParchmentApiError(0, "bad_body", "trade needs action, side, marketId, owner and symbol");
+    }
+    if (v.id == null || v.positionId == null || v.notional == null || v.margin == null || v.timestampMs == null || v.pnl === undefined) {
+        throw new ParchmentApiError(0, "bad_body", "trade needs id, positionId, notional, margin, pnl and timestampMs");
+    }
+    return decodeJsBigInts(v, PUBLIC_INTS.trade);
+}
+const ORDER_KINDS = ["open", "close"];
+const ORDER_STATUSES = [
+    "pending",
+    "filled",
+    "liquidated",
+    "cancelled",
+    "expired",
+    "refunded",
+    "void",
+    "emergency_closed",
+    "unknown",
+];
+function isAddress(value) {
+    return typeof value === "string" && /^0x[0-9a-fA-F]{1,64}$/.test(value);
+}
+function checkedOrder(order, orderId) {
+    const v = order;
+    if (typeof v !== "object" || v === null || !isAddress(v.orderId) || normalizeAddress(v.orderId) !== orderId) {
+        throw new ParchmentApiError(0, "bad_body", `order response is not order ${orderId}`);
+    }
+    if (!isAddress(v.accountId) || !isAddress(v.owner) || !isAddress(v.marketId)) {
+        throw new ParchmentApiError(0, "bad_body", "order needs accountId, owner and marketId");
+    }
+    if (!ORDER_KINDS.includes(v.kind) || !ORDER_STATUSES.includes(v.status)) {
+        throw new ParchmentApiError(0, "bad_body", "order has no known kind or status");
+    }
+    return order;
+}