@cmdoss/suipay-mcp 0.2.0

package/dist/http.d.ts

@@ -0,0 +1,3 @@
+export { q as handleSuipayMcpHttpRequest } from './http-BnIjiwcR.js';
+import '@modelcontextprotocol/sdk/server/index.js';
+import '@mysten/sui/keypairs/ed25519';

package/dist/http.js

@@ -0,0 +1,7 @@
+import {
+  handleSuipayMcpHttpRequest
+} from "./chunk-XZQOOY66.js";
+import "./chunk-A3JIIDYT.js";
+export {
+  handleSuipayMcpHttpRequest
+};

package/dist/index.d.ts

@@ -0,0 +1,324 @@
+import { D as Dialect, G as GrantSnapshot, M as McpConfig, T as TraceSink, a as DelegatedKeySigner, b as GetObjectJson, c as DelegatedPayerSession, d as DelegatedPayerConfig, e as DelegatedPayerDeps, S as SpendIntent, f as DelegatedPayResult } from './http-BnIjiwcR.js';
+export { A as AgentHeldResolver, g as AgentHeldSettlement, h as McpEnvelope, i as McpEnvelopeEntry, j as McpServerOptions, k as McpTraceContext, l as McpTraceHooks, m as McpTraceRuntime, P as PACKAGE_NAME, n as TOOLS, o as canonicalMcpRequestId, p as createServer, q as handleSuipayMcpHttpRequest, r as inspectMcpEnvelope, s as loadMcpConfig, t as resetAgentHeldProcessLedger, u as resolveAgentHeldSettlement, v as resolveGrantTarget, w as traceMcpHttpRequest } from './http-BnIjiwcR.js';
+import '@modelcontextprotocol/sdk/server/index.js';
+import '@mysten/sui/keypairs/ed25519';
+
+type PaidHttpMethod = 'GET' | 'POST';
+interface PaidHttpRequest {
+    url: string;
+    method: PaidHttpMethod;
+    /** Exact wire bytes. Empty for GET. */
+    body: Uint8Array;
+    /** Normalized media type, or null when no body is sent. */
+    contentType: string | null;
+    /** `hashRequestBody(body)` — the single canonical body hash. */
+    bodyHash: string;
+}
+
+/** Holds a key and signs transaction bytes. Never leaves the payer. */
+interface Wallet {
+    readonly address: string;
+    signTransaction(txBytes: string): Promise<string>;
+}
+
+interface SuiPayCredentials {
+    /** 64-hex Ed25519 seed. NEVER logged. */
+    delegatePrivateKey: string;
+    delegatePublicKeyHex: string;
+    delegateAddress: string;
+    ownerAddress: string;
+    allowanceId: string;
+    packageId: string;
+    coinType: string;
+    /** Allowance recipient = the resource's payTo. */
+    recipient: string;
+    gatewayUrl: string;
+    network: string;
+    maxPerPayment: string;
+    label?: string;
+    createdAt: string;
+    version: 1;
+}
+/** Public-only view. Never includes the seed. */
+interface LocalSigningKeyIdentity {
+    delegateAddress: string;
+    publicKeyHex: string;
+}
+type SignerSource = 'secret-key' | 'credentials' | 'mnemonic';
+interface PaymentProfile {
+    creds: SuiPayCredentials;
+    wallet: Wallet;
+    source: SignerSource;
+}
+/**
+ * Load a historical V1 allowance payment profile, if present.
+ * ADR-0010: not for new settlement. Callers that pay must refuse this profile
+ * and point operators at shared_pool OAuth / delegated-signer flows.
+ */
+declare function loadPaymentProfile(): PaymentProfile | null;
+/**
+ * First authorization generates a local keypair and persists it at 0600.
+ * Re-authorization reuses the stored key so a second key cannot orphan the grant.
+ * Returns only the public identity.
+ */
+declare function ensureLocalSigningKey(opts?: {
+    label?: string;
+}): Promise<LocalSigningKeyIdentity>;
+/**
+ * The persisted agent-held delegate signer, or null when this process holds no
+ * key. Reads only — it never mints.
+ *
+ * `ensureLocalSigningKey` is the provisioning entry point and mints on first
+ * authorization, which is right there and wrong here: `pay` runs on hosts that
+ * are not the agent (the gateway runs the same tool code), and minting on a read
+ * path would write key material onto a machine that must hold none, then quietly
+ * fail to match any grant. Absent key → no settlement, by construction.
+ */
+declare function loadLocalSigner(): {
+    address: string;
+    signTransaction: (txBytes: string) => Promise<string>;
+    signPersonalMessage: (message: Uint8Array) => Promise<string>;
+} | null;
+
+/**
+ * Shared pay-request helpers.
+ *
+ * The V1 allowance sponsored payer (ADR-0010) is retired; only the
+ * rail-neutral request surface the SpendAccount payer depends on survives here:
+ * the `PayResult` shape every payer returns and `paidRequestInit`, which builds
+ * the one RequestInit replayed byte for byte on the unpaid and the paid call.
+ */
+
+type PayResult = {
+    status: 'ok' | 'failed' | 'ambiguous';
+    /**
+     * `true` — settlement confirmed. `false` — money did not leave the
+     * account. `'unknown'` — execute/finality did not resolve; a retry can
+     * pay twice.
+     */
+    paid: boolean | 'unknown';
+    body?: unknown;
+    receipt?: unknown;
+    code?: string;
+    detail?: string;
+    txDigest?: string;
+};
+
+/**
+ * SpendAccount PREPARE-only client (non-custodial MCP).
+ *
+ * The remote MCP `pay` tool runs inside the gateway, which holds NO key that can
+ * spend. So this module does not sign or submit: it PREPARES a payment and hands
+ * back an unsigned `spend_account::settle_policy_payment` transaction plus everything the client
+ * needs. The client — which holds the delegate key — sponsors, signs locally,
+ * and submits through the same personal-message challenge → local-sign → submit flow the
+ * REST/SDK delegate path uses. Only signatures ever reach the gateway; the
+ * private key is never placed in an HTTP body, a bearer, or any header.
+ *
+ * Flow: 402 Offer → request-binding → package/network SSOT →
+ * resolveGrantTarget(snapshot, offer.targetHash) (pause/revoke gate) → cap/coin
+ * checks → assertLive (fresh authority) → build unsigned kind bytes → return the
+ * signing request. There is deliberately no sponsor call, no decrypt, no
+ * signature, and no forwarded bearer here.
+ *
+ * See docs/design/mcp-non-custodial-signing.md and ADR-0013 §3.
+ */
+
+/**
+ * Read/prepare-only session for the non-custodial MCP pay tool. It carries the
+ * immutable grant snapshot and an optional prepare-time live gate — and no key,
+ * by construction. There is no `decryptDelegateSeed` and no `sponsorAuthorization`.
+ */
+interface SpendAccountPrepareSession {
+    snapshot: GrantSnapshot;
+    /** SpendAccount package id (V2). */
+    packageId: string;
+    /**
+     * Re-assert the grant is still live (not paused/revoked/expired) against fresh
+     * canonical state, invoked immediately before a signing request is handed back.
+     * Throw to abort. Optional; when absent, only the request-time snapshot gates
+     * the prepare (on-chain `spend_account::settle_policy_payment` remains the final backstop for any
+     * spend the client later submits).
+     */
+    assertLive?: () => Promise<void>;
+}
+interface SpendAccountPayDeps {
+    fetchImpl?: typeof fetch;
+    /** Build only-transaction-kind bytes for spend_account::settle_policy_payment. */
+    buildPayKind?: (input: {
+        delegate: string;
+        coinType: string;
+        poolObjectId: string;
+        grantObjectId: string;
+        policyId: number | string;
+        targetHash: string;
+        amount: string;
+        paymentIdHash: Uint8Array;
+        termsHash: Uint8Array;
+        recipient?: string;
+        accessMode?: 'scoped' | 'open';
+    }) => Promise<{
+        kindBytes: string;
+    }>;
+    /**
+     * Live trace for this prepare. Purely observational: emission records what the
+     * canonical read decisions already returned — an event is written after a check
+     * passes and can never be the thing that lets the next step run.
+     */
+    trace?: SpendAccountPayTrace;
+}
+interface SpendAccountPayTrace {
+    sink: TraceSink;
+    traceId: string;
+    requestId: string | null;
+    buyerAccountId: string;
+    connectionId: string;
+    /** HMAC secret for signed cross-request context. Absent disables signing. */
+    secret?: string | null;
+    /** Injected clock, for tests. */
+    now?: () => number;
+}
+/** The unsigned payment the client signs locally and submits. */
+interface SpendAccountSigningRequest {
+    /**
+     * Unsigned `spend_account::settle_policy_payment` transaction-kind bytes (base64), sender set to
+     * `delegateAddress`. The client sponsors these for gas, signs with the delegate
+     * key, and submits — the gateway never receives the key.
+     */
+    unsignedKindBytes: string;
+    delegateAddress: string;
+    packageId: string;
+    poolObjectId: string;
+    grantObjectId: string;
+    /** On-chain policy id the pay is bound to. */
+    policyId: number | string;
+    coinType: string;
+    targetHash: string;
+    amount: string;
+    /** Hex (no 0x) of the payment-id hash bound into the transaction. */
+    paymentIdHashHex: string;
+    /** Hex (no 0x) of the terms hash bound into the transaction. */
+    termsHashHex: string;
+    challengeId: string;
+    /** The exact paid request to replay after the client submits. */
+    resource: {
+        url: string;
+        method: string;
+    };
+    dialect: Dialect;
+    /** Recipient the agent requested (offer.payTo). */
+    recipient: string;
+    /** Where the client (holding the key) sponsors and submits. */
+    submit: {
+        sponsorUrl: string;
+        executeUrl: string;
+        moveCallTarget: string;
+    };
+    /**
+     * Non-secret wallet/console handoff for hosts that cannot run a local signer:
+     * the delegate key signs and submits out of band there. Parameterized only by
+     * public Connection-manifest fields — never any secret.
+     */
+    handoffUrl: string;
+    /** Restated hard rule for the agent host. */
+    note: string;
+}
+interface PreparedPayment {
+    status: 'prepared';
+    paid: false;
+    signingRequest: SpendAccountSigningRequest;
+}
+/** Prepared signing request, or a canonical failure (never a spend). */
+type SpendAccountPrepareResult = PreparedPayment | PayResult;
+/** Default kind builder (no chain client — pure PTB). */
+declare function buildSpendAccountPayKind(input: {
+    packageId: string;
+    delegate: string;
+    coinType: string;
+    poolObjectId: string;
+    grantObjectId: string;
+    policyId: number | string;
+    targetHash: string;
+    amount: string;
+    paymentIdHash: Uint8Array;
+    termsHash: Uint8Array;
+}): Promise<{
+    kindBytes: string;
+}>;
+/**
+ * Refuse blind signing: a client validating a sponsored transaction must be able
+ * to prove the sponsored bytes reconstruct the intended spend_account::settle_policy_payment. Kept
+ * here (and exported) so both the client signer and its tests share one check.
+ */
+declare function verifySpendAccountPayReconstructs(bytes: string, expected: {
+    kindBytes: string;
+    packageId: string;
+    delegate: string;
+    poolObjectId: string;
+    grantObjectId: string;
+    amount: string;
+}): void;
+/**
+ * Prepare a shared_pool payment WITHOUT signing. Reads the 402 offer, binds it,
+ * gates on the immutable grant snapshot + a fresh authority check, builds the
+ * unsigned transaction, and returns a signing request. The client holding the
+ * delegate key signs locally and submits. This function never decrypts, signs,
+ * sponsors, or submits.
+ */
+declare function prepareSpendAccountPayment(args: {
+    url: string;
+    /** The one normalized paid request, replayed byte for byte after signing. */
+    request?: PaidHttpRequest;
+    session: SpendAccountPrepareSession;
+    cfg: McpConfig;
+    deps?: SpendAccountPayDeps;
+    /** Preferred dialect when the 402 advertises both (default mpp). */
+    preferredDialect?: Dialect;
+}): Promise<SpendAccountPrepareResult>;
+
+/**
+ * Client-side completion of an MCP prepared payment.
+ *
+ * Verifies the server-prepared kind (ADR-0016 §3) then settles through
+ * `payDelegatedSpendAccount` — the same path as direct signer mode. This module
+ * does not implement a second submitter.
+ *
+ * Two hops read a 402, and only one of them was verified. The prepare hop's kind
+ * is checked here; the payer then reads its own offer and builds the bytes it
+ * signs from that. So the verified terms are carried down as `preparedTerms` and
+ * re-asserted against the payer's offer before it signs. Without that carry, the
+ * two hops can price different recipients and nothing would notice.
+ */
+
+declare function settlePreparedMcpPayment(args: {
+    signingRequest: SpendAccountSigningRequest;
+    /**
+     * What this payment is supposed to move, sourced from the caller's intent —
+     * never re-read from the object being verified. Comparing a prepared kind
+     * against fields copied out of the same prepare response proves only that the
+     * response agrees with itself.
+     */
+    expected: {
+        amount: string;
+        recipient: string;
+        delegateAddress: string;
+    };
+    signer: DelegatedKeySigner;
+    getObjectJson: GetObjectJson;
+    session: DelegatedPayerSession;
+    cfg: DelegatedPayerConfig;
+    deps: DelegatedPayerDeps;
+    /**
+     * Agent-declared spend bound. Required when `deps.offerSecret` is absent
+     * (stdio local key): the HMAC is a gateway secret the agent must not need.
+     */
+    intent?: SpendIntent;
+}): Promise<DelegatedPayResult>;
+
+declare function loadBootProfile(load?: typeof loadPaymentProfile): {
+    profile: ReturnType<typeof loadPaymentProfile>;
+    unreadable: boolean;
+};
+declare function main(): Promise<void>;
+
+export { type PreparedPayment, type SpendAccountPrepareResult, type SpendAccountPrepareSession, type SpendAccountSigningRequest, buildSpendAccountPayKind, ensureLocalSigningKey, loadBootProfile, loadLocalSigner, main, prepareSpendAccountPayment, settlePreparedMcpPayment, verifySpendAccountPayReconstructs };

