@zktx.io/sui-mcp 0.5.0

package/dist/core/session/keyedRecordStore.js

@@ -0,0 +1,18 @@
+export class InMemoryKeyedRecordStore {
+    records = new Map();
+    get(id) {
+        return this.records.get(id);
+    }
+    set(id, value) {
+        this.records.set(id, value);
+    }
+    delete(id) {
+        this.records.delete(id);
+    }
+    ids() {
+        return [...this.records.keys()];
+    }
+    clear() {
+        this.records.clear();
+    }
+}

package/dist/core/session/liveReviewSessionContract.js

@@ -0,0 +1,3 @@
+export const LIVE_REVIEW_SESSION_WRITE_CONTRACT_VERSION = "shared_sqlite_review_session_v1";
+export const LIVE_REVIEW_SESSION_INSERT_TRIGGER = "trg_live_review_sessions_contract_insert";
+export const LIVE_REVIEW_SESSION_UPDATE_TRIGGER = "trg_live_review_sessions_contract_update";

package/dist/core/session/localSession.js

@@ -0,0 +1,31 @@
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+export const DEFAULT_SESSION_TTL_MS = 30 * 60 * 1000;
+export function createLocalSessionBase(now, ttlMs) {
+    const id = randomBytes(18).toString("base64url");
+    const token = randomBytes(32).toString("base64url");
+    const createdAt = now.toISOString();
+    return {
+        base: {
+            id,
+            tokenHash: hashToken(token),
+            createdAt,
+            expiresAt: new Date(now.getTime() + ttlMs).toISOString(),
+            lastActivityAt: createdAt
+        },
+        token
+    };
+}
+export function hashToken(token) {
+    return createHash("sha256").update(token).digest("hex");
+}
+export function tokenMatchesHash(tokenHash, token) {
+    const expected = Buffer.from(tokenHash, "hex");
+    const actual = Buffer.from(hashToken(token), "hex");
+    return expected.length === actual.length && timingSafeEqual(expected, actual);
+}
+export function isLocalSessionExpired(session, now) {
+    return new Date(session.expiresAt).getTime() <= now.getTime();
+}
+export function cloneLocalSession(value) {
+    return structuredClone(value);
+}

package/dist/core/session/privateReviewArtifacts.js

@@ -0,0 +1,75 @@
+import { transactionFundingEvidenceSchema } from "../action/transactionFunding.js";
+import { parseHumanReadableReviewEvidence } from "../action/humanReadableReviewEvidence.js";
+import { parseReviewTimeSimulationEvidence } from "../action/reviewTimeSimulationEvidence.js";
+export function clonePrivateReviewArtifacts(artifacts) {
+    return {
+        ...(artifacts.transactionMaterial
+            ? { transactionMaterial: { ...artifacts.transactionMaterial } }
+            : {}),
+        ...(artifacts.transactionMaterialDigest
+            ? { transactionMaterialDigest: { ...artifacts.transactionMaterialDigest } }
+            : {}),
+        ...(artifacts.swapQuotePolicy
+            ? {
+                swapQuotePolicy: {
+                    ...artifacts.swapQuotePolicy,
+                    quoteSource: { ...artifacts.swapQuotePolicy.quoteSource },
+                    sourceAmount: {
+                        ...artifacts.swapQuotePolicy.sourceAmount,
+                        asset: { ...artifacts.swapQuotePolicy.sourceAmount.asset }
+                    },
+                    expectedOutput: {
+                        ...artifacts.swapQuotePolicy.expectedOutput,
+                        asset: { ...artifacts.swapQuotePolicy.expectedOutput.asset }
+                    },
+                    minimumOutput: {
+                        ...artifacts.swapQuotePolicy.minimumOutput,
+                        asset: { ...artifacts.swapQuotePolicy.minimumOutput.asset }
+                    },
+                    protocolFee: {
+                        ...artifacts.swapQuotePolicy.protocolFee,
+                        asset: { ...artifacts.swapQuotePolicy.protocolFee.asset }
+                    }
+                }
+            }
+            : {}),
+        ...(artifacts.transactionObjectOwnership
+            ? {
+                transactionObjectOwnership: {
+                    ...artifacts.transactionObjectOwnership,
+                    funding: transactionFundingEvidenceSchema.parse(structuredClone(artifacts.transactionObjectOwnership.funding)),
+                    objects: artifacts.transactionObjectOwnership.objects.map((object) => ({
+                        ...object,
+                        roles: [...object.roles]
+                    }))
+                }
+            }
+            : {}),
+        ...(artifacts.humanReadableReview
+            ? {
+                humanReadableReview: parseHumanReadableReviewEvidence(structuredClone(artifacts.humanReadableReview))
+            }
+            : {}),
+        ...(artifacts.reviewTimeSimulation
+            ? {
+                reviewTimeSimulation: parseReviewTimeSimulationEvidence(structuredClone(artifacts.reviewTimeSimulation))
+            }
+            : {})
+    };
+}
+export class InMemoryPrivateReviewArtifactStore {
+    artifacts = new Map();
+    get(reviewSessionId) {
+        const artifacts = this.artifacts.get(reviewSessionId);
+        return artifacts ? clonePrivateReviewArtifacts(artifacts) : undefined;
+    }
+    set(reviewSessionId, artifacts) {
+        this.artifacts.set(reviewSessionId, clonePrivateReviewArtifacts(artifacts));
+    }
+    delete(reviewSessionId) {
+        this.artifacts.delete(reviewSessionId);
+    }
+    clear() {
+        this.artifacts.clear();
+    }
+}

