@zktx.io/sui-mcp 0.5.0

package/dist/core/action/transactionObjectOwnershipEvidence.js

@@ -0,0 +1,256 @@
+import { Transaction } from "@mysten/sui/transactions";
+import { transactionFundingEvidenceSchema, describeTransactionFunding, assertTransactionFundingMatches } from "./transactionFunding.js";
+import { z } from "zod";
+import { isValidStructTag, normalizeStructTag } from "@mysten/sui/utils";
+import { adapterEvidenceClaimSchema, adapterGasObjectOwnershipLinkSchema, adapterObjectOwnershipEvidenceSchema, adapterSourceOfTruthSchema, SUI_GAS_COIN_TYPE } from "./signableAdapterContract.js";
+import { normalizedSuiAddressSchema, suiTransactionDigestSchema } from "../suiAddress.js";
+export const TRANSACTION_OBJECT_OWNERSHIP_EVIDENCE_VERSION = "transaction-object-ownership-v2";
+export const TRANSACTION_OBJECT_ROLES = [
+    "gas_object",
+    "imm_or_owned_object",
+    "shared_object",
+    "receiving_object"
+];
+export const TRANSACTION_OBJECT_OWNERSHIP_STATUSES = [
+    "owned_by_account",
+    "not_owned_by_account",
+    "shared_object",
+    "immutable_object",
+    "object_owner",
+    "consensus_address_owner",
+    "unknown_owner"
+];
+const isoUtcStringSchema = z.string().refine((value) => {
+    const parsed = new Date(value);
+    return Number.isFinite(parsed.getTime()) && parsed.toISOString() === value;
+}, "Expected ISO 8601 UTC timestamp");
+const moveStructTagSchema = z.string().min(1).max(512).refine((value) => isValidStructTag(value), "Expected valid Move struct tag").transform((value) => normalizeStructTag(value));
+export const transactionObjectOwnershipFactSchema = z.object({
+    objectId: normalizedSuiAddressSchema,
+    roles: z.array(z.enum(TRANSACTION_OBJECT_ROLES)).min(1),
+    ownership: z.enum(TRANSACTION_OBJECT_OWNERSHIP_STATUSES),
+    ownerKind: z.string().min(1).max(80),
+    ownerAccount: normalizedSuiAddressSchema.optional(),
+    objectType: moveStructTagSchema,
+    source: z.literal("stored_transaction_data_and_mainnet_object_read")
+}).strict().superRefine((value, ctx) => {
+    if (new Set(value.roles).size !== value.roles.length) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["roles"],
+            message: "roles must be unique"
+        });
+    }
+});
+export const transactionObjectOwnershipEvidenceSchema = z.object({
+    evidenceVersion: z.literal(TRANSACTION_OBJECT_OWNERSHIP_EVIDENCE_VERSION),
+    materialId: z.string().min(1),
+    reviewSessionId: z.string().min(1),
+    planId: z.string().min(1),
+    account: normalizedSuiAddressSchema,
+    transactionDigest: suiTransactionDigestSchema,
+    funding: transactionFundingEvidenceSchema,
+    objectCount: z.number().int().min(1),
+    objects: z.array(transactionObjectOwnershipFactSchema).min(1),
+    verifiedAt: isoUtcStringSchema,
+    expiresAt: isoUtcStringSchema
+}).strict().superRefine((value, ctx) => {
+    if (value.account !== value.funding.sender) {
+        ctx.addIssue({ code: "custom", path: ["funding", "sender"], message: "Funding must match the ownership account" });
+    }
+    if (value.objectCount !== value.objects.length) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["objectCount"],
+            message: "objectCount must equal objects.length"
+        });
+    }
+    if (new Set(value.objects.map((object) => object.objectId)).size !== value.objects.length) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["objects"],
+            message: "objects must have unique objectId values"
+        });
+    }
+    const verifiedAtMs = Date.parse(value.verifiedAt);
+    const expiresAtMs = Date.parse(value.expiresAt);
+    if (expiresAtMs <= verifiedAtMs) {
+        ctx.addIssue({
+            code: "custom",
+            path: ["expiresAt"],
+            message: "expiresAt must be after verifiedAt"
+        });
+    }
+});
+export function parseSuiCoinObjectType(objectType) {
+    if (!isValidStructTag(objectType)) {
+        return { status: "not_coin" };
+    }
+    const normalized = normalizeStructTag(objectType);
+    const coinPrefix = `${normalizeStructTag("0x2::coin::Coin<0x2::sui::SUI>").split("<")[0]}<`;
+    if (!normalized.startsWith(coinPrefix) || !normalized.endsWith(">")) {
+        return { status: "not_coin" };
+    }
+    const coinType = normalized.slice(coinPrefix.length, -1);
+    if (!isValidStructTag(coinType)) {
+        return { status: "not_coin" };
+    }
+    return {
+        status: "coin",
+        objectType: normalized,
+        coinType: normalizeStructTag(coinType)
+    };
+}
+export function parseTransactionObjectOwnershipEvidence(value) {
+    return transactionObjectOwnershipEvidenceSchema.parse(value);
+}
+export function verifyTransactionObjectOwnershipEvidence(input) {
+    const evidence = parseTransactionObjectOwnershipEvidence(input.evidence);
+    assertTransactionFundingMatches(describeTransactionFunding(Transaction.from(input.transactionBytes).getData(), input.transactionMaterial.account, evidence.funding.chainIdentifier), evidence.funding);
+    const now = input.now ?? new Date();
+    const nowMs = now.getTime();
+    if (!Number.isFinite(nowMs)) {
+        throw new Error("now must be a valid Date");
+    }
+    if (evidence.materialId !== input.transactionMaterial.materialId ||
+        evidence.reviewSessionId !== input.transactionMaterial.reviewSessionId ||
+        evidence.planId !== input.transactionMaterial.planId ||
+        evidence.account !== input.transactionMaterial.account ||
+        evidence.expiresAt !== input.transactionMaterial.expiresAt ||
+        evidence.transactionDigest !== input.transactionMaterialDigest.transactionDigest) {
+        throw new Error("transaction object ownership evidence must match material and digest identity");
+    }
+    if (input.transactionMaterialDigest.materialId !== input.transactionMaterial.materialId ||
+        input.transactionMaterialDigest.reviewSessionId !== input.transactionMaterial.reviewSessionId ||
+        input.transactionMaterialDigest.planId !== input.transactionMaterial.planId ||
+        input.transactionMaterialDigest.account !== input.transactionMaterial.account ||
+        input.transactionMaterialDigest.expiresAt !== input.transactionMaterial.expiresAt) {
+        throw new Error("transaction material digest must match material identity before ownership evidence is accepted");
+    }
+    const materialCreatedAtMs = Date.parse(input.transactionMaterial.createdAt);
+    const verifiedAtMs = Date.parse(evidence.verifiedAt);
+    const expiresAtMs = Date.parse(evidence.expiresAt);
+    if (verifiedAtMs < materialCreatedAtMs || verifiedAtMs > nowMs || verifiedAtMs >= expiresAtMs) {
+        throw new Error("transaction object ownership verifiedAt must be between material creation, now, and material expiry");
+    }
+    if (expiresAtMs <= nowMs) {
+        throw new Error("transaction object ownership evidence must not be expired");
+    }
+    const contractMapping = mapTransactionObjectOwnershipEvidenceToContractDraft(evidence);
+    if (contractMapping.status === "unsupported") {
+        throw new Error(`transaction object ownership evidence is not contract-mappable: ${contractMapping.reason}`);
+    }
+    return evidence;
+}
+export function mapTransactionObjectOwnershipEvidenceToContractDraft(evidenceInput) {
+    const evidence = parseTransactionObjectOwnershipEvidence(evidenceInput);
+    const sourceEvidenceId = "tx_object_ownership_source";
+    const claims = [];
+    const objects = [];
+    const gasObjectOwnershipLinks = [];
+    for (const [index, object] of evidence.objects.entries()) {
+        const mapped = mapOwnershipFactForContract(object);
+        if (mapped.status === "unsupported") {
+            return {
+                ...mapped,
+                objectId: object.objectId,
+                roles: object.roles,
+                ownership: object.ownership
+            };
+        }
+        const evidenceClaimId = `tx_object_ownership:${index}`;
+        claims.push(adapterEvidenceClaimSchema.parse({
+            id: evidenceClaimId,
+            factKind: "object_ownership",
+            sourceEvidenceId,
+            objectId: object.objectId,
+            ownerAccount: evidence.account,
+            ownership: mapped.ownership
+        }));
+        objects.push({
+            objectId: object.objectId,
+            role: mapped.role,
+            ownership: mapped.ownership,
+            evidenceClaimId
+        });
+        if (mapped.role === "gas_coin" && mapped.ownership === "owned_by_account") {
+            gasObjectOwnershipLinks.push(adapterGasObjectOwnershipLinkSchema.parse({
+                objectId: object.objectId,
+                ownerAccount: evidence.account,
+                ownershipClaimId: evidenceClaimId
+            }));
+        }
+    }
+    if (gasObjectOwnershipLinks.length !== evidence.funding.gasObjectIds.length ||
+        gasObjectOwnershipLinks.some((link) => !evidence.funding.gasObjectIds.includes(link.objectId)) ||
+        (gasObjectOwnershipLinks.length === 0 && evidence.funding.gasMode === "coin_objects")) {
+        return {
+            status: "unsupported",
+            reason: "contract gas ownership links must cover exactly the real gas objects in the verified funding evidence",
+            objectId: evidence.objects[0]?.objectId ?? "unknown",
+            roles: evidence.objects[0]?.roles ?? [],
+            ownership: evidence.objects[0]?.ownership ?? "unknown_owner"
+        };
+    }
+    if (!objects.some((object) => object.role !== "gas_coin")) {
+        return {
+            status: "unsupported",
+            reason: "contract mapping requires the full transaction object set, not gas-only ownership evidence",
+            objectId: evidence.objects[0]?.objectId ?? "unknown",
+            roles: evidence.objects[0]?.roles ?? [],
+            ownership: evidence.objects[0]?.ownership ?? "unknown_owner"
+        };
+    }
+    return {
+        status: "mapped",
+        sourceReferences: adapterSourceOfTruthSchema.parse({
+            id: sourceEvidenceId,
+            kind: "wallet_account_read",
+            network: "sui:mainnet",
+            source: "Stored local transaction data object refs plus Sui mainnet object owner reads",
+            verifiedAt: evidence.verifiedAt,
+            fields: ["ownerAccount", "objects"]
+        }),
+        evidenceClaims: claims,
+        objectOwnership: adapterObjectOwnershipEvidenceSchema.parse({
+            checkedAt: evidence.verifiedAt,
+            ownerAccount: evidence.account,
+            objects
+        }),
+        gasObjectOwnershipLinks
+    };
+}
+function mapOwnershipFactForContract(fact) {
+    if (fact.roles.includes("gas_object")) {
+        const coinObject = parseSuiCoinObjectType(fact.objectType);
+        return fact.ownership === "owned_by_account" &&
+            coinObject.status === "coin" &&
+            coinObject.coinType === SUI_GAS_COIN_TYPE
+            ? { status: "mapped", role: "gas_coin", ownership: "owned_by_account" }
+            : { status: "unsupported", reason: "gas objects must be owned by the connected account and be Coin<SUI> objects" };
+    }
+    if (fact.roles.includes("shared_object")) {
+        return fact.ownership === "shared_object"
+            ? { status: "mapped", role: "shared_object", ownership: "shared_object" }
+            : { status: "unsupported", reason: "shared object refs must have shared ownership facts" };
+    }
+    if (fact.roles.includes("receiving_object")) {
+        return fact.ownership === "owned_by_account"
+            ? { status: "mapped", role: "receiving_object", ownership: "owned_by_account" }
+            : { status: "unsupported", reason: "receiving object refs must be owned by the connected account" };
+    }
+    if (fact.roles.includes("imm_or_owned_object")) {
+        if (fact.ownership === "immutable_object") {
+            return { status: "mapped", role: "protocol_object", ownership: "immutable_or_package" };
+        }
+        const coinObject = parseSuiCoinObjectType(fact.objectType);
+        if (fact.ownership === "owned_by_account" && coinObject.status === "coin") {
+            return { status: "mapped", role: "input_coin", ownership: "owned_by_account" };
+        }
+        return {
+            status: "unsupported",
+            reason: "owned ImmOrOwnedObject refs must be Coin<T> objects before contract mapping can call them input coins"
+        };
+    }
+    return { status: "unsupported", reason: "object ownership role is not contract-mappable" };
+}