package/dist/index.js

@@ -0,0 +1,45 @@
+import {
+  loadBootProfile,
+  main
+} from "./chunk-TPW6S2K4.js";
+import {
+  PACKAGE_NAME,
+  TOOLS,
+  buildSpendAccountPayKind,
+  canonicalMcpRequestId,
+  createServer,
+  ensureLocalSigningKey,
+  handleSuipayMcpHttpRequest,
+  inspectMcpEnvelope,
+  loadLocalSigner,
+  loadMcpConfig,
+  prepareSpendAccountPayment,
+  resetAgentHeldProcessLedger,
+  resolveAgentHeldSettlement,
+  resolveGrantTarget,
+  settlePreparedMcpPayment,
+  traceMcpHttpRequest,
+  verifySpendAccountPayReconstructs
+} from "./chunk-XZQOOY66.js";
+import "./chunk-A3JIIDYT.js";
+export {
+  PACKAGE_NAME,
+  TOOLS,
+  buildSpendAccountPayKind,
+  canonicalMcpRequestId,
+  createServer,
+  ensureLocalSigningKey,
+  handleSuipayMcpHttpRequest,
+  inspectMcpEnvelope,
+  loadBootProfile,
+  loadLocalSigner,
+  loadMcpConfig,
+  main,
+  prepareSpendAccountPayment,
+  resetAgentHeldProcessLedger,
+  resolveAgentHeldSettlement,
+  resolveGrantTarget,
+  settlePreparedMcpPayment,
+  traceMcpHttpRequest,
+  verifySpendAccountPayReconstructs
+};