package/dist/core/session/reviewValidity.js

@@ -0,0 +1,49 @@
+import { isDeepStrictEqual } from "node:util";
+import { REVIEW_MATERIAL_DERIVED_FIELDS } from "../action/types.js";
+import { sameHandle } from "./transactionMaterialStore.js";
+import { SessionStoreError } from "./sessionErrors.js";
+export function needsReviewMaterial(session, admitted) {
+    return !admitted && !session.preparationId && session.status !== "expired" &&
+        !!session.reviewState && REVIEW_MATERIAL_DERIVED_FIELDS.some((field) => session.reviewState[field] !== undefined);
+}
+export function invalidateReviewEvidence(session, now) {
+    if (session.reviewState && session.reviewState.status !== "ready_for_wallet_review") {
+        const state = { ...session.reviewState, evidenceValidity: "invalidated", updatedAt: now.toISOString() };
+        for (const field of REVIEW_MATERIAL_DERIVED_FIELDS)
+            delete state[field];
+        // Keep the computation's failure reason, checks and stage provenance. Their
+        // presence describes that failed attempt, not currently usable material.
+        return { ...session, lastActivityAt: now.toISOString(), reviewState: state };
+    }
+    return { ...session, status: "refresh_required", lastActivityAt: now.toISOString(),
+        ...(session.reviewState ? { reviewState: {
+                planId: session.reviewState.planId, reviewSessionId: session.id, account: session.reviewState.account,
+                status: "refresh_required", refreshReason: "review_evidence_stale",
+                checks: [{ id: "private_review_artifacts_refresh_required", label: "Review details out of date", status: "fail",
+                        message: "These review details are no longer current.", source: "adapter" }],
+                updatedAt: now.toISOString()
+            } } : {}) };
+}
+export function materialStillMatches(verified, session, rowRevision, artifacts, material, now) {
+    return session.id === verified.reviewSessionId && session.reviewRevision === verified.reviewRevision &&
+        rowRevision === verified.rowRevision && session.account === verified.account &&
+        session.reviewState?.planId === verified.planId &&
+        isDeepStrictEqual(artifacts, verified.artifacts) && !!artifacts?.transactionMaterial && sameHandle(artifacts.transactionMaterial, verified.transactionMaterial) &&
+        isDeepStrictEqual(artifacts.transactionMaterialDigest, verified.transactionMaterialDigest) &&
+        !!material && sameHandle(material, verified.transactionMaterial) && Date.parse(material.expiresAt) > now.getTime() &&
+        Buffer.from(material.transactionBytes).toString("base64") === verified.transactionBytesBase64;
+}
+// The caller owns a synchronous transaction and supplies its one decision time.
+export function decideReviewEvaluation(candidate, current, rowRevision, artifacts, material, admitted, now) {
+    if (current.status !== "expired" && Date.parse(current.expiresAt) <= now.getTime()) {
+        return { ...current, status: "expired" };
+    }
+    if (!needsReviewMaterial(current, admitted))
+        return current;
+    if (candidate.rowRevision !== rowRevision || !isDeepStrictEqual(candidate.session, current) ||
+        !isDeepStrictEqual(candidate.artifacts, artifacts)) {
+        throw new SessionStoreError("invalid_session_transition", "The review changed while it was being checked.", { reason: "review_changed_during_verification", message: "The review changed while it was being checked." });
+    }
+    return candidate.material && materialStillMatches(candidate.material, current, rowRevision, artifacts, material, now)
+        ? current : invalidateReviewEvidence(current, now);
+}

package/dist/core/session/sessionErrors.js

@@ -0,0 +1,9 @@
+export class SessionStoreError extends Error {
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}

package/dist/core/session/sessionRecordStore.js

@@ -0,0 +1,40 @@
+import { isDeepStrictEqual } from "node:util";
+import { cloneLocalSession } from "./localSession.js";
+export class InMemorySessionRecordStore {
+    sessions = new Map();
+    revisions = new Map();
+    usesActivityStoreLiveSessionMutations = false;
+    get(id) {
+        const session = this.sessions.get(id);
+        return session ? cloneLocalSession(session) : undefined;
+    }
+    revision(id) { return this.revisions.get(id); }
+    hasAdmittedRevision(_id, _reviewRevision) { return false; }
+    create(id, session) {
+        if (this.sessions.has(id)) {
+            throw new Error(`Review session already exists: ${id}`);
+        }
+        this.sessions.set(id, cloneLocalSession(session));
+        this.revisions.set(id, 0);
+    }
+    commitReviewSessionTransition(id, expected, next) {
+        const current = this.sessions.get(id);
+        if (!current || !isDeepStrictEqual(current, expected)) {
+            return false;
+        }
+        this.sessions.set(id, cloneLocalSession(next));
+        this.revisions.set(id, this.revisions.get(id) + 1);
+        return true;
+    }
+    ids() {
+        return [...this.sessions.keys()];
+    }
+    clear() {
+        this.sessions.clear();
+        this.revisions.clear();
+    }
+    hasUnsettledRequest(_id, _now) {
+        // This preparation-only fixture owns no wallet request records.
+        return false;
+    }
+}