@parchment-trade/sdk 0.0.0-stage → 1.0.1

package/dist/packages/parchment/txBodies.js

@@ -0,0 +1,683 @@
+import { baseUnit, coinDigest, compact, normalizeAddress, signedUpdateBase64, u128Unit, u64Unit } from "../../general/utils/address.js";
+import { ParchmentApiError } from "../../general/utils/errors.js";
+import { toJsBigInt } from "../../general/utils/jsBigInt.js";
+function u64Wire(value, field, code) {
+    return toJsBigInt(BigInt(u64Unit(value, field, code)));
+}
+function bool(value, field) {
+    if (typeof value !== "boolean") {
+        throw new ParchmentApiError(0, "bad_request", `${field} must be a boolean`);
+    }
+    return value;
+}
+function coin(value) {
+    if (!value)
+        return undefined;
+    return {
+        objectId: normalizeAddress(value.objectId),
+        version: u64Wire(value.version, "coin.version", "bad_amount"),
+        digest: coinDigest(value.digest),
+    };
+}
+function shared(value) {
+    if (!value)
+        return undefined;
+    const out = {};
+    for (const [id, version] of Object.entries(value)) {
+        out[normalizeAddress(id)] = u64Wire(version, "shared version", "bad_amount");
+    }
+    return out;
+}
+function update(value) {
+    return signedUpdateBase64(value);
+}
+export function openPreviewBody(input) {
+    return {
+        marketId: normalizeAddress(input.marketId),
+        margin: u64Wire(input.margin, "margin"),
+        leverage: u64Wire(input.leverage, "leverage"),
+        isLong: bool(input.isLong, "isLong"),
+        ...compact({
+            accountId: input.accountId === undefined ? undefined : normalizeAddress(input.accountId),
+            minFactorBps: input.minFactorBps === undefined ? undefined : u64Wire(input.minFactorBps, "minFactorBps"),
+            slippageBps: previewSlippageBps(input.slippageBps),
+            acceptableEntryWad: optionalBound(input.acceptableEntryWad ?? input.acceptablePriceWad, "acceptableEntryWad"),
+            topUp: optionalBaseUnit(input.topUp, "topUp"),
+        }),
+    };
+}
+export function closePreviewBody(input) {
+    return compact({
+        positionId: u64Wire(input.positionId, "positionId", "bad_request"),
+        nowMs: input.nowMs === undefined ? undefined : u64Wire(input.nowMs, "nowMs", "bad_request"),
+        slippageBps: previewSlippageBps(input.slippageBps),
+        acceptableExitWad: optionalBound(input.acceptableExitWad ?? input.acceptablePriceWad, "acceptableExitWad"),
+        topUp: optionalBaseUnit(input.topUp, "topUp"),
+    });
+}
+export function openAccountTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        shared: shared(input.shared),
+    });
+}
+function objectDigest(value, field) {
+    if (value.length === 0 || value.length > 128 || !/^[0-9A-Za-z]+$/.test(value)) {
+        throw new ParchmentApiError(0, "bad_request", `${field} must be a base58 digest`);
+    }
+    return value;
+}
+function authorityDigest(value) {
+    return objectDigest(value, "authorityCapDigest");
+}
+const LONE_SURROGATE = /[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/;
+export function builderCode(value, lengthCode = "bad_request") {
+    const bytes = new TextEncoder().encode(value).length;
+    if (bytes < 1 || bytes > 32) {
+        throw new ParchmentApiError(0, lengthCode, "builderCode must be 1 to 32 bytes");
+    }
+    if (value.includes("\u0000") || LONE_SURROGATE.test(value)) {
+        throw new ParchmentApiError(0, lengthCode, "builderCode must be printable UTF-8 (no NUL, no lone surrogate)");
+    }
+    return value;
+}
+function capDigest(value) {
+    return objectDigest(value, "accountCapDigest");
+}
+function capRef(input) {
+    return {
+        accountCapId: normalizeAddress(input.accountCapId),
+        accountCapVersion: input.accountCapVersion === undefined ? undefined : u64Wire(input.accountCapVersion, "accountCapVersion", "bad_amount"),
+        accountCapDigest: input.accountCapDigest === undefined ? undefined : capDigest(input.accountCapDigest),
+    };
+}
+export function depositTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        coin: coin(input.coin),
+        shared: shared(input.shared),
+    });
+}
+export function withdrawTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        amount: u64Wire(input.amount, "amount", "bad_amount"),
+        shared: shared(input.shared),
+    });
+}
+function previewSlippageBps(value) {
+    if (value === undefined)
+        return undefined;
+    const bps = BigInt(baseUnit(value, "slippageBps"));
+    if (bps > 10000n) {
+        throw new ParchmentApiError(0, "bad_request", "slippageBps must be at most 10000 (100%)");
+    }
+    return toJsBigInt(bps);
+}
+function optionalBaseUnit(value, field) {
+    return value === undefined ? undefined : toJsBigInt(BigInt(baseUnit(value, field)));
+}
+function optionalBound(value, field) {
+    return value === undefined ? undefined : toJsBigInt(BigInt(u128Unit(value, field)));
+}
+export function requestOpenTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        marketId: normalizeAddress(input.marketId),
+        margin: u64Wire(input.margin, "margin", "bad_amount"),
+        leverage: u64Wire(input.leverage, "leverage", "bad_amount"),
+        isLong: bool(input.isLong, "isLong"),
+        minFactorBps: u64Wire(input.minFactorBps ?? 0n, "minFactorBps", "bad_amount"),
+        acceptablePriceWad: openBound(input.acceptablePriceWad),
+        ...builderRef(input),
+        topUp: coin(input.topUp),
+        shared: shared(input.shared),
+    });
+}
+export const DELEGATE_FILL_MARGIN_MS = 60000n;
+function liveMs(value, field) {
+    const text = typeof value === "number" ? (Number.isSafeInteger(value) && value >= 0 ? String(value) : "") : String(value).trim();
+    if (!/^[0-9]+$/.test(text) || BigInt(text) > 0xffffffffffffffffn) {
+        throw new ParchmentApiError(0, "bad_amount", `${field} must be a u64`);
+    }
+    return BigInt(text);
+}
+export function assertDelegateLiveThroughFill(delegation) {
+    const expiry = liveMs(delegation.expiryMs, "delegation.expiryMs");
+    const deadline = liveMs(delegation.fillDeadlineMs, "delegation.fillDeadlineMs");
+    const now = liveMs(delegation.nowMs ?? Date.now(), "delegation.nowMs");
+    if (expiry <= now + deadline + DELEGATE_FILL_MARGIN_MS) {
+        throw new ParchmentApiError(0, "delegate_expires_before_deadline", "The trading session expires before this order could fill; renew the session and try again");
+    }
+}
+export function requestOpenAsDelegateTxBody(input) {
+    if (input.delegation !== undefined)
+        assertDelegateLiveThroughFill(input.delegation);
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        marketId: normalizeAddress(input.marketId),
+        margin: u64Wire(input.margin, "margin", "bad_amount"),
+        leverage: u64Wire(input.leverage, "leverage", "bad_amount"),
+        isLong: bool(input.isLong, "isLong"),
+        minFactorBps: u64Wire(input.minFactorBps ?? 0n, "minFactorBps", "bad_amount"),
+        acceptablePriceWad: openBound(input.acceptablePriceWad),
+        ...builderRef(input),
+        shared: shared(input.shared),
+    });
+}
+function builderIdField(value) {
+    const text = typeof value === "bigint" ? value.toString() : typeof value === "string" ? value.trim() : "";
+    const hex = /^0[xX]([0-9a-fA-F]+)$/.exec(text);
+    const id = hex ? BigInt(`0x${hex[1]}`) : /^[0-9]+$/.test(text) ? BigInt(text) : null;
+    if (id === null || id > 0xffffffffn)
+        throw new ParchmentApiError(0, "bad_amount", "builderId must be a u32");
+    return toJsBigInt(id);
+}
+function noBuilder(value) {
+    return value === undefined || value === null || value === "";
+}
+function builderRef(input) {
+    const id = noBuilder(input.builderId) ? undefined : input.builderId;
+    const code = noBuilder(input.builderCode) ? undefined : input.builderCode;
+    if (id !== undefined && code !== undefined) {
+        throw new ParchmentApiError(0, "bad_request", "pass builderId or builderCode, not both");
+    }
+    return {
+        builderId: id === undefined ? undefined : builderIdField(id),
+        builderCode: code === undefined ? undefined : builderCode(code, "bad_code"),
+    };
+}
+function openBound(value) {
+    if (value === undefined || value === null || (typeof value === "string" && value.trim() === "")) {
+        throw new ParchmentApiError(0, "price_bound_required", "acceptablePriceWad is required for opens and must be non-zero");
+    }
+    const bound = BigInt(u128Unit(value, "acceptablePriceWad"));
+    if (bound === 0n)
+        throw new ParchmentApiError(0, "price_bound_required", "acceptablePriceWad is required for opens and must be non-zero");
+    return toJsBigInt(bound);
+}
+function closeBound(value) {
+    if (value === undefined || value === null || (typeof value === "string" && value.trim() === ""))
+        return undefined;
+    return toJsBigInt(BigInt(u128Unit(value, "acceptablePriceWad")));
+}
+export function requestCloseTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        marketId: normalizeAddress(input.marketId),
+        positionId: u64Wire(input.positionId, "positionId", "bad_amount"),
+        acceptablePriceWad: closeBound(input.acceptablePriceWad),
+        topUp: coin(input.topUp),
+        shared: shared(input.shared),
+    });
+}
+export function requestCloseAsDelegateTxBody(input) {
+    if (input.delegation !== undefined)
+        assertDelegateLiveThroughFill(input.delegation);
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        marketId: normalizeAddress(input.marketId),
+        positionId: u64Wire(input.positionId, "positionId", "bad_amount"),
+        acceptablePriceWad: closeBound(input.acceptablePriceWad),
+        shared: shared(input.shared),
+    });
+}
+export function cancelOrderTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        orderId: normalizeAddress(input.orderId),
+        shared: shared(input.shared),
+    });
+}
+export function orderRefTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        orderId: normalizeAddress(input.orderId),
+        shared: shared(input.shared),
+    });
+}
+export function expireOrderTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        orderId: normalizeAddress(input.orderId),
+        marketId: input.marketId === undefined ? undefined : normalizeAddress(input.marketId),
+        updateBase64: input.update === undefined ? undefined : update(input.update),
+        shared: shared(input.shared),
+    });
+}
+export function emergencyCloseTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        marketId: normalizeAddress(input.marketId),
+        orderId: normalizeAddress(input.orderId),
+        updateBase64: input.update === undefined ? undefined : update(input.update),
+        shared: shared(input.shared),
+    });
+}
+export function emergencyCloseAsDelegateTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        marketId: normalizeAddress(input.marketId),
+        orderId: normalizeAddress(input.orderId),
+        updateBase64: input.update === undefined ? undefined : update(input.update),
+        shared: shared(input.shared),
+    });
+}
+export function closeRetiredTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        marketId: normalizeAddress(input.marketId),
+        positionId: u64Wire(input.positionId, "positionId", "bad_amount"),
+        updateBase64: input.update === undefined ? undefined : update(input.update),
+        shared: shared(input.shared),
+    });
+}
+export function closeRetiredAsDelegateTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        marketId: normalizeAddress(input.marketId),
+        positionId: u64Wire(input.positionId, "positionId", "bad_amount"),
+        updateBase64: input.update === undefined ? undefined : update(input.update),
+        shared: shared(input.shared),
+    });
+}
+export function liquidateTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        marketId: normalizeAddress(input.marketId),
+        positionId: u64Wire(input.positionId, "positionId", "bad_amount"),
+        updateBase64: update(input.update),
+        shared: shared(input.shared),
+    });
+}
+const DEFAULT_SWEEP_BATCH = 8n;
+const MAX_SWEEP_BATCH = 8n;
+export function sweepBatch(value) {
+    const amount = BigInt(baseUnit(value ?? DEFAULT_SWEEP_BATCH, "maxEntries", "bad_amount"));
+    if (amount < 1n || amount > MAX_SWEEP_BATCH) {
+        throw new ParchmentApiError(0, "bad_amount", "maxEntries must be from 1 to 8");
+    }
+    return toJsBigInt(amount);
+}
+export function sweepTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        marketId: normalizeAddress(input.marketId),
+        maxEntries: sweepBatch(input.maxEntries),
+        updateBase64: update(input.update),
+        shared: shared(input.shared),
+    });
+}
+export function sweepSurplusTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        shared: shared(input.shared),
+    });
+}
+export function claimPendingMintTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        shared: shared(input.shared),
+    });
+}
+const DEFAULT_HARVEST_BATCH = 32n;
+const MAX_HARVEST_BATCH = 128n;
+export function harvestBatch(value) {
+    const text = baseUnit(value ?? DEFAULT_HARVEST_BATCH, "maxEntries", "bad_amount");
+    const amount = BigInt(text);
+    if (amount < 1n || amount > MAX_HARVEST_BATCH) {
+        throw new ParchmentApiError(0, "bad_amount", "maxEntries must be from 1 to 128");
+    }
+    return toJsBigInt(amount);
+}
+export function lpHarvestTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        maxEntries: harvestBatch(input.maxEntries),
+        shared: shared(input.shared),
+    });
+}
+const ZERO_ADDRESS = `0x${"0".repeat(64)}`;
+function referrerAddress(value) {
+    const referrer = normalizeAddress(value);
+    if (referrer === ZERO_ADDRESS) {
+        throw new ParchmentApiError(0, "zero_referrer", "referrer cannot be the zero address (0x0)");
+    }
+    return referrer;
+}
+export function bindReferrerTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        referrer: referrerAddress(input.referrer),
+        shared: shared(input.shared),
+    });
+}
+export function bindTradingReferrerTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        referrer: referrerAddress(input.referrer),
+        ...capRef(input),
+        shared: shared(input.shared),
+    });
+}
+export function transferAccountTxBody(input) {
+    const sender = normalizeAddress(input.walletAddress);
+    const recipient = normalizeAddress(input.recipient);
+    if (BigInt(recipient) === 0n) {
+        throw new ParchmentApiError(0, "zero_recipient", "recipient cannot be the zero address (0x0)");
+    }
+    if (recipient === sender) {
+        throw new ParchmentApiError(0, "self_transfer", "the account is already yours");
+    }
+    return compact({
+        sender,
+        accountId: normalizeAddress(input.accountId),
+        recipient,
+        ...capRef(input),
+        shared: shared(input.shared),
+    });
+}
+export function stakeTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        coin: coin(input.coin),
+        shared: shared(input.shared),
+    });
+}
+export function unstakeTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        amount: u64Wire(input.amount, "amount", "bad_amount"),
+        shared: shared(input.shared),
+    });
+}
+export function claimTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        shared: shared(input.shared),
+    });
+}
+export function releaseUnlockedTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        who: input.who === undefined ? undefined : normalizeAddress(input.who),
+        shared: shared(input.shared),
+    });
+}
+export function exitEarlyTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        shared: shared(input.shared),
+    });
+}
+export const MAX_LOCKED_ENTRIES = 244;
+export function exitEarlyBoundedTxBody(input) {
+    if (input.unlocks.length === 0 || input.unlocks.length > MAX_LOCKED_ENTRIES) {
+        throw new ParchmentApiError(0, "bad_request", `unlocks must list 1 to ${MAX_LOCKED_ENTRIES} entries`);
+    }
+    const unlocks = input.unlocks.map((u) => u64Wire(u, "unlocks[]", "bad_amount"));
+    if (new Set(unlocks).size !== unlocks.length)
+        throw new ParchmentApiError(0, "bad_request", "unlocks has a duplicate");
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        unlocks,
+        maxPenalty: u64Wire(input.maxPenalty, "maxPenalty", "bad_amount"),
+        shared: shared(input.shared),
+    });
+}
+export function grantCloseDelegateTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        shared: shared(input.shared),
+    });
+}
+export function grantSessionAndTriggerTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        sessionDelegate: normalizeAddress(input.sessionDelegate),
+        expiryMs: u64Wire(input.expiryMs, "expiryMs", "bad_amount"),
+        shared: shared(input.shared),
+    });
+}
+export function revokeSessionAndTriggerTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        sessionDelegate: normalizeAddress(input.sessionDelegate),
+        triggerDelegate: normalizeAddress(input.triggerDelegate),
+        shared: shared(input.shared),
+    });
+}
+export function grantDelegateTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        delegate: normalizeAddress(input.delegate),
+        expiryMs: u64Wire(input.expiryMs, "expiryMs", "bad_amount"),
+        shared: shared(input.shared),
+    });
+}
+export const BUILDER_FEE_HARD_BPS = 100n;
+export const MAX_BUILDER_CREATE_FEE = 100000000n;
+function builderFeeBps(value, field, min) {
+    const text = typeof value === "bigint" ? value.toString() : typeof value === "string" ? value.trim() : "";
+    const bps = /^[0-9]{1,3}$/.test(text) ? BigInt(text) : null;
+    if (bps === null || bps < min || bps > BUILDER_FEE_HARD_BPS) {
+        throw new ParchmentApiError(0, "bad_fee", `${field} must be from ${min} to ${BUILDER_FEE_HARD_BPS} bps`);
+    }
+    return toJsBigInt(bps);
+}
+function selfServeCode(value) {
+    if (typeof value !== "string" || !/^[a-z0-9_-]{3,32}$/.test(value)) {
+        throw new ParchmentApiError(0, "bad_code", "code must be 3 to 32 bytes of [a-z0-9_-]");
+    }
+    return value;
+}
+function authorityCapId(value) {
+    if (value === undefined || value === null) {
+        throw new ParchmentApiError(0, "authority_cap_required", "authorityCapId is required");
+    }
+    return normalizeAddress(value);
+}
+export function registerBuilderTxBody(input) {
+    const sender = normalizeAddress(input.walletAddress);
+    const code = builderCode(input.code, "bad_code");
+    const bps = builderFeeBps(input.feeBps, "feeBps", 0n);
+    const payout = normalizeAddress(input.payout);
+    const owner = normalizeAddress(input.owner);
+    return compact({
+        sender,
+        authorityCapId: authorityCapId(input.authorityCapId),
+        authorityCapVersion: input.authorityCapVersion === undefined ? undefined : u64Wire(input.authorityCapVersion, "authorityCapVersion", "bad_amount"),
+        authorityCapDigest: input.authorityCapDigest === undefined ? undefined : authorityDigest(input.authorityCapDigest),
+        code,
+        payout,
+        owner,
+        feeBps: bps,
+        shared: shared(input.shared),
+    });
+}
+export function setBuilderCreateFeeTxBody(input) {
+    const sender = normalizeAddress(input.walletAddress);
+    const amount = BigInt(u64Unit(input.amount, "amount", "bad_amount"));
+    if (amount > MAX_BUILDER_CREATE_FEE) {
+        throw new ParchmentApiError(0, "bad_amount", `amount must be at most ${MAX_BUILDER_CREATE_FEE} (100 USDC)`);
+    }
+    return compact({
+        sender,
+        amount: toJsBigInt(amount),
+        authorityCapId: authorityCapId(input.authorityCapId),
+        authorityCapVersion: input.authorityCapVersion === undefined ? undefined : u64Wire(input.authorityCapVersion, "authorityCapVersion", "bad_amount"),
+        authorityCapDigest: input.authorityCapDigest === undefined ? undefined : authorityDigest(input.authorityCapDigest),
+        shared: shared(input.shared),
+    });
+}
+export function installTreasuryTxBody(input) {
+    const sender = normalizeAddress(input.walletAddress);
+    const treasuryCap = coin(input.treasuryCap);
+    return compact({
+        sender,
+        authorityCapId: authorityCapId(input.authorityCapId),
+        authorityCapVersion: input.authorityCapVersion === undefined ? undefined : u64Wire(input.authorityCapVersion, "authorityCapVersion", "bad_amount"),
+        authorityCapDigest: input.authorityCapDigest === undefined ? undefined : authorityDigest(input.authorityCapDigest),
+        treasuryCap,
+        shared: shared(input.shared),
+    });
+}
+export function authRegisterTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        authorityCapId: authorityCapId(input.authorityCapId),
+        authorityCapVersion: input.authorityCapVersion === undefined ? undefined : u64Wire(input.authorityCapVersion, "authorityCapVersion", "bad_amount"),
+        authorityCapDigest: input.authorityCapDigest === undefined ? undefined : authorityDigest(input.authorityCapDigest),
+        shared: shared(input.shared),
+    });
+}
+export function setBuilderPayoutTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        builderId: builderIdField(input.builderId),
+        newPayout: normalizeAddress(input.newPayout),
+        shared: shared(input.shared),
+    });
+}
+export function createBuilderTxBody(input) {
+    const sender = normalizeAddress(input.walletAddress);
+    const code = selfServeCode(input.code);
+    const payout = normalizeAddress(input.payout);
+    const feeBps = builderFeeBps(input.feeBps, "feeBps", 0n);
+    if (!input.coin)
+        throw new ParchmentApiError(0, "coin_required", "a USDC coin covering the creation fee is required");
+    return compact({ sender, code, payout, feeBps, coin: coin(input.coin), shared: shared(input.shared) });
+}
+export function setBuilderFeeTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        builderId: builderIdField(input.builderId),
+        feeBps: builderFeeBps(input.feeBps, "feeBps", 0n),
+        shared: shared(input.shared),
+    });
+}
+export function builderOwnerTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        builderId: builderIdField(input.builderId),
+        shared: shared(input.shared),
+    });
+}
+export function transferBuilderTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        builderId: builderIdField(input.builderId),
+        newOwner: normalizeAddress(input.newOwner),
+        shared: shared(input.shared),
+    });
+}
+export function approveBuilderTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        builderId: builderIdField(input.builderId),
+        maxFeeBps: builderFeeBps(input.maxFeeBps, "maxFeeBps", 1n),
+        shared: shared(input.shared),
+    });
+}
+export function revokeBuilderApprovalTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        builderId: builderIdField(input.builderId),
+        shared: shared(input.shared),
+    });
+}
+export function gameTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        shared: shared(input.shared),
+    });
+}
+function questIdField(value) {
+    const text = typeof value === "bigint" ? value.toString() : typeof value === "string" ? value.trim() : "";
+    if (text.length === 0)
+        throw new ParchmentApiError(0, "quest_required", "questId is required");
+    if (!/^[0-9]{1,3}$/.test(text) || Number(text) > 255) {
+        throw new ParchmentApiError(0, "bad_quest", "questId must be a u8");
+    }
+    return toJsBigInt(BigInt(text));
+}
+export function claimQuestTxBody(input) {
+    return compact({
+        ...gameTxBody(input),
+        questId: questIdField(input.questId),
+    });
+}
+const U64_MAX = (1n << 64n) - 1n;
+function crateCountField(value) {
+    if (value === undefined || value === null || (typeof value === "string" && value.trim().length === 0)) {
+        throw new ParchmentApiError(0, "count_required", "count is required");
+    }
+    const bad = () => new ParchmentApiError(0, "bad_count", "count must be an integer from 1 to 2^64 - 1");
+    let count;
+    if (typeof value === "bigint")
+        count = value;
+    else if (typeof value === "number") {
+        if (!Number.isSafeInteger(value))
+            throw bad();
+        count = BigInt(value);
+    }
+    else if (typeof value === "string" && /^[0-9]+$/.test(value.trim()))
+        count = BigInt(value.trim());
+    else
+        throw bad();
+    if (count < 1n || count > U64_MAX)
+        throw bad();
+    return toJsBigInt(count);
+}
+export function openCratesTxBody(input) {
+    return compact({
+        ...gameTxBody(input),
+        count: crateCountField(input.count),
+    });
+}
+export function revokeDelegateTxBody(input) {
+    return compact({
+        sender: normalizeAddress(input.walletAddress),
+        accountId: normalizeAddress(input.accountId),
+        ...capRef(input),
+        delegate: normalizeAddress(input.delegate),
+        shared: shared(input.shared),
+    });
+}