package/dist/personal-message-5PF4KVLF.js

@@ -0,0 +1,284 @@
+import {
+  SPEND_ACCOUNT_DEBIT_FUNCTIONS
+} from "./chunk-A3JIIDYT.js";
+
+// ../../src/gateway/sponsor/personal-message.ts
+import { createHash, randomBytes } from "crypto";
+import { bcs } from "@mysten/sui/bcs";
+import {
+  isValidPersonalMessageSignature,
+  verifyPersonalMessageSignature
+} from "@mysten/sui/verify";
+import {
+  fromBase64,
+  normalizeSuiAddress,
+  toBase64
+} from "@mysten/sui/utils";
+import { Transaction } from "@mysten/sui/transactions";
+var SPONSOR_PERSONAL_MESSAGE_DOMAIN = "suipay:sponsor-personal-message:v1";
+var SPONSOR_PERSONAL_MESSAGE_DEFAULT_TTL_MS = 6e4;
+var SPONSOR_PERSONAL_MESSAGE_DEFAULT_GAS_BUDGET_MIST = 50000000n;
+function encodeSponsorPersonalMessagePayload(payload) {
+  if (payload.domain !== SPONSOR_PERSONAL_MESSAGE_DOMAIN) {
+    throw new Error(`domain must be ${SPONSOR_PERSONAL_MESSAGE_DOMAIN}`);
+  }
+  if (payload.txKindHash.length !== 32) {
+    throw new Error("txKindHash must be 32 bytes");
+  }
+  if (!payload.nonce.trim()) throw new Error("nonce is required");
+  if (!Number.isFinite(payload.expiryMs) || payload.expiryMs <= 0) {
+    throw new Error("expiryMs must be a positive finite number");
+  }
+  if (!payload.requestId.trim()) throw new Error("requestId is required");
+  if (!payload.network.trim()) throw new Error("network is required");
+  const parts = [];
+  const push = (u) => parts.push(u);
+  push(
+    bcs.vector(bcs.u8()).serialize([...Buffer.from(payload.domain, "utf8")]).toBytes()
+  );
+  push(
+    bcs.vector(bcs.u8()).serialize([...Buffer.from(payload.nonce, "utf8")]).toBytes()
+  );
+  push(bcs.u64().serialize(BigInt(payload.expiryMs)).toBytes());
+  push(bcs.Address.serialize(normalizeSuiAddress(payload.delegate)).toBytes());
+  push(bcs.Address.serialize(normalizeSuiAddress(payload.poolId)).toBytes());
+  push(bcs.Address.serialize(normalizeSuiAddress(payload.grantId)).toBytes());
+  push(
+    bcs.vector(bcs.u8()).serialize([...Buffer.from(payload.network, "utf8")]).toBytes()
+  );
+  push(bcs.Address.serialize(normalizeSuiAddress(payload.packageId)).toBytes());
+  push(
+    bcs.vector(bcs.u8()).serialize([...Buffer.from(payload.requestId, "utf8")]).toBytes()
+  );
+  push(bcs.vector(bcs.u8()).serialize([...payload.txKindHash]).toBytes());
+  return Buffer.concat(parts.map((p) => Buffer.from(p)));
+}
+function hashTransactionKindBytes(kindBytes) {
+  const raw = typeof kindBytes === "string" ? fromBase64(kindBytes) : kindBytes;
+  return createHash("sha256").update(raw).digest();
+}
+function txKindHashHex(kindBytes) {
+  return Buffer.from(hashTransactionKindBytes(kindBytes)).toString("hex");
+}
+function buildSponsorPersonalMessagePayload(input) {
+  return {
+    domain: SPONSOR_PERSONAL_MESSAGE_DOMAIN,
+    nonce: input.nonce,
+    expiryMs: input.expiryMs,
+    delegate: normalizeSuiAddress(input.delegate),
+    poolId: normalizeSuiAddress(input.poolId),
+    grantId: normalizeSuiAddress(input.grantId),
+    network: input.network,
+    packageId: normalizeSuiAddress(input.packageId),
+    requestId: input.requestId,
+    txKindHash: hashTransactionKindBytes(input.transactionKindBytes)
+  };
+}
+async function verifySponsorPersonalMessageSignature(input) {
+  try {
+    const expected = normalizeSuiAddress(input.expectedDelegate);
+    const encoded = encodeSponsorPersonalMessagePayload(input.payload);
+    const addressMatches = normalizeSuiAddress(input.payload.delegate) === expected;
+    if (!addressMatches) {
+      return { ok: false, reason: "payload_delegate_mismatch" };
+    }
+    try {
+      const publicKey = await verifyPersonalMessageSignature(
+        encoded,
+        input.signature,
+        { address: expected }
+      );
+      const derived = publicKey.toSuiAddress();
+      if (normalizeSuiAddress(derived) !== expected) {
+        return { ok: false, reason: "address_derivation_mismatch" };
+      }
+      return { ok: true, address: expected };
+    } catch {
+      const ok = await isValidPersonalMessageSignature(
+        encoded,
+        input.signature,
+        { address: expected }
+      );
+      if (!ok) return { ok: false, reason: "bad_signature" };
+      return { ok: true, address: expected };
+    }
+  } catch {
+    return { ok: false, reason: "bad_signature" };
+  }
+}
+function assertPersonalMessageKindIsPermittedPay(input) {
+  const allowed = new Set(
+    input.allowedFunctions ?? SPEND_ACCOUNT_DEBIT_FUNCTIONS
+  );
+  let data;
+  try {
+    data = Transaction.fromKind(
+      fromBase64(input.transactionKindBytes)
+    ).getData();
+  } catch {
+    return { ok: false, reason: "kind_invalid" };
+  }
+  if (JSON.stringify(data.commands).includes('"GasCoin"')) {
+    return { ok: false, reason: "kind_gas_coin" };
+  }
+  const commands = data.commands ?? [];
+  if (commands.length !== 1) {
+    return { ok: false, reason: "kind_extra_commands" };
+  }
+  const cmd = commands[0];
+  if (cmd.$kind !== "MoveCall") {
+    return { ok: false, reason: "kind_not_move_call" };
+  }
+  const move = cmd.MoveCall;
+  if (!move) return { ok: false, reason: "kind_missing_move_call" };
+  const pkg = normalizeSuiAddress(String(move.package));
+  const expectedPkg = normalizeSuiAddress(input.packageId);
+  if (pkg !== expectedPkg) {
+    return { ok: false, reason: "kind_package_mismatch" };
+  }
+  if (String(move.module) !== "spend_account") {
+    return { ok: false, reason: "kind_module_not_shared_pool" };
+  }
+  const fn = String(move.function);
+  if (!allowed.has(fn)) {
+    return { ok: false, reason: "kind_function_not_permitted" };
+  }
+  const args = move.arguments ?? [];
+  if (args.length < 2) {
+    return { ok: false, reason: "kind_args_incomplete" };
+  }
+  const poolObj = objectIdFromArg(args[0], data.inputs);
+  const grantObj = objectIdFromArg(args[1], data.inputs);
+  if (!poolObj || !grantObj) {
+    return { ok: false, reason: "kind_object_unresolved" };
+  }
+  if (normalizeSuiAddress(poolObj) !== normalizeSuiAddress(input.poolObjectId)) {
+    return { ok: false, reason: "kind_pool_mismatch" };
+  }
+  if (normalizeSuiAddress(grantObj) !== normalizeSuiAddress(input.grantObjectId)) {
+    return { ok: false, reason: "kind_grant_mismatch" };
+  }
+  return { ok: true, functionName: String(move.function) };
+}
+function assertPersonalMessageDeploymentBinding(input) {
+  const wantNet = input.expectedNetwork.trim().toLowerCase();
+  const gotNet = input.network.trim().toLowerCase();
+  if (!wantNet || gotNet !== wantNet) {
+    return { ok: false, reason: "network_mismatch" };
+  }
+  try {
+    if (normalizeSuiAddress(input.packageId) !== normalizeSuiAddress(input.expectedPackageId)) {
+      return { ok: false, reason: "package_mismatch" };
+    }
+  } catch {
+    return { ok: false, reason: "package_mismatch" };
+  }
+  return { ok: true };
+}
+function publicSponsorGrantDenyReason(reason) {
+  const r = reason.toLowerCase();
+  if (r.includes("expired")) return "grant_expired";
+  if (r.includes("revok")) return "grant_revoked";
+  if (r.includes("paus")) return "grant_paused";
+  if (r.includes("not active") || r.includes("not_active")) {
+    return "grant_not_active";
+  }
+  if (r.includes("no active") || r.includes("not found") || r.includes("missing")) {
+    return "grant_not_found";
+  }
+  return "grant_not_authorized";
+}
+function objectIdFromArg(arg, inputs) {
+  if (!arg || typeof arg !== "object") return null;
+  const a = arg;
+  if (a.$kind !== "Input" || !Number.isInteger(a.Input)) return null;
+  const input = inputs?.[Number(a.Input)];
+  if (!input || typeof input !== "object") return null;
+  const value = input;
+  if (value.$kind !== "Object" || !value.Object) return null;
+  const object = value.Object;
+  const id = object.$kind === "SharedObject" ? object.SharedObject?.objectId : object.$kind === "ImmOrOwnedObject" ? object.ImmOrOwnedObject?.objectId : object.$kind === "Receiving" ? object.Receiving?.objectId : void 0;
+  return typeof id === "string" ? id : null;
+}
+function createResolveSponsorGrant(store) {
+  return async (query) => {
+    const found = await store.findActiveGrantForPersonalMessage({
+      grantObjectId: query.grantObjectId,
+      poolObjectId: query.poolObjectId,
+      delegateAddress: query.delegateAddress
+    });
+    if (!found) {
+      return { ok: false, reason: "grant_not_found" };
+    }
+    const expiresAtMs = Number(found.grant.expiresAtMs);
+    if (Number.isFinite(expiresAtMs) && expiresAtMs > 0 && expiresAtMs <= query.nowMs) {
+      return { ok: false, reason: "grant_expired" };
+    }
+    if (found.grant.status === "revoked") {
+      return { ok: false, reason: "grant_revoked" };
+    }
+    if (found.grant.status !== "active") {
+      return { ok: false, reason: "grant_not_active" };
+    }
+    if (found.aggregateStatus === "paused" || found.aggregateStatus === "pausing") {
+      return { ok: false, reason: "grant_paused" };
+    }
+    if (found.aggregateStatus === "revoking" || found.aggregateStatus === "partially_revoked" || found.aggregateStatus === "revoked") {
+      return { ok: false, reason: "grant_revoked" };
+    }
+    if (!found.grant.grantObjectId) {
+      return { ok: false, reason: "grant_not_found" };
+    }
+    return {
+      ok: true,
+      grant: {
+        delegateAddress: normalizeSuiAddress(found.agentAddress),
+        poolObjectId: normalizeSuiAddress(found.grant.poolObjectId),
+        grantObjectId: normalizeSuiAddress(found.grant.grantObjectId),
+        expiresAtMs: Number.isFinite(expiresAtMs) ? expiresAtMs : 0,
+        status: "active"
+      }
+    };
+  };
+}
+function mintSponsorChallengeNonce() {
+  return randomBytes(24).toString("base64url");
+}
+function mintSponsorExecuteToken() {
+  return randomBytes(24).toString("base64url");
+}
+async function signSponsorPersonalMessagePayload(input) {
+  const encoded = encodeSponsorPersonalMessagePayload(input.payload);
+  return input.signPersonalMessage(encoded);
+}
+function bytesToHex(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function hexToBytes32(hex) {
+  const h = hex.replace(/^0x/i, "").toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(h)) {
+    throw new Error(`expected 32-byte hex, got ${hex}`);
+  }
+  return Buffer.from(h, "hex");
+}
+export {
+  SPONSOR_PERSONAL_MESSAGE_DEFAULT_GAS_BUDGET_MIST,
+  SPONSOR_PERSONAL_MESSAGE_DEFAULT_TTL_MS,
+  SPONSOR_PERSONAL_MESSAGE_DOMAIN,
+  assertPersonalMessageDeploymentBinding,
+  assertPersonalMessageKindIsPermittedPay,
+  buildSponsorPersonalMessagePayload,
+  bytesToHex,
+  createResolveSponsorGrant,
+  encodeSponsorPersonalMessagePayload,
+  fromBase64,
+  hashTransactionKindBytes,
+  hexToBytes32,
+  mintSponsorChallengeNonce,
+  mintSponsorExecuteToken,
+  publicSponsorGrantDenyReason,
+  signSponsorPersonalMessagePayload,
+  toBase64,
+  txKindHashHex,
+  verifySponsorPersonalMessageSignature
+};