@parchment-trade/sdk 0.0.0-stage → 1.0.0

package/dist/packages/parchment/txIntent.js

@@ -0,0 +1,611 @@
+import { fromBase64, normalizeSuiAddress, toBase64, toHex } from "@mysten/sui/utils";
+import { ParchmentApiError } from "../../general/utils/errors.js";
+import { PARCHMENT_BASE_MODULES, PARCHMENT_CORE_MODULES, PARCHMENT_TRADE_MODULES } from "./packageIds.js";
+export const UNCHECKED_TX = "unchecked";
+const ROLE_MODULES = {
+    core: PARCHMENT_CORE_MODULES,
+    trade: PARCHMENT_TRADE_MODULES,
+    base: PARCHMENT_BASE_MODULES,
+    game: [],
+    mint: [],
+    oracle: ["adapter"],
+    token: ["tokenomics", "staking", "parchment"],
+    lazerIntegration: ["price_feed_storage"],
+};
+const FRAMEWORK = normalizeSuiAddress("0x2");
+const ZERO_COIN = ["framework", "coin", "zero"];
+const ONE_STEP_PRELUDE = [
+    ["lazerIntegration", "price_feed_storage", "update_price_feed"],
+    ["oracle", "adapter", "quote"],
+    ["trade", "oracle", "begin_price"],
+];
+const call = (role, module, fn) => [role, module, fn];
+const only = (role, module, fn) => ({ actions: [{ call: call(role, module, fn) }] });
+function oneStep(action, bind, receiptAt, lossMint, updateOptional) {
+    const update = (at) => (updateOptional ? { at, update: "updateBase64", optional: true } : { at, update: "updateBase64" });
+    const actions = [
+        { call: call("lazerIntegration", "price_feed_storage", "update_price_feed"), bind: [update(5)] },
+        { call: call("oracle", "adapter", "quote"), bind: [update(2)] },
+        { call: call("trade", "oracle", "begin_price"), bind: [{ at: 1, object: "marketId" }, { at: 2, resultOf: 1 }] },
+        { call: action, bind: [...bind, { at: receiptAt, resultOf: 2 }] },
+    ];
+    if (lossMint) {
+        actions.push({ call: call("token", "tokenomics", "mint_on_loss"), bind: [{ at: 2, object: "accountId" }, { at: 3, resultOf: 3 }], times: [0, 1] });
+    }
+    return { actions };
+}
+const gameRoute = (fn, more = []) => ({
+    actions: [{ call: call("trade", "game", fn), bind: [{ at: 1, object: "accountId" }, { at: 2, object: "accountCapId" }, ...more] }],
+});
+const syncLocked = (owner) => ({
+    call: call("token", "staking", "sync_locked"), bind: [{ at: 2, address: owner }], times: [0, 1],
+});
+const adminRoute = (role, module, fn, capAt, more = []) => ({
+    actions: [{ call: call(role, module, fn), bind: [{ at: capAt, object: "authorityCapId" }, ...more] }],
+});
+const ROUTES = {
+    "open-account": only("core", "exchange", "open_account"),
+    deposit: {
+        actions: [{ call: call("core", "exchange", "deposit"), bind: [{ at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, object: "coin" }] }],
+    },
+    withdraw: {
+        actions: [{ call: call("core", "exchange", "withdraw"), bind: [{ at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, u64: "amount" }] }],
+    },
+    "request-open": {
+        actions: [
+            {
+                call: call("trade", "order", "request_open"),
+                bind: [
+                    { at: 1, object: "marketId" },
+                    { at: 2, object: "accountId" },
+                    { at: 3, object: "accountCapId" },
+                    { at: 5, u64: "margin" },
+                    { at: 6, u64: "leverage" },
+                    { at: 7, bool: "isLong" },
+                    { at: 8, u64: "minFactorBps", fallback: 0n },
+                    { at: 9, u128: "acceptablePriceWad" },
+                    { at: 10, optionU32: "builderId", unverifiable: "builderCode" },
+                    { at: 11, coinOrZero: "topUp" },
+                ],
+            },
+        ],
+        extras: [ZERO_COIN],
+    },
+    "request-open-as-delegate": {
+        actions: [
+            {
+                call: call("trade", "order", "request_open_as_delegate"),
+                bind: [
+                    { at: 1, object: "marketId" },
+                    { at: 2, object: "accountId" },
+                    { at: 4, u64: "margin" },
+                    { at: 5, u64: "leverage" },
+                    { at: 6, bool: "isLong" },
+                    { at: 7, u64: "minFactorBps", fallback: 0n },
+                    { at: 8, u128: "acceptablePriceWad" },
+                    { at: 9, optionU32: "builderId", unverifiable: "builderCode" },
+                ],
+            },
+        ],
+    },
+    "request-close": {
+        actions: [
+            {
+                call: call("trade", "order", "request_close"),
+                bind: [
+                    { at: 1, object: "marketId" },
+                    { at: 2, object: "accountId" },
+                    { at: 3, object: "accountCapId" },
+                    { at: 5, u64: "positionId" },
+                    { at: 6, u128: "acceptablePriceWad", fallback: 0n },
+                    { at: 7, coinOrZero: "topUp" },
+                ],
+            },
+        ],
+        extras: [ZERO_COIN],
+    },
+    "request-close-as-delegate": {
+        actions: [
+            {
+                call: call("trade", "order", "request_close_as_delegate"),
+                bind: [{ at: 1, object: "marketId" }, { at: 2, object: "accountId" }, { at: 4, u64: "positionId" }, { at: 5, u128: "acceptablePriceWad", fallback: 0n }],
+            },
+        ],
+    },
+    "cancel-order": {
+        actions: [{ call: call("trade", "order", "cancel"), bind: [{ at: 1, object: "accountId" }, { at: 2, object: "accountCapId" }, { at: 4, object: "orderId" }] }],
+    },
+    "cancel-order-as-delegate": {
+        actions: [{ call: call("trade", "order", "cancel_as_delegate"), bind: [{ at: 1, object: "accountId" }, { at: 3, object: "orderId" }] }],
+    },
+    "expire-order": {
+        actions: [
+            {
+                call: call("trade", "order", "expire"),
+                bind: [{ at: 1, object: "marketId", optional: true }, { at: 2, object: "accountId" }, { at: 4, object: "orderId" }],
+            },
+        ],
+        extras: [["oracle", "adapter", "quote"], ["trade", "oracle", "begin_expiry_price"]],
+    },
+    "emergency-close": oneStep(call("trade", "order", "emergency_close"), [{ at: 1, object: "marketId" }, { at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 5, object: "orderId" }], 6, true, true),
+    "emergency-close-as-delegate": oneStep(call("trade", "order", "emergency_close_as_delegate"), [{ at: 1, object: "marketId" }, { at: 2, object: "accountId" }, { at: 4, object: "orderId" }], 5, true, true),
+    "close-retired": oneStep(call("trade", "trade", "close_retired"), [{ at: 1, object: "marketId" }, { at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 5, u64: "positionId" }], 6, true, true),
+    "close-retired-as-delegate": oneStep(call("trade", "trade", "close_retired_as_delegate"), [{ at: 1, object: "marketId" }, { at: 2, object: "accountId" }, { at: 4, u64: "positionId" }], 5, true, true),
+    liquidate: oneStep(call("trade", "trade", "liquidate"), [{ at: 1, object: "marketId" }, { at: 3, u64: "positionId" }], 4, false, false),
+    "liquidate-retired": oneStep(call("trade", "trade", "liquidate_retired"), [{ at: 1, object: "marketId" }, { at: 3, u64: "positionId" }], 4, false, false),
+    sweep: oneStep(call("trade", "trade", "sweep"), [{ at: 1, object: "marketId" }, { at: 4, u64: "maxEntries" }], 3, false, false),
+    "sweep-surplus": {
+        actions: [
+            { call: call("core", "exchange", "begin_reserve_check") },
+            { call: call("trade", "trade", "check_market"), bind: [{ at: 0, resultOf: 0 }], times: [0, 64] },
+            { call: call("core", "exchange", "sweep_surplus"), bind: [{ at: 2, resultOf: 0 }] },
+        ],
+        extras: ONE_STEP_PRELUDE,
+    },
+    "grant-delegate": {
+        actions: [
+            {
+                call: call("core", "exchange", "grant_delegate"),
+                bind: [{ at: 1, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, address: "delegate" }, { at: 5, u64: "expiryMs" }],
+            },
+        ],
+    },
+    "revoke-delegate": {
+        actions: [{ call: call("core", "exchange", "revoke_delegate"), bind: [{ at: 1, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, address: "delegate" }] }],
+    },
+    "grant-close-delegate": {
+        actions: [
+            {
+                call: call("core", "exchange", "grant_close_delegate"),
+                bind: [{ at: 1, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, address: { triggerDelegate: true } }],
+                times: [0, 1],
+            },
+        ],
+    },
+    "grant-session-and-trigger": {
+        actions: [
+            {
+                call: call("core", "exchange", "grant_delegate"),
+                bind: [{ at: 1, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, address: "sessionDelegate" }, { at: 5, u64: "expiryMs" }],
+            },
+            {
+                call: call("core", "exchange", "grant_close_delegate"),
+                bind: [{ at: 1, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, address: { triggerDelegate: true } }],
+                times: [0, 1],
+            },
+        ],
+    },
+    "release-unlocked": {
+        actions: [
+            { call: call("trade", "locked_mint", "release_unlocked"), bind: [{ at: 1, address: { field: "who", fallback: "sender" } }] },
+            syncLocked({ field: "who", fallback: "sender" }),
+        ],
+    },
+    "exit-early": { actions: [{ call: call("trade", "locked_mint", "exit_early") }, syncLocked({ sender: true })] },
+    "exit-early-bounded": {
+        actions: [
+            { call: call("trade", "locked_mint", "exit_early_bounded"), bind: [{ at: 2, u64s: "unlocks" }, { at: 3, u64: "maxPenalty" }] },
+            syncLocked({ sender: true }),
+        ],
+    },
+    harvest: { actions: [{ call: call("trade", "harvest", "harvest"), bind: [{ at: 3, u64: "maxEntries" }] }] },
+    "claim-pending-mint": {
+        actions: [
+            { call: call("trade", "fees", "claim_pending_ticket"), bind: [{ at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }] },
+            { call: call("token", "tokenomics", "mint_on_loss"), bind: [{ at: 2, object: "accountId" }, { at: 3, resultOf: 0 }] },
+        ],
+    },
+    stake: { actions: [{ call: call("token", "staking", "stake"), bind: [{ at: 2, object: "coin" }] }] },
+    unstake: { actions: [{ call: call("token", "staking", "unstake"), bind: [{ at: 2, u64: "amount" }] }] },
+    claim: only("token", "staking", "claim"),
+    "bind-referrer": { actions: [{ call: call("token", "staking", "bind_referrer"), bind: [{ at: 2, address: "referrer" }] }] },
+    "bind-trading-referrer": {
+        actions: [
+            {
+                call: call("trade", "referral", "bind_referrer"),
+                bind: [{ at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, address: "referrer" }],
+            },
+        ],
+    },
+    "transfer-account": {
+        actions: [
+            {
+                call: call("trade", "account_transfer", "transfer_account"),
+                bind: [{ at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, address: "recipient" }],
+            },
+        ],
+    },
+    "claim-daily": gameRoute("claim_daily"),
+    "open-crate": gameRoute("open_crate"),
+    "open-crates": gameRoute("open_crates", [{ at: 4, u64: "count" }]),
+    "claim-quest": gameRoute("claim_quest", [{ at: 4, u8: "questId" }]),
+    "collect-mint": gameRoute("collect_mint"),
+    "create-builder": {
+        actions: [
+            {
+                call: call("trade", "builder", "create_builder"),
+                bind: [{ at: 2, utf8: "code" }, { at: 3, address: "payout" }, { at: 4, u16: "feeBps" }, { at: 5, splitOf: "coin" }],
+            },
+        ],
+        splits: 1,
+    },
+    "set-builder-payout": {
+        actions: [{ call: call("trade", "builder", "set_builder_payout"), bind: [{ at: 2, u32: "builderId" }, { at: 3, address: "newPayout" }] }],
+    },
+    "set-builder-fee": { actions: [{ call: call("trade", "builder", "set_builder_fee"), bind: [{ at: 2, u32: "builderId" }, { at: 3, u16: "feeBps" }] }] },
+    "pause-builder": { actions: [{ call: call("trade", "builder", "pause_builder"), bind: [{ at: 2, u32: "builderId" }] }] },
+    "resume-builder": { actions: [{ call: call("trade", "builder", "resume_builder"), bind: [{ at: 2, u32: "builderId" }] }] },
+    "transfer-builder": { actions: [{ call: call("trade", "builder", "transfer_owner"), bind: [{ at: 2, u32: "builderId" }, { at: 3, address: "newOwner" }] }] },
+    "approve-builder": {
+        actions: [
+            {
+                call: call("trade", "builder", "approve_builder"),
+                bind: [{ at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, u32: "builderId" }, { at: 5, u16: "maxFeeBps" }],
+            },
+        ],
+    },
+    "revoke-builder-approval": {
+        actions: [
+            {
+                call: call("trade", "builder", "revoke_builder_approval"),
+                bind: [{ at: 2, object: "accountId" }, { at: 3, object: "accountCapId" }, { at: 4, u32: "builderId" }],
+            },
+        ],
+    },
+    "register-builder": adminRoute("trade", "builder", "register_builder", 2, [
+        { at: 3, utf8: "code" },
+        { at: 4, address: "payout" },
+        { at: 5, address: "owner" },
+        { at: 6, u16: "feeBps" },
+    ]),
+    "set-builder-create-fee": adminRoute("core", "config", "set_builder_create_fee", 1, [{ at: 2, u64: "amount" }]),
+    "install-treasury": adminRoute("token", "parchment", "install_treasury", 2, [{ at: 3, object: "treasuryCap" }]),
+    "auth-register": adminRoute("trade", "auth", "register", 2),
+    "game-attach": adminRoute("trade", "game_book", "attach", 2),
+};
+const REVOKE_SESSION_AND_TRIGGER = call("core", "exchange", "revoke_delegate");
+const REVOKE_ROUTE = "revoke-session-and-trigger";
+function namedDelegates(body) {
+    const session = bodyAddress(body.sessionDelegate);
+    const trigger = bodyAddress(body.triggerDelegate);
+    if (session === null || trigger === null)
+        return null;
+    return session === trigger ? [session] : [session, trigger];
+}
+function ids(list) {
+    return new Set((list ?? []).map((id) => normalizeSuiAddress(id)));
+}
+function roleOf(trusted, pkg, module, fn) {
+    const id = normalizeSuiAddress(pkg);
+    if (id === FRAMEWORK && module === "coin" && fn === "zero")
+        return "framework";
+    for (const role of Object.keys(ROLE_MODULES)) {
+        if (ids(trusted[role]).has(id) && ROLE_MODULES[role].includes(module))
+            return role;
+    }
+    return null;
+}
+function inputOf(data, arg) {
+    if (arg?.$kind !== "Input" || typeof arg.Input !== "number")
+        return null;
+    return data.inputs[arg.Input] ?? null;
+}
+function objectIdOf(data, arg) {
+    const input = inputOf(data, arg);
+    const id = input?.Object?.SharedObject?.objectId ?? input?.Object?.ImmOrOwnedObject?.objectId ?? input?.UnresolvedObject?.objectId;
+    return id ? normalizeSuiAddress(id) : null;
+}
+function pureBytes(data, arg) {
+    const input = inputOf(data, arg);
+    return input?.$kind === "Pure" && input.Pure ? fromBase64(input.Pure.bytes) : null;
+}
+function bcsBytes(bytes) {
+    return bcsVector(bytes.length, bytes);
+}
+function bcsVector(length, bytes) {
+    const prefix = [];
+    let n = length;
+    do {
+        prefix.push((n & 0x7f) | (n > 0x7f ? 0x80 : 0));
+        n >>>= 7;
+    } while (n > 0);
+    const out = new Uint8Array(prefix.length + bytes.length);
+    out.set(prefix);
+    out.set(bytes, prefix.length);
+    return out;
+}
+export function updateArgBase64(updateBase64) {
+    if (typeof updateBase64 !== "string" || updateBase64.length === 0)
+        return null;
+    try {
+        const bytes = fromBase64(updateBase64);
+        return bytes.length === 0 ? null : toBase64(bcsBytes(bytes));
+    }
+    catch {
+        return null;
+    }
+}
+function sameBytes(a, b) {
+    return a.length === b.length && a.every((x, i) => x === b[i]);
+}
+function littleEndian(bytes) {
+    let value = 0n;
+    for (let i = bytes.length - 1; i >= 0; i--)
+        value = (value << 8n) | BigInt(bytes[i]);
+    return value;
+}
+function bodyInt(value) {
+    if (typeof value === "bigint")
+        return value;
+    if (typeof value === "string" && /^\d+n?$/.test(value))
+        return BigInt(value.replace(/n$/, ""));
+    return null;
+}
+function bodyAddress(value) {
+    if (typeof value !== "string")
+        return null;
+    try {
+        return normalizeSuiAddress(value);
+    }
+    catch {
+        return null;
+    }
+}
+function bodyObject(value) {
+    if (value && typeof value === "object" && typeof value.objectId === "string") {
+        return bodyAddress(value.objectId);
+    }
+    return bodyAddress(value);
+}
+function bindingViolation(data, args, binding, body, sender, trust, zeroCoins, actionAt) {
+    const arg = args[binding.at];
+    if (arg === undefined)
+        return `argument ${binding.at} is missing`;
+    if ("resultOf" in binding) {
+        const from = actionAt[binding.resultOf];
+        const index = arg.$kind === "Result" ? arg.Result : arg.$kind === "NestedResult" && arg.NestedResult?.[1] === 0 ? arg.NestedResult[0] : undefined;
+        return from !== null && from !== undefined && index === from ? null : `argument ${binding.at} is not the result of the route's earlier call`;
+    }
+    if ("object" in binding) {
+        if (binding.optional && body[binding.object] === undefined)
+            return null;
+        const want = bodyObject(body[binding.object]);
+        if (want === null)
+            return `request has no ${binding.object}`;
+        return objectIdOf(data, arg) === want ? null : `argument ${binding.at} is not the requested ${binding.object}`;
+    }
+    if ("coinOrZero" in binding) {
+        const want = body[binding.coinOrZero] === undefined ? null : bodyObject(body[binding.coinOrZero]);
+        if (want !== null)
+            return objectIdOf(data, arg) === want ? null : `argument ${binding.at} is not the requested ${binding.coinOrZero} coin`;
+        return arg.$kind === "Result" && typeof arg.Result === "number" && zeroCoins.has(arg.Result) ? null : `argument ${binding.at} is not a zero coin`;
+    }
+    if ("update" in binding || "utf8" in binding) {
+        const field = "update" in binding ? binding.update : binding.utf8;
+        const raw = body[field];
+        let want = null;
+        if (typeof raw === "string" && raw.length > 0) {
+            try {
+                want = "update" in binding ? fromBase64(raw) : new TextEncoder().encode(raw);
+            }
+            catch {
+                want = null;
+            }
+        }
+        if (want === null || want.length === 0) {
+            if ("update" in binding && binding.optional && (raw === undefined || raw === null)) {
+                return trust.acceptServiceOracleUpdate === true
+                    ? null
+                    : `request has no ${field}: pass the signed update (or set txTrust.acceptServiceOracleUpdate to take the service's)`;
+            }
+            return `request has no ${field}`;
+        }
+        const bytes = pureBytes(data, arg);
+        return bytes !== null && sameBytes(bytes, bcsBytes(want)) ? null : `argument ${binding.at} is not the requested ${field}`;
+    }
+    if ("splitOf" in binding) {
+        const want = bodyObject(body[binding.splitOf]);
+        if (want === null)
+            return `request has no ${binding.splitOf}`;
+        const index = arg.$kind === "Result" ? arg.Result : arg.$kind === "NestedResult" && arg.NestedResult?.[1] === 0 ? arg.NestedResult[0] : undefined;
+        const split = index === undefined ? undefined : data.commands[index];
+        const from = split?.$kind === "SplitCoins" && split.SplitCoins.amounts.length === 1 ? split.SplitCoins.coin : undefined;
+        return from !== undefined && objectIdOf(data, from) === want ? null : `argument ${binding.at} is not split from the requested ${binding.splitOf}`;
+    }
+    if ("u8" in binding || "u16" in binding || "u32" in binding || "u64" in binding || "u128" in binding) {
+        const [field, width] = "u8" in binding ? [binding.u8, 1]
+            : "u16" in binding ? [binding.u16, 2]
+                : "u32" in binding ? [binding.u32, 4]
+                    : "u64" in binding ? [binding.u64, 8]
+                        : [binding.u128, 16];
+        const raw = body[field];
+        const fallback = "fallback" in binding ? binding.fallback : undefined;
+        const want = raw === undefined ? (fallback ?? null) : bodyInt(raw);
+        if (want === null)
+            return `request has no ${field}`;
+        const bytes = pureBytes(data, arg);
+        return bytes !== null && bytes.length === width && littleEndian(bytes) === want ? null : `argument ${binding.at} is not the requested ${field}`;
+    }
+    if ("u64s" in binding) {
+        const raw = body[binding.u64s];
+        const want = Array.isArray(raw) ? raw.map(bodyInt) : null;
+        if (want === null || want.some((v) => v === null || v > 0xffffffffffffffffn))
+            return `request has no ${binding.u64s}`;
+        const bytes = pureBytes(data, arg);
+        const words = new Uint8Array(want.length * 8);
+        want.forEach((v, i) => {
+            for (let b = 0; b < 8; b++)
+                words[i * 8 + b] = Number((v >> BigInt(8 * b)) & 0xffn);
+        });
+        return bytes !== null && sameBytes(bytes, bcsVector(want.length, words)) ? null : `argument ${binding.at} is not the requested ${binding.u64s}`;
+    }
+    if ("optionU32" in binding) {
+        const bytes = pureBytes(data, arg);
+        const some = bytes !== null && bytes.length === 5 && bytes[0] === 1 ? littleEndian(bytes.subarray(1)) : null;
+        const none = bytes !== null && bytes.length === 1 && bytes[0] === 0;
+        const raw = body[binding.optionU32];
+        if (raw === undefined) {
+            if (body[binding.unverifiable] !== undefined)
+                return `a ${binding.unverifiable} without ${binding.optionU32} cannot be checked; pass ${binding.optionU32}`;
+            return none ? null : `argument ${binding.at} names a ${binding.optionU32} the request does not`;
+        }
+        const want = bodyInt(raw);
+        if (want === null)
+            return `request has no ${binding.optionU32}`;
+        return some === want ? null : `argument ${binding.at} is not the requested ${binding.optionU32}`;
+    }
+    if ("bool" in binding) {
+        const want = body[binding.bool];
+        if (typeof want !== "boolean")
+            return `request has no ${binding.bool}`;
+        const bytes = pureBytes(data, arg);
+        return bytes !== null && bytes.length === 1 && bytes[0] === (want ? 1 : 0) ? null : `argument ${binding.at} is not the requested ${binding.bool}`;
+    }
+    const spec = binding.address;
+    let want;
+    let label;
+    if (typeof spec === "string") {
+        want = bodyAddress(body[spec]);
+        label = spec;
+    }
+    else if ("sender" in spec) {
+        want = normalizeSuiAddress(sender);
+        label = "sender";
+    }
+    else if ("triggerDelegate" in spec) {
+        want = trust.triggerDelegate ? normalizeSuiAddress(trust.triggerDelegate) : null;
+        label = "pinned trigger delegate";
+        if (want === null)
+            return "txTrust.triggerDelegate is not pinned";
+    }
+    else {
+        want = body[spec.field] === undefined ? normalizeSuiAddress(sender) : bodyAddress(body[spec.field]);
+        label = spec.field;
+    }
+    if (want === null)
+        return `request has no ${label}`;
+    const bytes = pureBytes(data, arg);
+    const got = bytes !== null && bytes.length === 32 ? normalizeSuiAddress(toHex(bytes)) : null;
+    return got === want ? null : `argument ${binding.at} is not the ${label}`;
+}
+export function txIntentViolation(route, tx, body, sender, trust, held) {
+    const data = tx.getData();
+    const intent = route === REVOKE_ROUTE
+        ? { actions: [{ call: REVOKE_SESSION_AND_TRIGGER, bind: [{ at: 1, object: "accountId" }, { at: 3, object: "accountCapId" }], times: [1, 2] }] }
+        : ROUTES[route];
+    if (!intent)
+        return `no intent check for transactions/${route}`;
+    let mustRevoke = [];
+    if (route === REVOKE_ROUTE) {
+        const named = namedDelegates(body);
+        if (named === null)
+            return "request has no sessionDelegate and triggerDelegate";
+        const live = held === undefined ? null : new Set(held.map((a) => normalizeSuiAddress(a)));
+        mustRevoke = live === null ? named : named.filter((a) => live.has(a));
+        if (mustRevoke.length === 0)
+            return "neither named delegate holds a grant on the account";
+    }
+    const counts = intent.actions.map(() => 0);
+    const actionAt = intent.actions.map(() => null);
+    const zeroCoins = new Set();
+    let splits = 0;
+    const revoked = [];
+    const bound = (bindings, args, what) => {
+        for (const binding of bindings) {
+            const violation = bindingViolation(data, args, binding, body, sender, trust, zeroCoins, actionAt);
+            if (violation)
+                return `${what} ${violation}`;
+        }
+        return null;
+    };
+    for (const [index, command] of data.commands.entries()) {
+        if (command.$kind === "SplitCoins") {
+            if (++splits > (intent.splits ?? 0) || command.SplitCoins.amounts.length !== 1)
+                return `unexpected SplitCoins for ${route}`;
+            continue;
+        }
+        if (command.$kind === "TransferObjects") {
+            const to = pureBytes(data, command.TransferObjects.address);
+            if (to === null || to.length !== 32 || normalizeSuiAddress(toHex(to)) !== normalizeSuiAddress(sender))
+                return `TransferObjects to someone other than the sender for ${route}`;
+            continue;
+        }
+        if (command.$kind !== "MoveCall")
+            return `unexpected ${command.$kind} for ${route}`;
+        const { package: pkg, module, function: fn, arguments: args } = command.MoveCall;
+        const role = roleOf(trust.packages, pkg, module, fn);
+        if (role === null)
+            return `call to untrusted ${pkg}::${module}::${fn}`;
+        const key = `${role}:${module}::${fn}`;
+        const sameKey = (c) => `${c[0]}:${c[1]}::${c[2]}` === key;
+        const action = intent.actions.findIndex((a) => sameKey(a.call));
+        if (action === -1) {
+            const extra = (intent.extras ?? []).find((e) => sameKey("call" in e ? e.call : e));
+            if (extra === undefined)
+                return `unexpected call to ${module}::${fn} for ${route}`;
+            if ("bind" in extra) {
+                const violation = bound(extra.bind, args, `${module}::${fn}`);
+                if (violation)
+                    return violation;
+            }
+            if (role === "framework")
+                zeroCoins.add(index);
+            continue;
+        }
+        counts[action]++;
+        const violation = bound(intent.actions[action].bind ?? [], args, `${module}::${fn}`);
+        if (violation)
+            return violation;
+        actionAt[action] = index;
+        if (route === REVOKE_ROUTE) {
+            const bytes = pureBytes(data, args[4]);
+            const who = bytes !== null && bytes.length === 32 ? normalizeSuiAddress(toHex(bytes)) : null;
+            if (who === null || !mustRevoke.includes(who) || revoked.includes(who)) {
+                return "revoke_delegate argument 4 is not a held delegate named in the request";
+            }
+            revoked.push(who);
+        }
+    }
+    for (const [i, action] of intent.actions.entries()) {
+        const [min, max] = action.times ?? [1, 1];
+        if (counts[i] < min || counts[i] > max)
+            return `${action.call[1]}::${action.call[2]} appears ${counts[i]} times for ${route}`;
+    }
+    const kept = mustRevoke.filter((a) => !revoked.includes(a));
+    if (kept.length > 0)
+        return `revoke-session-and-trigger leaves ${kept.join(", ")} granted`;
+    return null;
+}
+export function untrustedConfigPackages(config, trusted) {
+    const out = [];
+    const check = (list, allowed) => {
+        const set = ids(allowed);
+        for (const id of list)
+            if (id && !set.has(normalizeSuiAddress(id)))
+                out.push(normalizeSuiAddress(id));
+    };
+    check([config.packageId, ...(config.packageIds ?? [])], trusted.core);
+    check([config.tradePackageId, ...(config.tradePackageIds ?? [])], trusted.trade);
+    check([config.basePackageId, ...(config.basePackageIds ?? [])], trusted.base);
+    check([config.gamePackageId, ...(config.gamePackageIds ?? [])], trusted.game);
+    check([config.mintPackageId, ...(config.mintPackageIds ?? [])], trusted.mint);
+    if (trusted.oracle)
+        check([config.oraclePackageId], trusted.oracle);
+    if (trusted.token)
+        check([config.tokenPackageId], trusted.token);
+    if (trusted.lazerIntegration)
+        check([config.lazerIntegrationPackageId], trusted.lazerIntegration);
+    return out;
+}
+export function txRoute(url) {
+    return url.replace(/^\/*transactions\//, "").replace(/[?#].*$/, "");
+}
+export async function assertTxIntent(url, body, tx, sender, trust) {
+    const route = txRoute(url);
+    const named = route === REVOKE_ROUTE ? namedDelegates(body) : null;
+    const accountId = bodyAddress(body.accountId);
+    const held = named !== null && accountId !== null && trust.heldDelegates ? await trust.heldDelegates(accountId, named) : undefined;
+    const violation = txIntentViolation(route, tx, body, sender, trust, held);
+    if (violation !== null)
+        throw new ParchmentApiError(0, "intent_mismatch", `transaction does not match the request: ${violation}`);
+}

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+export type { CallerConfig, ParchmentOptions, RequestOptions, RequestOptionsUpdate } from "./general/types/index.js";
+export type * from "./packages/parchment/parchmentTypes.js";

package/dist/types.js

@@ -0,0 +1 @@
+export {};