@stelis/say-ur-intent 0.0.0 → 0.0.2

package/dist/core/action/transactionObjectOwnershipProducer.js

@@ -0,0 +1,329 @@
+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;
+        try {
+            objectRefs = extractObjectRefsFromStoredTransactionBytes(material.transactionBytes);
+        }
+        catch {
+            return {
+                status: "blocked",
+                blockedReason: "object_resolution_failed",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_refs_unavailable", "Object ownership refs", "Object ownership evidence was not produced because the stored local transaction material did not expose a complete resolved transaction object reference set.", "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")
+                ]
+            };
+        }
+        if (![...objectRoles.values()].some((roles) => roles.includes("gas_object"))) {
+            return {
+                status: "blocked",
+                blockedReason: "insufficient_gas",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_gas_missing", "Gas object ownership", "Object ownership evidence requires at least one gas object from the stored local transaction material.", "wallet")
+                ]
+            };
+        }
+        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 = invalidFact.roles.includes("gas_object")
+                ? "insufficient_gas"
+                : "object_resolution_failed";
+            return {
+                status: "blocked",
+                blockedReason,
+                checks: [
+                    failReviewCheck("transaction_object_ownership_unverified", "Object ownership", "Object ownership evidence was not accepted because at least one gas or account-owned transaction object is not owned by the connected account, or an object owner could not be classified.", 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,
+                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: contractMapping.roles.includes("gas_object")
+                    ? "insufficient_gas"
+                    : "object_resolution_failed",
+                checks: [
+                    failReviewCheck("transaction_object_ownership_contract_mapping_unsupported", "Object ownership contract mapping", `Object ownership evidence was read but cannot be used for contract objectOwnership evidence: ${contractMapping.reason}.`, contractMapping.roles.includes("gas_object") ? "wallet" : "adapter")
+                ]
+            };
+        }
+        return {
+            status: "completed",
+            evidence,
+            checks: [
+                passReviewCheck("transaction_object_ownership_verified", "Object ownership", "Verified contract-mappable transaction object ownership facts from the stored local transaction material and mainnet object reads. Gas and account-owned transaction coin objects are owned by the connected account; shared or immutable protocol objects are recorded as non-account-owned facts. This is not wallet handoff, signing readiness, or execution readiness.", "wallet")
+            ]
+        };
+    };
+}
+function extractObjectRefsFromStoredTransactionBytes(transactionBytes) {
+    const transaction = Transaction.from(transactionBytes);
+    const data = transaction.getData();
+    const refs = [];
+    const payments = data.gasData.payment ?? [];
+    for (const payment of payments) {
+        refs.push({ objectId: parseSuiObjectId(payment.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,35 @@
+export const FAILURE_REASONS = [
+    "wallet_rejected",
+    "wallet_provider_error",
+    "signing_disconnected",
+    "network_error",
+    "transaction_submit_failed",
+    "execution_result_unavailable",
+    "unknown_failure"
+];
+export const BLOCKED_REASONS = [
+    "adapter_not_implemented",
+    "producer_stage_missing",
+    "wallet_review_contract_emit_missing",
+    "wallet_handoff_not_implemented",
+    "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 = [
+    "quote_stale",
+    "quote_unavailable",
+    "simulation_transient_failure"
+];
+export const REVIEW_UI_LABELS = {
+    ready_for_wallet_review: "Ready for wallet review",
+    refresh_required: "Refresh required",
+    blocked: "Blocked"
+};

package/dist/core/action/walletReviewContractAssembler.js

@@ -0,0 +1,282 @@
+import { adapterEvidenceClaimSchema, adapterInputProvenanceSchema, adapterOutputBoundarySchema, adapterSimulationEvidenceSchema, adapterSourceOfTruthSchema, walletReviewAdapterContractSchema, WALLET_REVIEW_ADAPTER_CONTRACT_VERSION, WALLET_REVIEW_REQUIRED_PROHIBITED_OUTPUTS, WALLET_REVIEW_REQUIRED_SIMULATION_FIELDS, WALLET_REVIEW_REQUIRED_HUMAN_FIELDS, adapterExpiryEvidenceSchema, adapterHumanReadableReviewSchema, adapterGasEvidenceSchema, SUI_GAS_COIN_TYPE } from "./signableAdapterContract.js";
+import { parseReviewTimeSimulationEvidence } from "./reviewTimeSimulationEvidence.js";
+import { parseHumanReadableReviewEvidence } from "./humanReadableReviewEvidence.js";
+export function buildWalletReviewOutputBoundary() {
+    return adapterOutputBoundarySchema.parse({
+        runtimeStatus: "emitted_pre_handoff",
+        mcpAndReviewUiMayExpose: [
+            "human_readable_review",
+            "ptb_visualization_artifact",
+            "diagnostics",
+            "status_checks"
+        ],
+        prohibited: [...WALLET_REVIEW_REQUIRED_PROHIBITED_OUTPUTS]
+    });
+}
+export function buildWalletReviewInputProvenance(input) {
+    return adapterInputProvenanceSchema.parse({
+        kind: input.kind,
+        sourceId: input.sourceId,
+        capturedAt: input.capturedAt,
+        authority: "untrusted_until_review_regenerates_and_verifies",
+        ...(input.userSelectionSource ? { userSelectionSource: input.userSelectionSource } : {})
+    });
+}
+import { mapSwapQuotePolicyEvidenceToContractDraft, parseSwapQuotePolicyEvidence } from "./swapQuotePolicyEvidence.js";
+import { mapTransactionObjectOwnershipEvidenceToContractDraft } from "./transactionObjectOwnershipEvidence.js";
+export function draftWalletReviewContractEvidencePool(input) {
+    const quote = mapSwapQuotePolicyEvidenceToContractDraft(input.quotePolicy);
+    if (quote.status === "unsupported") {
+        return { status: "declined", reason: `quote policy draft unsupported: ${quote.reason}` };
+    }
+    const ownership = mapTransactionObjectOwnershipEvidenceToContractDraft(input.objectOwnership);
+    if (ownership.status === "unsupported") {
+        return { status: "declined", reason: `object ownership draft unsupported: ${ownership.reason}` };
+    }
+    const sourceOfTruth = [...quote.sourceOfTruth, ownership.sourceOfTruth];
+    const sourceIds = new Set();
+    for (const record of sourceOfTruth) {
+        if (sourceIds.has(record.id)) {
+            return { status: "declined", reason: `duplicate sourceOfTruth id: ${record.id}` };
+        }
+        sourceIds.add(record.id);
+    }
+    const evidenceClaims = [...quote.evidenceClaims, ...ownership.evidenceClaims];
+    const claimIds = new Set();
+    for (const claim of evidenceClaims) {
+        if (claimIds.has(claim.id)) {
+            return { status: "declined", reason: `duplicate evidence claim id: ${claim.id}` };
+        }
+        claimIds.add(claim.id);
+    }
+    return {
+        status: "drafted",
+        sourceOfTruth,
+        evidenceClaims,
+        rawQuantities: quote.rawQuantities,
+        objectOwnership: ownership.objectOwnership,
+        gasObjectOwnershipLinks: ownership.gasObjectOwnershipLinks
+    };
+}
+export function mapReviewTimeSimulationEvidenceToContractDraft(evidenceInput) {
+    const evidence = parseReviewTimeSimulationEvidence(evidenceInput);
+    const sourceId = "review_time_simulation_source";
+    const claimId = "review_time_simulation_claim";
+    const sourceOfTruth = adapterSourceOfTruthSchema.parse({
+        id: sourceId,
+        kind: "review_time_simulation",
+        network: "sui:mainnet",
+        source: "Checks-enabled client.core.simulateTransaction run over stored local transaction material",
+        verifiedAt: evidence.simulatedAt,
+        fields: [...WALLET_REVIEW_REQUIRED_SIMULATION_FIELDS]
+    });
+    const evidenceClaim = adapterEvidenceClaimSchema.parse({
+        id: claimId,
+        factKind: "simulation_result",
+        sourceEvidenceId: sourceId,
+        provider: evidence.provider,
+        checksEnabled: evidence.checksEnabled,
+        simulatedAt: evidence.simulatedAt,
+        status: evidence.status,
+        requiredFields: [...evidence.requiredFields],
+        missingFields: [...evidence.missingFields]
+    });
+    const simulation = adapterSimulationEvidenceSchema.parse({
+        evidenceClaimId: claimId,
+        boundToCommitment: evidence.transactionDigest,
+        provider: evidence.provider,
+        checksEnabled: evidence.checksEnabled,
+        simulatedAt: evidence.simulatedAt,
+        status: evidence.status,
+        requiredFields: [...evidence.requiredFields],
+        missingFields: [...evidence.missingFields]
+    });
+    return { status: "mapped", sourceOfTruth, evidenceClaim, simulation };
+}
+export function mapReviewTimeSimulationGasToContractDraft(evidenceInput, gasObjects) {
+    const evidence = parseReviewTimeSimulationEvidence(evidenceInput);
+    const summary = evidence.effects.gasCostSummary;
+    const gasUsed = BigInt(summary.computationCostRaw) +
+        BigInt(summary.storageCostRaw) -
+        BigInt(summary.storageRebateRaw);
+    if (gasUsed < 0n) {
+        return {
+            status: "unsupported",
+            reason: "net gas used is negative (storage rebate exceeds costs); unsigned gas evidence unavailable"
+        };
+    }
+    const sourceOfTruth = [];
+    const evidenceClaims = [];
+    const gasAsset = { coinType: SUI_GAS_COIN_TYPE };
+    const gasUsedSourceId = "review_time_simulation_gas_used_source";
+    const gasUsedClaimId = "review_time_simulation_gas_used_claim";
+    sourceOfTruth.push(adapterSourceOfTruthSchema.parse({
+        id: gasUsedSourceId,
+        kind: "review_time_simulation",
+        network: "sui:mainnet",
+        source: "Gas cost summary components from checks-enabled simulation of stored local transaction material",
+        verifiedAt: evidence.simulatedAt,
+        fields: ["gasUsedRaw", "asset", "amountRole"]
+    }));
+    evidenceClaims.push(adapterEvidenceClaimSchema.parse({
+        id: gasUsedClaimId,
+        factKind: "raw_quantity_amount",
+        sourceEvidenceId: gasUsedSourceId,
+        role: "gas_used",
+        asset: gasAsset,
+        rawAmount: gasUsed.toString()
+    }));
+    const gasBudgetRaw = evidence.transaction.gasBudgetRaw;
+    let gasBudgetClaimId;
+    if (gasBudgetRaw !== undefined) {
+        const gasBudgetSourceId = "review_time_simulation_gas_budget_source";
+        gasBudgetClaimId = "review_time_simulation_gas_budget_claim";
+        sourceOfTruth.push(adapterSourceOfTruthSchema.parse({
+            id: gasBudgetSourceId,
+            kind: "review_time_simulation",
+            network: "sui:mainnet",
+            source: "Gas budget from the simulated stored local transaction data",
+            verifiedAt: evidence.simulatedAt,
+            fields: ["gasBudgetRaw", "asset", "amountRole"]
+        }));
+        evidenceClaims.push(adapterEvidenceClaimSchema.parse({
+            id: gasBudgetClaimId,
+            factKind: "raw_quantity_amount",
+            sourceEvidenceId: gasBudgetSourceId,
+            role: "gas_budget",
+            asset: gasAsset,
+            rawAmount: gasBudgetRaw
+        }));
+    }
+    const gas = adapterGasEvidenceSchema.parse({
+        source: "review_time_simulation",
+        checkedAt: evidence.simulatedAt,
+        gasUsedRaw: gasUsed.toString(),
+        gasUsedClaimId,
+        ...(gasBudgetRaw !== undefined && gasBudgetClaimId
+            ? { gasBudgetRaw, gasBudgetClaimId }
+            : {}),
+        ...(gasObjects.length > 0 ? { gasObjects } : {})
+    });
+    return { status: "mapped", sourceOfTruth, evidenceClaims, gas };
+}
+export function mapSwapQuotePolicyExpiryToContractDraft(evidenceInput, now) {
+    const evidence = parseSwapQuotePolicyEvidence(evidenceInput);
+    const checkedAt = now.toISOString();
+    const status = Date.parse(evidence.expiresAt) > now.getTime() ? "current" : "expired";
+    const sourceId = "swap_quote_policy_expiry_source";
+    const claimId = "swap_quote_policy_expiry_claim";
+    const sourceOfTruth = adapterSourceOfTruthSchema.parse({
+        id: sourceId,
+        kind: "validated_request_fact",
+        network: "sui:mainnet",
+        source: "Quote policy expiry window (quote fetchedAt plus staleAfterMs) checked against the review-time clock",
+        verifiedAt: checkedAt,
+        fields: ["checkedAt", "expiresAt"]
+    });
+    const evidenceClaim = adapterEvidenceClaimSchema.parse({
+        id: claimId,
+        factKind: "expiry_status",
+        sourceEvidenceId: sourceId,
+        checkedAt,
+        status,
+        expiresAt: evidence.expiresAt
+    });
+    const expiry = adapterExpiryEvidenceSchema.parse({
+        checkedAt,
+        status,
+        expiresAt: evidence.expiresAt,
+        evidenceClaimId: claimId
+    });
+    return { status: "mapped", sourceOfTruth, evidenceClaim, expiry };
+}
+export function mapHumanReadableReviewEvidenceToContractDraft(evidenceInput) {
+    const evidence = parseHumanReadableReviewEvidence(evidenceInput);
+    const humanReadableReview = adapterHumanReadableReviewSchema.parse({
+        fields: [...WALLET_REVIEW_REQUIRED_HUMAN_FIELDS],
+        boundToCommitment: evidence.boundToCommitment,
+        source: "review_model_or_adapter_equivalent",
+        purpose: "human_review_before_wallet_authorization"
+    });
+    return { status: "mapped", humanReadableReview };
+}
+export function assembleWalletReviewAdapterContract(input) {
+    const pool = draftWalletReviewContractEvidencePool({
+        quotePolicy: input.quotePolicy,
+        objectOwnership: input.objectOwnership
+    });
+    if (pool.status === "declined") {
+        return pool;
+    }
+    const simulation = mapReviewTimeSimulationEvidenceToContractDraft(input.reviewTimeSimulation);
+    const gas = mapReviewTimeSimulationGasToContractDraft(input.reviewTimeSimulation, pool.gasObjectOwnershipLinks);
+    if (gas.status === "unsupported") {
+        return { status: "declined", reason: `gas evidence unsupported: ${gas.reason}` };
+    }
+    const expiry = mapSwapQuotePolicyExpiryToContractDraft(input.quotePolicy, input.now);
+    const human = mapHumanReadableReviewEvidenceToContractDraft(input.humanReadableReview);
+    const sourceOfTruth = [
+        ...pool.sourceOfTruth,
+        simulation.sourceOfTruth,
+        ...gas.sourceOfTruth,
+        expiry.sourceOfTruth
+    ];
+    const sourceIds = new Set();
+    for (const record of sourceOfTruth) {
+        if (sourceIds.has(record.id)) {
+            return { status: "declined", reason: `duplicate sourceOfTruth id: ${record.id}` };
+        }
+        sourceIds.add(record.id);
+    }
+    const evidenceClaims = [
+        ...pool.evidenceClaims,
+        simulation.evidenceClaim,
+        ...gas.evidenceClaims,
+        expiry.evidenceClaim
+    ];
+    const claimIds = new Set();
+    for (const claim of evidenceClaims) {
+        if (claimIds.has(claim.id)) {
+            return { status: "declined", reason: `duplicate evidence claim id: ${claim.id}` };
+        }
+        claimIds.add(claim.id);
+    }
+    const quote = parseSwapQuotePolicyEvidence(input.quotePolicy);
+    const candidate = {
+        contractVersion: WALLET_REVIEW_ADAPTER_CONTRACT_VERSION,
+        adapterId: input.adapterId,
+        protocol: input.protocol,
+        actionKind: input.actionKind,
+        network: "sui:mainnet",
+        inputProvenance: buildWalletReviewInputProvenance(input.provenance),
+        sourceOfTruth,
+        evidenceClaims,
+        rawQuantities: pool.rawQuantities,
+        gas: gas.gas,
+        expiry: expiry.expiry,
+        slippageOrMinOut: {
+            status: "required_and_verified",
+            quoteEvidenceId: quote.quoteEvidenceId,
+            quoteEvidenceClaimId: "swap_quote_min_out_claim",
+            maxSlippageBps: quote.maxSlippageBps,
+            minOutRaw: quote.minimumOutput.raw,
+            policySource: "adapter_policy_from_quote_evidence",
+            policyEvidenceClaimId: "swap_quote_slippage_policy_claim"
+        },
+        objectOwnership: pool.objectOwnership,
+        simulation: simulation.simulation,
+        humanReadableReview: human.humanReadableReview,
+        outputBoundary: buildWalletReviewOutputBoundary(),
+        transactionMaterialCommitment: input.transactionMaterialCommitment
+    };
+    const parsed = walletReviewAdapterContractSchema.safeParse(candidate);
+    if (!parsed.success) {
+        const issue = parsed.error.issues[0];
+        const path = issue?.path.join(".") ?? "";
+        return {
+            status: "declined",
+            reason: `contract schema rejected: ${path ? `${path}: ` : ""}${issue?.message ?? "unknown issue"}`
+        };
+    }
+    return { status: "emitted", contract: parsed.data };
+}

package/dist/core/activity/activityStore.js

@@ -0,0 +1,15 @@
+export const REVIEW_ACTIVITY_LOW_SAMPLE_THRESHOLD = 5;
+export const REVIEW_ACTIVITY_LIST_DEFAULT_LIMIT = 20;
+export const REVIEW_ACTIVITY_LIST_MAX_LIMIT = 100;
+export const REVIEW_ACTIVITY_DETAIL_MAX_ITEMS = 100;
+export const EXTERNAL_ACTIVITY_SCAN_DEFAULT_LIMIT = 100;
+export const EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT = 100;
+export class ActivityStoreReadError extends Error {
+    kind;
+    details;
+    constructor(kind, message, details = {}) {
+        super(message);
+        this.kind = kind;
+        this.details = details;
+    }
+}