@parchment-trade/sdk 0.0.0-stage → 1.0.1

package/dist/packages/parchment/batchClose.js

@@ -0,0 +1,524 @@
+import { coinWithBalance, Inputs, Transaction } from "@mysten/sui/transactions";
+import { fromBase64, normalizeSuiAddress } from "@mysten/sui/utils";
+import { serviceTxViolation } from "../../general/utils/txShape.js";
+import { UNCHECKED_TX, txIntentViolation, updateArgBase64 } from "./txIntent.js";
+export const SUI_TX_LIMITS = {
+    commands: 1024,
+    txBytes: 128 * 1024,
+    events: 1024,
+    newObjectIds: 2048,
+    argumentsPerCommand: 512,
+};
+export const CLOSE_BATCH_BUDGET = {
+    commands: SUI_TX_LIMITS.commands,
+    txBytes: 96 * 1024,
+    events: 768,
+    newObjectIds: 1536,
+    argumentsPerCommand: SUI_TX_LIMITS.argumentsPerCommand,
+};
+export const SPONSOR_BATCH_BUDGET = {
+    trades: 32,
+    inputs: 64,
+    inputsPerTrade: 7,
+    oneTradeCommands: 8,
+    retiredTrades: 24,
+    retiredCommandsPerTrade: 6,
+    retiredInputsPerTrade: 16,
+};
+const LEG_EXECUTION = {
+    request: { events: 1, fundedEvents: 1, newObjectIds: 2 },
+    retired: { events: 26 + 2 + 1, newObjectIds: 3 },
+};
+export const GAME_REGISTRY_MAXIMA = {
+    achievements: 128,
+    quests: 128,
+    cosmetics: 128,
+    tierThresholds: 32,
+};
+export function gameEventLimitsFromDefinitions(definitions, config = {}) {
+    return {
+        achievements: definitions.achievements.length,
+        quests: definitions.quests.length,
+        cosmetics: definitions.cosmetics.length,
+        tierThresholds: config.tierThresholds ?? GAME_REGISTRY_MAXIMA.tierThresholds,
+    };
+}
+export function playerProgressionEvents(limits = GAME_REGISTRY_MAXIMA) {
+    const n = (key) => {
+        const value = limits[key];
+        if (!Number.isSafeInteger(value) || value < 0)
+            throw new BatchCloseError(`gameLimits.${key} must be a non-negative integer`);
+        return Math.min(value, GAME_REGISTRY_MAXIMA[key]);
+    };
+    const achievements = n("achievements");
+    const quests = n("quests");
+    return 3 * achievements + 2 * quests + Math.min(n("cosmetics"), achievements + quests) + n("tierThresholds") + achievements + quests + 1;
+}
+const REQUEST_CLOSE_TOP_UP_ARG = 7;
+const SUI_FRAMEWORK = normalizeSuiAddress("0x2");
+export class BatchCloseError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "BatchCloseError";
+    }
+}
+export function closeBatchTopUps(execFees, free) {
+    if (execFees.some((fee) => fee < 0n))
+        throw new BatchCloseError("an exec fee cannot be negative");
+    let available = free > 0n ? free : 0n;
+    return execFees.map((fee) => {
+        const topUp = fee > available ? fee - available : 0n;
+        available += topUp - fee;
+        return topUp;
+    });
+}
+export function batchCloseTx(legs, options) {
+    return assemble(legs, options, false);
+}
+export async function fitCloseBatch(legs, options) {
+    if (legs.length === 0)
+        throw new BatchCloseError("Nothing to close");
+    checkMaxTrades(options.maxTrades);
+    const funded = (count) => legs.slice(0, count).some((leg) => leg.topUp !== undefined && leg.topUp > 0n);
+    if (options.sponsored && funded(legs.length))
+        throw new BatchCloseError("A sponsored close takes no top-up");
+    if (funded(legs.length) && !options.client)
+        throw new BatchCloseError("Funding the close fees needs a Sui client");
+    const estimated = await longestFit(legs.length, async (count) => {
+        const usage = await closeBatchUsage(legs.slice(0, count), options);
+        return withinBudget(usage, options.sponsored, options.maxTrades) ? { tx: null, usage } : null;
+    });
+    if (!funded(estimated.count))
+        return { tx: batchCloseTx(legs.slice(0, estimated.count), options), count: estimated.count, usage: estimated.usage };
+    const client = largestCoinsFirst(options.client);
+    const resolved = await longestFit(estimated.count, async (count) => {
+        const fit = await resolvedBatch(legs.slice(0, count), { ...options, client });
+        return withinBudget(fit.usage, false) ? fit : null;
+    });
+    return { tx: resolved.tx, count: resolved.count, usage: resolved.usage };
+}
+async function longestFit(max, measure) {
+    const whole = await measure(max);
+    if (whole)
+        return { ...whole, count: max };
+    let lo = 0;
+    let hi = max;
+    let best = null;
+    while (hi - lo > 1) {
+        const mid = Math.floor((lo + hi) / 2);
+        const fits = await measure(mid);
+        if (fits) {
+            lo = mid;
+            best = fits;
+        }
+        else
+            hi = mid;
+    }
+    if (lo === 0 || !best)
+        throw new BatchCloseError("A close does not fit in one transaction");
+    return { ...best, count: lo };
+}
+export async function splitCloseBatches(legs, options) {
+    if (legs.length === 0)
+        throw new BatchCloseError("Nothing to close");
+    const batches = [];
+    for (let start = 0; start < legs.length;) {
+        if (start > 0 && legs.slice(start).some((leg) => leg.topUp !== undefined && leg.topUp > 0n)) {
+            throw new BatchCloseError("A later batch tops up from the wallet: fit it with fitCloseBatch after the previous transaction confirms");
+        }
+        const fit = await fitCloseBatch(legs.slice(start), options);
+        batches.push({ ...fit, start });
+        start += fit.count;
+    }
+    return batches;
+}
+const PLAN_LEG_COMMANDS = { request: 2, sponsoredRequest: 1, retired: 6 };
+export function planCloseBatches(legs, options = {}) {
+    checkMaxTrades(options.maxTrades);
+    const commandsOf = (leg) => leg.retired ? PLAN_LEG_COMMANDS.retired : options.sponsored ? PLAN_LEG_COMMANDS.sponsoredRequest : PLAN_LEG_COMMANDS.request + (leg.funded ? 1 : 0);
+    const fits = (group) => {
+        const execution = executionOf(group, options.gameLimits);
+        const commands = group.reduce((n, leg) => n + commandsOf(leg), 0);
+        const retired = group.filter((leg) => leg.retired).length;
+        const usage = { ...execution, commands, trades: group.length, retired, inputs: 0 };
+        if (commands > CLOSE_BATCH_BUDGET.commands || execution.newObjectIds > CLOSE_BATCH_BUDGET.newObjectIds || !eventsFit(usage))
+            return false;
+        return !options.sponsored || sponsorTakes(usage, options.maxTrades);
+    };
+    const batches = [];
+    let current = [];
+    legs.forEach((leg, i) => {
+        if (current.length > 0 && fits([...current, i].map((j) => legs[j]))) {
+            current.push(i);
+            return;
+        }
+        if (current.length > 0)
+            batches.push(current);
+        if (!fits([leg]))
+            throw new BatchCloseError("A close does not fit in one transaction");
+        current = [i];
+    });
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
+function checkMaxTrades(maxTrades) {
+    if (maxTrades !== undefined && (!Number.isSafeInteger(maxTrades) || maxTrades < 1))
+        throw new BatchCloseError("maxTrades must be a positive integer");
+}
+export async function closeBatchUsage(legs, options) {
+    const tx = assemble(legs, options, true);
+    const coinCommands = legs.some((leg) => leg.topUp !== undefined && leg.topUp > 0n) ? COIN_RESOLUTION_COMMANDS : 0;
+    return measure(tx, legs, coinCommands, options.gameLimits);
+}
+async function resolvedBatch(legs, options) {
+    const tx = assemble(legs, options, false);
+    await tx.prepareForSerialization({ client: options.client });
+    return { tx, usage: await measure(tx, legs, 0, options.gameLimits) };
+}
+async function measure(tx, legs, extraCommands, gameLimits) {
+    const commands = tx.getData().commands;
+    const argumentsPerCommand = commands.reduce((max, c) => Math.max(max, commandArguments(c)), 0);
+    const bytes = await tx.build({ onlyTransactionKind: true });
+    const kinds = legs.map((leg) => {
+        const retired = !legIsRequest(leg.tx);
+        return { retired, account: retired ? (retiredAccount(leg.tx) ?? undefined) : undefined, funded: leg.topUp !== undefined && leg.topUp > 0n };
+    });
+    const execution = executionOf(kinds, gameLimits);
+    return {
+        commands: commands.length + extraCommands,
+        txBytes: bytes.length,
+        argumentsPerCommand,
+        inputs: tx.getData().inputs.length,
+        trades: legs.length,
+        retired: kinds.filter((k) => k.retired).length,
+        ...execution,
+    };
+}
+function executionOf(legs, gameLimits) {
+    const players = new Set();
+    let events = 0;
+    let newObjectIds = 0;
+    legs.forEach((leg, i) => {
+        if (leg.retired) {
+            players.add(leg.account ? normalizeSuiAddress(leg.account) : `leg ${i}`);
+            events += LEG_EXECUTION.retired.events;
+            newObjectIds += LEG_EXECUTION.retired.newObjectIds;
+        }
+        else {
+            events += LEG_EXECUTION.request.events + (leg.funded ? LEG_EXECUTION.request.fundedEvents : 0);
+            newObjectIds += LEG_EXECUTION.request.newObjectIds;
+        }
+    });
+    const progressionEvents = players.size * playerProgressionEvents(gameLimits);
+    return { events: events + progressionEvents, progressionEvents, newObjectIds };
+}
+const RETIRED_ACCOUNT_ARG = 2;
+const RETIRED_CLOSE_FUNCTIONS = new Set(["close_retired", "close_retired_as_delegate"]);
+function retiredAccount(source) {
+    const data = source.getData();
+    const commands = data.commands;
+    const inputs = data.inputs;
+    for (const c of commands) {
+        if (c.$kind !== "MoveCall")
+            continue;
+        const call = c.MoveCall;
+        if (call.module !== "trade" || !RETIRED_CLOSE_FUNCTIONS.has(call.function))
+            continue;
+        const arg = call.arguments[RETIRED_ACCOUNT_ARG];
+        const input = arg?.$kind === "Input" && arg.Input !== undefined ? inputs[arg.Input] : undefined;
+        const id = input?.Object?.SharedObject?.objectId ?? input?.Object?.ImmOrOwnedObject?.objectId ?? input?.UnresolvedObject?.objectId;
+        return id ? normalizeSuiAddress(id) : null;
+    }
+    return null;
+}
+function largestCoinsFirst(client) {
+    const core = client.core;
+    if (!core || typeof core.listCoins !== "function" || typeof core.getBalance !== "function")
+        return client;
+    const reads = core;
+    const coins = new Map();
+    const balances = new Map();
+    const allCoins = async (owner, coinType) => {
+        const all = [];
+        let cursor = null;
+        do {
+            const page = await reads.listCoins({ owner, coinType, cursor });
+            all.push(...page.objects);
+            cursor = page.hasNextPage ? page.cursor : null;
+        } while (cursor);
+        return all.sort((a, b) => (BigInt(b.balance) > BigInt(a.balance) ? 1 : BigInt(b.balance) < BigInt(a.balance) ? -1 : 0));
+    };
+    const listCoins = async ({ owner, coinType, cursor }) => {
+        const key = `${owner}:${coinType ?? ""}`;
+        if (!coins.has(key))
+            coins.set(key, allCoins(owner, coinType));
+        const sorted = await coins.get(key);
+        const at = cursor ? Number(cursor) : 0;
+        return { objects: sorted.slice(at, at + 1), hasNextPage: at + 1 < sorted.length, cursor: String(at + 1) };
+    };
+    const getBalance = (input) => {
+        const key = `${input.owner}:${input.coinType ?? ""}`;
+        if (!balances.has(key))
+            balances.set(key, reads.getBalance(input));
+        return balances.get(key);
+    };
+    const proxy = new Proxy(core, {
+        get(target, prop) {
+            if (prop === "listCoins")
+                return listCoins;
+            if (prop === "getBalance")
+                return getBalance;
+            const value = Reflect.get(target, prop, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+    return { core: proxy };
+}
+function withinBudget(usage, sponsored, maxTrades) {
+    const fits = (budget) => Object.keys(budget).every((k) => k === "events" || usage[k] <= budget[k]);
+    return fits(CLOSE_BATCH_BUDGET) && eventsFit(usage) && (!sponsored || sponsorTakes(usage, maxTrades));
+}
+function sponsorTakes(usage, maxTrades = SPONSOR_BATCH_BUDGET.trades) {
+    if (usage.retired > 0) {
+        const b = SPONSOR_BATCH_BUDGET;
+        return (usage.retired === usage.trades &&
+            usage.trades <= Math.min(maxTrades, b.retiredTrades) &&
+            usage.commands <= Math.max(b.oneTradeCommands, b.retiredCommandsPerTrade * usage.trades) &&
+            usage.inputs <= Math.max(b.inputs, b.retiredInputsPerTrade * usage.trades));
+    }
+    return (usage.trades <= maxTrades &&
+        usage.commands <= usage.trades &&
+        usage.inputs <= Math.max(SPONSOR_BATCH_BUDGET.inputs, SPONSOR_BATCH_BUDGET.inputsPerTrade * usage.trades));
+}
+function eventsFit(usage) {
+    const room = SUI_TX_LIMITS.events - usage.progressionEvents;
+    return room > 0 && (usage.events - usage.progressionEvents) * SUI_TX_LIMITS.events <= CLOSE_BATCH_BUDGET.events * room;
+}
+function commandArguments(c) {
+    switch (c.$kind) {
+        case "MoveCall":
+            return c.MoveCall.arguments.length;
+        case "SplitCoins":
+            return 1 + c.SplitCoins.amounts.length;
+        case "MergeCoins":
+            return 1 + c.MergeCoins.sources.length;
+        case "TransferObjects":
+            return 1 + c.TransferObjects.objects.length;
+        default:
+            return 0;
+    }
+}
+export function legIsRequest(source) {
+    const commands = source.getData().commands;
+    return commands.some((c) => c.$kind === "MoveCall" && REQUEST_CLOSE_FUNCTIONS.has(c.MoveCall.function));
+}
+const REQUEST_CLOSE_FUNCTIONS = new Set(["request_close", "request_close_as_delegate"]);
+const COIN_RESOLUTION_COMMANDS = 2;
+const PLACEHOLDER_COIN = Inputs.ObjectRef({ objectId: normalizeSuiAddress("0x0"), version: "0", digest: "11111111111111111111111111111111" });
+const CLOSE_LEG_ROUTES = new Set(["request-close", "request-close-as-delegate", "close-retired", "close-retired-as-delegate"]);
+function checkLeg(leg, index, sender, trust) {
+    const request = leg.request;
+    if (!request)
+        throw new BatchCloseError(`Close ${index + 1} has no request to check it against (pass ParchmentBuiltTx.request)`);
+    if (!CLOSE_LEG_ROUTES.has(request.route))
+        throw new BatchCloseError(`Close ${index + 1} is a ${request.route}, not a close`);
+    if (typeof request.body.sender !== "string" || normalizeSuiAddress(request.body.sender) !== normalizeSuiAddress(sender)) {
+        throw new BatchCloseError(`Close ${index + 1} was built for another sender`);
+    }
+    const violation = txIntentViolation(request.route, leg.tx, request.body, sender, trust);
+    if (violation !== null)
+        throw new BatchCloseError(`Close ${index + 1} does not match its request: ${violation}`);
+}
+const PUSH_STORAGE_ARG = 2;
+const PUSH_FEED_INFO_ARG = 3;
+const PUSH_UPDATE_ARG = 5;
+function updatesOf(tx) {
+    const data = tx.getData();
+    return data.commands.flatMap((command) => {
+        const c = command.$kind === "MoveCall" ? command.MoveCall : undefined;
+        const at = c?.module === "adapter" && c.function === "quote" ? QUOTE_UPDATE_ARG : c?.module === "price_feed_storage" && c.function === "update_price_feed" ? PUSH_UPDATE_ARG : -1;
+        if (at === -1)
+            return [];
+        const update = c.arguments[at];
+        return [update?.$kind === "Input" ? (data.inputs[update.Input ?? -1]?.Pure?.bytes ?? null) : null];
+    });
+}
+function checkBatchUpdates(tx, legs) {
+    const carried = new Set(legs.flatMap((leg) => updatesOf(leg.tx)).filter((u) => u !== null));
+    if (updatesOf(tx).some((u) => u === null || !carried.has(u)))
+        throw new BatchCloseError("The batch prices a close with an update no close carried");
+}
+function assemble(legs, { sender, coinType, txTrust = UNCHECKED_TX, sponsored }, measuring) {
+    if (legs.length === 0)
+        throw new BatchCloseError("Nothing to close");
+    if (txTrust !== UNCHECKED_TX && (typeof txTrust !== "object" || txTrust === null)) {
+        throw new BatchCloseError('txTrust is "unchecked" or { packages }');
+    }
+    const trust = txTrust === UNCHECKED_TX ? null : txTrust;
+    const topUps = legs.map((leg) => (leg.topUp !== undefined && leg.topUp > 0n ? leg.topUp : 0n));
+    const total = topUps.reduce((a, b) => a + b, 0n);
+    const tx = new Transaction();
+    tx.setSender(sender);
+    const coins = topUps.map(() => null);
+    if (total > 0n) {
+        if (!coinType)
+            throw new BatchCloseError("A top-up needs the collateral coin type");
+        const coin = measuring ? tx.object(PLACEHOLDER_COIN) : tx.add(coinWithBalance({ type: coinType, balance: total }));
+        const funded = topUps.flatMap((amount, i) => (amount > 0n ? [i] : []));
+        const parts = funded.length > 1 ? tx.splitCoins(coin, funded.slice(0, -1).map((i) => topUps[i])) : null;
+        funded.forEach((legIndex, k) => {
+            coins[legIndex] = k < funded.length - 1 ? parts[k] : coin;
+        });
+    }
+    const pinnedUpdates = new Map();
+    const pushed = sponsored ? new Set() : null;
+    legs.forEach((leg, i) => {
+        const violation = serviceTxViolation(leg.tx, sender);
+        if (violation !== null)
+            throw new BatchCloseError(`A close has a ${violation}`);
+        if (trust)
+            checkLeg(leg, i, sender, trust);
+        const named = trust ? updateArgBase64(leg.request?.body.updateBase64) : null;
+        appendLeg(tx, leg.tx, coins[i] ?? null, pinnedUpdates, named, pushed);
+    });
+    if (trust)
+        checkBatchUpdates(tx, legs);
+    return tx;
+}
+const QUOTE_UPDATE_ARG = 2;
+function appendLeg(tx, source, topUp, pinnedUpdates, namedUpdate, pushed) {
+    const data = source.getData();
+    let skipCommand = -1;
+    if (topUp) {
+        const calls = data.commands.flatMap((c, i) => (c.$kind === "MoveCall" && c.MoveCall.function === "request_close" ? [i] : []));
+        if (calls.length !== 1)
+            throw new BatchCloseError("A top-up needs exactly one request_close in its leg");
+        const arg = data.commands[calls[0]].MoveCall.arguments[REQUEST_CLOSE_TOP_UP_ARG];
+        const producer = arg?.$kind === "Result" ? data.commands[arg.Result ?? -1] : undefined;
+        const zero = producer?.$kind === "MoveCall" ? producer.MoveCall : undefined;
+        if (!zero || normalizeSuiAddress(zero.package) !== SUI_FRAMEWORK || zero.module !== "coin" || zero.function !== "zero") {
+            throw new BatchCloseError("The request's top-up is not the service's zero coin");
+        }
+        skipCommand = arg.Result;
+    }
+    const updateFeeds = new Map();
+    for (const command of data.commands) {
+        const c = command.$kind === "MoveCall" ? command.MoveCall : undefined;
+        if (!c || c.module !== "adapter" || c.function !== "quote")
+            continue;
+        const [storage, update, sourceId, feedId] = [c.arguments[1], c.arguments[QUOTE_UPDATE_ARG], c.arguments[4], c.arguments[5]];
+        const storageInput = storage?.$kind === "Input" ? data.inputs[storage.Input ?? -1] : undefined;
+        const storageId = storageInput?.Object?.SharedObject?.objectId ?? storageInput?.Object?.ImmOrOwnedObject?.objectId ?? storageInput?.UnresolvedObject?.objectId;
+        const pure = (a) => (a?.$kind === "Input" ? data.inputs[a.Input ?? -1]?.Pure?.bytes : undefined);
+        if (update?.$kind !== "Input" || pure(update) === undefined || !storageId)
+            throw new BatchCloseError("Malformed oracle quote in a close");
+        updateFeeds.set(update.Input, `${normalizeSuiAddress(storageId)}:${pure(sourceId) ?? ""}:${pure(feedId) ?? ""}`);
+    }
+    const inputs = data.inputs.map((input, index) => {
+        const feed = updateFeeds.get(index);
+        const pinned = feed !== undefined ? pinnedUpdates.get(feed) : undefined;
+        if (pinned) {
+            if (namedUpdate !== null && pinned.bytes !== namedUpdate) {
+                throw new BatchCloseError("A close names a signed update another close's update for the same feed would replace; build them with one update");
+            }
+            return pinned.arg;
+        }
+        if (input.$kind === "Pure" && input.Pure) {
+            const pure = tx.pure(fromBase64(input.Pure.bytes));
+            if (feed !== undefined)
+                pinnedUpdates.set(feed, { arg: pure, bytes: input.Pure.bytes });
+            return pure;
+        }
+        const obj = input.Object;
+        if (input.$kind === "Object" && obj) {
+            if (obj.SharedObject)
+                return tx.object(Inputs.SharedObjectRef(obj.SharedObject));
+            if (obj.ImmOrOwnedObject)
+                return tx.object(Inputs.ObjectRef({ ...obj.ImmOrOwnedObject, version: String(obj.ImmOrOwnedObject.version) }));
+            if (obj.Receiving)
+                return tx.object(Inputs.ReceivingRef({ ...obj.Receiving, version: String(obj.Receiving.version) }));
+        }
+        if (input.$kind === "UnresolvedObject" && input.UnresolvedObject)
+            return tx.object(input.UnresolvedObject.objectId);
+        throw new BatchCloseError(`Unsupported transaction input ${input.$kind}`);
+    });
+    const results = [];
+    const arg = (a) => {
+        switch (a.$kind) {
+            case "Input":
+                return inputs[a.Input ?? -1] ?? malformed(`input ${a.Input}`);
+            case "Result":
+                return results[a.Result ?? -1] ?? malformed(`result ${a.Result}`);
+            case "NestedResult": {
+                const [r, n] = a.NestedResult ?? [-1, -1];
+                const result = results[r];
+                return result?.[n] ?? malformed(`result ${r}`);
+            }
+            case "GasCoin":
+                return tx.gas;
+            default:
+                return malformed(`argument ${a.$kind}`);
+        }
+    };
+    const objectId = (a) => {
+        const input = a?.$kind === "Input" ? data.inputs[a.Input ?? -1] : undefined;
+        const id = input?.Object?.SharedObject?.objectId ?? input?.Object?.ImmOrOwnedObject?.objectId ?? input?.UnresolvedObject?.objectId;
+        return id ? normalizeSuiAddress(id) : null;
+    };
+    const repeatedPush = (c) => {
+        if (!pushed || c.module !== "price_feed_storage" || c.function !== "update_price_feed")
+            return false;
+        const [storage, info, update] = [objectId(c.arguments[PUSH_STORAGE_ARG]), objectId(c.arguments[PUSH_FEED_INFO_ARG]), c.arguments[PUSH_UPDATE_ARG]];
+        if (!storage || !info || update?.$kind !== "Input")
+            return false;
+        const feed = updateFeeds.get(update.Input);
+        const bytes = (feed !== undefined ? pinnedUpdates.get(feed)?.bytes : undefined) ?? data.inputs[update.Input]?.Pure?.bytes;
+        if (bytes === undefined)
+            return false;
+        const key = `${storage}:${info}:${bytes}`;
+        if (pushed.has(key))
+            return true;
+        pushed.add(key);
+        return false;
+    };
+    data.commands.forEach((command, index) => {
+        if (index === skipCommand) {
+            results.push(topUp);
+            return;
+        }
+        if (command.$kind === "MoveCall" && repeatedPush(command.MoveCall)) {
+            results.push(undefined);
+            return;
+        }
+        switch (command.$kind) {
+            case "MoveCall": {
+                const c = command.MoveCall;
+                results.push(tx.moveCall({ target: `${c.package}::${c.module}::${c.function}`, typeArguments: c.typeArguments, arguments: c.arguments.map(arg) }));
+                break;
+            }
+            case "SplitCoins": {
+                const c = command.SplitCoins;
+                results.push(tx.splitCoins(arg(c.coin), c.amounts.map(arg)));
+                break;
+            }
+            case "MergeCoins": {
+                const c = command.MergeCoins;
+                tx.mergeCoins(arg(c.destination), c.sources.map((s) => arg(s)));
+                results.push(undefined);
+                break;
+            }
+            case "TransferObjects": {
+                const c = command.TransferObjects;
+                tx.transferObjects(c.objects.map((o) => arg(o)), arg(c.address));
+                results.push(undefined);
+                break;
+            }
+            default:
+                throw new BatchCloseError(`Unsupported transaction command ${command.$kind}`);
+        }
+    });
+}
+function malformed(what) {
+    throw new BatchCloseError(`Malformed close transaction (${what})`);
+}

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

@@ -0,0 +1,106 @@
+import type { Transaction, TransactionArgument, TransactionObjectArgument } from "@mysten/sui/transactions";
+/** `event_guard` reason codes (`u8`); any other value aborts `EBadReason` (0). */
+export declare const EVENT_REASON: {
+    readonly dividend: 0;
+    readonly earnings: 1;
+    readonly macro: 2;
+    readonly other: 3;
+};
+export type EventReason = keyof typeof EVENT_REASON;
+/** `event_guard::max_window_ms()`: an event pause or cap ends at most 24 h after the call that sets it. */
+export declare const EVENT_GUARD_MAX_WINDOW_MS = 86400000;
+type ObjectInput = string | TransactionObjectArgument;
+type U64 = number | bigint | string;
+interface EventGuardTarget {
+    /** Latest `parchment_trade` package id (call target). */
+    tradePackageId: string;
+    /** Collateral coin type `C`. */
+    coinType: string;
+    exchange: ObjectInput;
+    market: ObjectInput;
+    config: ObjectInput;
+}
+export interface EventKeeperCall extends EventGuardTarget {
+    /** `parchment::authority::AuthorityCap<PACKAGE, MARKET_KEEPER>` (`config::grant_market_keeper`). */
+    keeperCap: ObjectInput;
+}
+export interface SetEventPauseCall extends EventKeeperCall {
+    reason: EventReason | number;
+    /** Clock ms the pause lapses at: after now and at most {@link EVENT_GUARD_MAX_WINDOW_MS} from now (`EBadWindow` 1). */
+    untilMs: U64;
+}
+/**
+ * Keeper `event_guard::set_event_pause<C>(exchange, market, config, cap, reason, until_ms, clock)`: blocks NEW opens
+ * on the market until `untilMs` (requests abort `EEventPaused` 3, pending open fills refund REFUND_PAUSED). Separate
+ * from the admin `opens_paused` flag. Emits `EventPauseUpdatedEventV1`.
+ */
+export declare function addSetEventPauseCall(tx: Transaction, input: SetEventPauseCall): void;
+/** Keeper `event_guard::clear_event_pause<C>(exchange, market, config, cap)`. Never lifts the admin `opens_paused`. */
+export declare function addClearEventPauseCall(tx: Transaction, input: EventKeeperCall): void;
+export interface SetEventLeverageCapCall extends SetEventPauseCall {
+    /** Within the market's `min_leverage..=max_leverage` (`EBadLeverageCap` 2): tighten-only. */
+    maxLeverage: U64;
+}
+/**
+ * Keeper `event_guard::set_event_leverage_cap<C>(exchange, market, config, cap, max_leverage, reason, until_ms, clock)`:
+ * caps the leverage of NEW opens until `untilMs` (requests above it abort `EEventLeverage` 4, pending fills above it
+ * refund REFUND_RISK). Emits `EventLeverageCapUpdatedEventV1`.
+ */
+export declare function addSetEventLeverageCapCall(tx: Transaction, input: SetEventLeverageCapCall): void;
+/** Keeper `event_guard::clear_event_leverage_cap<C>(exchange, market, config, cap)`. */
+export declare function addClearEventLeverageCapCall(tx: Transaction, input: EventKeeperCall): void;
+export interface ArmEventCloseCall extends EventKeeperCall {
+    /** `oracle::PriceReceipt` from `oracle::begin_price` earlier in the same PTB: this market, open session. */
+    receipt: TransactionArgument;
+}
+/**
+ * Keeper `event_guard::arm_event_close<C>(market, exchange, config, cap, receipt, clock)`: needs an active event pause
+ * (`ENoEventPause` 5); arms the session force-close drain at the receipt's storage price. Then run
+ * `addForceCloseSessionCall` per account (pending opens refund in full). Admin cancel: `oracle::disarm_session_close`.
+ * Emits `SessionArmedEventV1` and `EventCloseArmedEventV1`. Consumes the receipt. Note the Move argument order
+ * (market before exchange), as `oracle::arm_session_close`.
+ */
+export declare function addArmEventCloseCall(tx: Transaction, input: ArmEventCloseCall): void;
+export interface EventGuardAdminClearCall extends EventGuardTarget {
+    /** `parchment::authority::AuthorityCap<PACKAGE, ADMIN>`. */
+    adminCap: ObjectInput;
+}
+/** Admin `event_guard::admin_clear<C>(exchange, market, config, cap)`: clears the event pause and the event cap. */
+export declare function addEventGuardAdminClearCall(tx: Transaction, input: EventGuardAdminClearCall): void;
+/** BCS for `event_guard::Event<EventPauseUpdatedEventV1>`; `until_ms` 0 is a clear. */
+export declare const EVENT_PAUSE_UPDATED_EVENT_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    market_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    until_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    reason: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    sender: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    admin: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, string>;
+/** BCS for `event_guard::Event<EventLeverageCapUpdatedEventV1>`; `max_leverage` 0 and `until_ms` 0 is a clear. */
+export declare const EVENT_LEVERAGE_CAP_UPDATED_EVENT_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    market_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    max_leverage: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    until_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    reason: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    sender: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    admin: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, string>;
+/** BCS for `event_guard::Event<EventCloseArmedEventV1>`; `remaining` 0 is an empty book (snapshot not armed). */
+export declare const EVENT_CLOSE_ARMED_EVENT_BCS: import("@mysten/sui/bcs").BcsStruct<{
+    market_id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    reason: import("@mysten/sui/bcs").BcsType<number, number, "u8">;
+    price_wad: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u128">;
+    ts_ms: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    watermark: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    remaining: import("@mysten/sui/bcs").BcsType<string, string | number | bigint, "u64">;
+    pause_until_ms: 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 EventPauseUpdatedEvent = ReturnType<typeof EVENT_PAUSE_UPDATED_EVENT_BCS.parse>;
+export type EventLeverageCapUpdatedEvent = ReturnType<typeof EVENT_LEVERAGE_CAP_UPDATED_EVENT_BCS.parse>;
+export type EventCloseArmedEvent = ReturnType<typeof EVENT_CLOSE_ARMED_EVENT_BCS.parse>;
+export declare function decodeEventPauseUpdatedEvent(bytes: Uint8Array): EventPauseUpdatedEvent | null;
+export declare function decodeEventLeverageCapUpdatedEvent(bytes: Uint8Array): EventLeverageCapUpdatedEvent | null;
+export declare function decodeEventCloseArmedEvent(bytes: Uint8Array): EventCloseArmedEvent | null;
+/** Full event type string, e.g. `eventGuardEventType(tradeOriginalId, "EventPauseUpdatedEventV1")`. */
+export declare function eventGuardEventType(tradeOriginalId: string, name: "EventPauseUpdatedEventV1" | "EventLeverageCapUpdatedEventV1" | "EventCloseArmedEventV1"): string;
+export {};