package/dist/core/action/transactionObjectOwnershipProducer.js

@@ -0,0 +1,323 @@
+import { describeTransactionFunding, readTransactionFunding, TransactionFundingError } from "./transactionFunding.js";
+import { Transaction } from "@mysten/sui/transactions";
+import { mapTransactionObjectOwnershipEvidenceToContractDraft, parseTransactionObjectOwnershipEvidence, TRANSACTION_OBJECT_OWNERSHIP_EVIDENCE_VERSION } from "./transactionObjectOwnershipEvidence.js";
+import { failReviewCheck, passReviewCheck } from "./reviewCheckResults.js";
+import { parseSuiAddress } from "../suiAddress.js";
+import { LocalTransactionMaterialStoreError, verifyLocalTransactionMaterialArtifacts } from "../session/transactionMaterialStore.js";
+export function createTransactionObjectOwnershipProducer(options) {
+    return async (input) => {
+        if (options.network !== "mainnet" || options.chainIdentifier !== options.expectedChainIdentifier) {
+            return {
+                status: "blocked",
+                blockedReason: "network_mismatch",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_network_mismatch", "Object ownership network", "Object ownership evidence requires a verified Sui mainnet object source and matching mainnet chain identifier.", "network")
+                ]
+            };
+        }
+        let materialHandle;
+        let materialDigest;
+        try {
+            const verified = await verifyLocalTransactionMaterialArtifacts({
+                materialStore: options.materialStore,
+                transactionMaterial: input.materialHandle,
+                transactionMaterialDigest: input.materialDigest,
+                now: input.now
+            });
+            materialHandle = verified.transactionMaterial;
+            materialDigest = verified.transactionMaterialDigest;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "transaction material is unavailable";
+            const check = failReviewCheck("transaction_object_ownership_material_unavailable", "Object ownership material", "Object ownership evidence was not produced because the stored local transaction material was unavailable, stale, or not bound to its internal digest.", "adapter");
+            if (message.includes("expired") || message.includes("unavailable")) {
+                return {
+                    status: "refresh_required",
+                    refreshReason: "quote_stale",
+                    checks: [check]
+                };
+            }
+            return {
+                status: "blocked",
+                blockedReason: "object_resolution_failed",
+                checks: [check]
+            };
+        }
+        const material = options.materialStore.getTransactionMaterial(materialHandle, input.now);
+        if (!material) {
+            return {
+                status: "refresh_required",
+                refreshReason: "quote_stale",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_material_unavailable", "Object ownership material", "Object ownership evidence was not produced because the stored local transaction material was unavailable or expired; refresh the review evidence before continuing.", "adapter")
+                ]
+            };
+        }
+        let objectRefs;
+        let funding;
+        try {
+            const description = describeTransactionFunding(Transaction.from(material.transactionBytes).getData(), materialHandle.account, options.chainIdentifier);
+            funding = await readTransactionFunding(description, options.fundingSource);
+            objectRefs = extractObjectRefsFromStoredTransactionBytes(material.transactionBytes, funding.gasObjectIds);
+        }
+        catch (error) {
+            if (error instanceof TransactionFundingError)
+                return { status: "blocked",
+                    blockedReason: error.kind === "insufficient_balance" || error.kind === "insufficient_gas" ? error.kind : "object_resolution_failed",
+                    checks: [failReviewCheck("transaction_funding_" + error.kind, "Transaction funding", error.message, error.kind === "unavailable" ? "network" : "wallet")] };
+            return {
+                status: "blocked",
+                blockedReason: "object_resolution_failed",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_refs_unavailable", "Object ownership refs", "Transaction funding and object ownership could not be verified because the stored material has invalid or unsupported account, gas, withdrawal, expiration or object references.", "adapter")
+                ]
+            };
+        }
+        const objectRoles = mergeObjectRoles(objectRefs);
+        if (objectRoles.size === 0) {
+            return {
+                status: "blocked",
+                blockedReason: "object_resolution_failed",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_refs_empty", "Object ownership refs", "Object ownership evidence requires at least one resolved transaction object reference.", "adapter")
+                ]
+            };
+        }
+        const facts = [];
+        for (const [objectId, roles] of objectRoles) {
+            let response;
+            try {
+                response = await options.objectSource.getObject({ objectId });
+            }
+            catch {
+                return objectReadBlocked();
+            }
+            if (parseSuiObjectId(response.object.objectId) !== objectId) {
+                return objectReadBlocked();
+            }
+            const fact = classifyObjectOwnership({
+                objectId,
+                roles,
+                owner: response.object.owner,
+                objectType: response.object.type,
+                account: materialHandle.account
+            });
+            if (!fact) {
+                return objectReadBlocked();
+            }
+            facts.push(fact);
+        }
+        const invalidFact = facts.find((fact) => !isAcceptableOwnershipFact(fact));
+        if (invalidFact) {
+            const blockedReason = "object_resolution_failed";
+            return {
+                status: "blocked",
+                blockedReason,
+                checks: [
+                    failReviewCheck("transaction_object_ownership_unverified", "Object ownership", "An object's ownership could not be confirmed, or an account-owned transaction or gas object belongs to a different account.", invalidFact.roles.includes("gas_object") ? "wallet" : "adapter")
+                ]
+            };
+        }
+        let evidence;
+        try {
+            evidence = parseTransactionObjectOwnershipEvidence({
+                evidenceVersion: TRANSACTION_OBJECT_OWNERSHIP_EVIDENCE_VERSION,
+                materialId: materialHandle.materialId,
+                reviewSessionId: materialHandle.reviewSessionId,
+                planId: materialHandle.planId,
+                account: materialHandle.account,
+                transactionDigest: materialDigest.transactionDigest,
+                funding,
+                objectCount: facts.length,
+                objects: facts,
+                verifiedAt: input.now.toISOString(),
+                expiresAt: materialHandle.expiresAt
+            });
+        }
+        catch {
+            return objectReadBlocked();
+        }
+        const contractMapping = mapTransactionObjectOwnershipEvidenceToContractDraft(evidence);
+        if (contractMapping.status === "unsupported") {
+            return {
+                status: "blocked",
+                blockedReason: "object_resolution_failed",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_contract_mapping_unsupported", "Object ownership contract mapping", `The object ownership checks could not be used for this transaction review. Reported reason: “${contractMapping.reason}”.`, contractMapping.roles.includes("gas_object") ? "wallet" : "adapter")
+                ]
+            };
+        }
+        return {
+            status: "completed",
+            evidence,
+            checks: [
+                passReviewCheck("transaction_object_ownership_verified", "Object ownership", "Checked the transaction objects against Sui mainnet. The gas objects and account-owned coins belong to the connected account; shared or immutable protocol objects are recorded separately. These ownership checks do not authorize wallet approval or guarantee execution.", "wallet")
+            ]
+        };
+    };
+}
+function extractObjectRefsFromStoredTransactionBytes(transactionBytes, gasObjectIds) {
+    const transaction = Transaction.from(transactionBytes);
+    const data = transaction.getData();
+    const refs = [];
+    for (const objectId of gasObjectIds)
+        refs.push({ objectId, role: "gas_object" });
+    for (const input of data.inputs) {
+        const inputKind = enumKind(input, [
+            "Object",
+            "Pure",
+            "UnresolvedPure",
+            "UnresolvedObject",
+            "FundsWithdrawal"
+        ]);
+        if (!inputKind) {
+            throw new LocalTransactionMaterialStoreError("unknown transaction input kind");
+        }
+        if (inputKind === "Pure" || inputKind === "UnresolvedPure" || inputKind === "FundsWithdrawal") {
+            continue;
+        }
+        if (inputKind === "UnresolvedObject") {
+            throw new LocalTransactionMaterialStoreError("transaction object refs must be resolved");
+        }
+        const objectInput = input.Object;
+        const objectKind = enumKind(objectInput, [
+            "ImmOrOwnedObject",
+            "SharedObject",
+            "Receiving"
+        ]);
+        if (!objectKind) {
+            throw new LocalTransactionMaterialStoreError("unknown transaction object input kind");
+        }
+        if (objectKind === "ImmOrOwnedObject") {
+            refs.push({
+                objectId: readObjectId(objectInput.ImmOrOwnedObject),
+                role: "imm_or_owned_object"
+            });
+        }
+        else if (objectKind === "SharedObject") {
+            refs.push({
+                objectId: readObjectId(objectInput.SharedObject),
+                role: "shared_object"
+            });
+        }
+        else {
+            refs.push({
+                objectId: readObjectId(objectInput.Receiving),
+                role: "receiving_object"
+            });
+        }
+    }
+    return refs;
+}
+function enumKind(value, allowedKinds) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    if ("$kind" in value) {
+        return typeof value.$kind === "string" && allowedKinds.includes(value.$kind)
+            ? value.$kind
+            : undefined;
+    }
+    const matchingKeys = allowedKinds.filter((kind) => kind in value);
+    return matchingKeys.length === 1 ? matchingKeys[0] : undefined;
+}
+function readObjectId(value) {
+    if (!isRecord(value) || typeof value.objectId !== "string") {
+        throw new LocalTransactionMaterialStoreError("transaction object ref is missing objectId");
+    }
+    return parseSuiObjectId(value.objectId);
+}
+function parseSuiObjectId(value) {
+    const objectId = parseSuiAddress(value);
+    if (!objectId) {
+        throw new LocalTransactionMaterialStoreError("transaction object ref has invalid Sui object id");
+    }
+    return objectId;
+}
+function mergeObjectRoles(refs) {
+    const merged = new Map();
+    for (const ref of refs) {
+        const roles = merged.get(ref.objectId) ?? [];
+        if (!roles.includes(ref.role)) {
+            roles.push(ref.role);
+        }
+        merged.set(ref.objectId, roles);
+    }
+    return merged;
+}
+function classifyObjectOwnership(input) {
+    if (!isRecord(input.owner) || typeof input.owner.$kind !== "string") {
+        return undefined;
+    }
+    if (typeof input.objectType !== "string") {
+        return undefined;
+    }
+    if (input.owner.$kind === "AddressOwner") {
+        const ownerAccount = parseSuiAddress(typeof input.owner.AddressOwner === "string" ? input.owner.AddressOwner : "");
+        if (!ownerAccount) {
+            return undefined;
+        }
+        return {
+            objectId: input.objectId,
+            roles: input.roles,
+            ownership: ownerAccount === input.account ? "owned_by_account" : "not_owned_by_account",
+            ownerKind: "AddressOwner",
+            ownerAccount,
+            objectType: input.objectType,
+            source: "stored_transaction_data_and_mainnet_object_read"
+        };
+    }
+    if (input.owner.$kind === "Shared") {
+        return ownershipFact(input, "shared_object", "Shared");
+    }
+    if (input.owner.$kind === "Immutable") {
+        return ownershipFact(input, "immutable_object", "Immutable");
+    }
+    if (input.owner.$kind === "ObjectOwner") {
+        return ownershipFact(input, "object_owner", "ObjectOwner");
+    }
+    if (input.owner.$kind === "ConsensusAddressOwner") {
+        return ownershipFact(input, "consensus_address_owner", "ConsensusAddressOwner");
+    }
+    if (input.owner.$kind === "Unknown") {
+        return ownershipFact(input, "unknown_owner", "Unknown");
+    }
+    return undefined;
+}
+function ownershipFact(input, ownership, ownerKind) {
+    return {
+        objectId: input.objectId,
+        roles: input.roles,
+        ownership,
+        ownerKind,
+        objectType: input.objectType,
+        source: "stored_transaction_data_and_mainnet_object_read"
+    };
+}
+function isAcceptableOwnershipFact(fact) {
+    if (fact.ownership === "unknown_owner" || fact.ownership === "object_owner" || fact.ownership === "consensus_address_owner") {
+        return false;
+    }
+    if (fact.roles.includes("gas_object")) {
+        return fact.ownership === "owned_by_account";
+    }
+    if (fact.roles.includes("imm_or_owned_object") || fact.roles.includes("receiving_object")) {
+        return fact.ownership === "owned_by_account" ||
+            (fact.roles.includes("imm_or_owned_object") && fact.ownership === "immutable_object");
+    }
+    return fact.roles.every((role) => role === "shared_object")
+        ? fact.ownership === "shared_object" || fact.ownership === "immutable_object"
+        : false;
+}
+function objectReadBlocked() {
+    return {
+        status: "blocked",
+        blockedReason: "object_resolution_failed",
+        checks: [
+            failReviewCheck("transaction_object_ownership_read_failed", "Object ownership read", "Object ownership evidence was not produced because a transaction object owner could not be read or classified from mainnet object state.", "network")
+        ]
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/core/action/types.js

@@ -0,0 +1,33 @@
+export { SUI_CHAIN_RECEIPT_REQUIRED_INCLUDE } from "./suiChainReceiptEvidence.js";
+export const BLOCKED_REASONS = [
+    "adapter_not_implemented",
+    "producer_stage_missing",
+    "wallet_review_contract_emit_missing",
+    "network_mismatch",
+    "insufficient_balance",
+    "insufficient_gas",
+    "allowlist_violation",
+    "asset_mismatch",
+    "amount_mismatch",
+    "wallet_mismatch",
+    "unsupported_action",
+    "object_resolution_failed",
+    "proposal_review_only"
+];
+export const REFRESH_REASONS = [
+    "review_evidence_stale",
+    "quote_stale",
+    "quote_unavailable",
+    "simulation_transient_failure",
+    "review_update_failed",
+    "wallet_connection_changed"
+];
+export const REVIEW_PREPARATION_STATUSES = ["proposed", "awaiting_wallet", "wallet_connected", "ready_for_wallet_review", "refresh_required", "blocked", "expired"];
+export const REVIEW_MATERIAL_DERIVED_FIELDS = ["humanReadableReview", "simulation", "transactionReviewData",
+    "ptbVisualization", "assetFlowActual", "beforeAfterBalance"];
+// Display wording for the three computed review states, not wallet authority.
+export const REVIEW_UI_LABELS = {
+    ready_for_wallet_review: "Ready for your review",
+    refresh_required: "Review needs updating",
+    blocked: "Review blocked"
+};