@zktx.io/sui-mcp 0.5.0

package/dist/core/action/walletReviewContractAssembler.js

@@ -0,0 +1,286 @@
+import { assertTransactionFundingMatches } from "./transactionFunding.js";
+import { adapterEvidenceClaimSchema, adapterInputProvenanceSchema, adapterOutputBoundarySchema, adapterSimulationEvidenceSchema, adapterSourceOfTruthSchema, transactionReviewDataSchema, TRANSACTION_REVIEW_SCHEMA_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 sourceReferences = [...quote.sourceReferences, ownership.sourceReferences];
+    const sourceIds = new Set();
+    for (const record of sourceReferences) {
+        if (sourceIds.has(record.id)) {
+            return { status: "declined", reason: `duplicate sourceReferences 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",
+        sourceReferences,
+        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 sourceReferences = adapterSourceOfTruthSchema.parse({
+        id: sourceId,
+        kind: "review_time_simulation",
+        network: "sui:mainnet",
+        source: "Sui gRPC simulation with validation enabled; returned transaction bytes and effects matched the stored transaction",
+        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,
+        transactionDigest: evidence.transactionDigest,
+        provider: evidence.provider,
+        checksEnabled: evidence.checksEnabled,
+        simulatedAt: evidence.simulatedAt,
+        status: evidence.status,
+        requiredFields: [...evidence.requiredFields],
+        missingFields: [...evidence.missingFields]
+    });
+    return { status: "mapped", sourceReferences, 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);
+    const sourceReferences = [];
+    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";
+    // A storage rebate can make net gas negative. Keep the verified budget and
+    // simulation components; do not invent an unsigned zero or a spending claim.
+    if (gasUsed >= 0n) {
+        sourceReferences.push(adapterSourceOfTruthSchema.parse({
+            id: gasUsedSourceId,
+            kind: "review_time_simulation",
+            network: "sui:mainnet",
+            source: "Network fee components estimated by simulation of the stored transaction with validation enabled",
+            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";
+        sourceReferences.push(adapterSourceOfTruthSchema.parse({
+            id: gasBudgetSourceId,
+            kind: "review_time_simulation",
+            network: "sui:mainnet",
+            source: "Network fee limit (gas budget) recorded in the transaction used for simulation",
+            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,
+        ...(gasUsed >= 0n ? { gasUsedRaw: gasUsed.toString(), gasUsedClaimId } : {}),
+        ...(gasBudgetRaw !== undefined && gasBudgetClaimId
+            ? { gasBudgetRaw, gasBudgetClaimId }
+            : {}),
+        ...(gasObjects.length > 0 ? { gasObjects } : {})
+    });
+    return { status: "mapped", sourceReferences, 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 sourceReferences = adapterSourceOfTruthSchema.parse({
+        id: sourceId,
+        kind: "validated_request_fact",
+        network: "sui:mainnet",
+        source: "Quote validity period (retrieval time plus validity duration), checked when the review was prepared",
+        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", sourceReferences, evidenceClaim, expiry };
+}
+export function mapHumanReadableReviewEvidenceToContractDraft(evidenceInput) {
+    const evidence = parseHumanReadableReviewEvidence(evidenceInput);
+    const humanReadableReview = adapterHumanReadableReviewSchema.parse({
+        fields: [...WALLET_REVIEW_REQUIRED_HUMAN_FIELDS],
+        transactionDigest: evidence.transactionDigest,
+        source: "review_model_or_adapter_equivalent",
+        purpose: "human_review_before_wallet_authorization"
+    });
+    return { status: "mapped", humanReadableReview };
+}
+export function assembleTransactionReviewData(input) {
+    const pool = draftWalletReviewContractEvidencePool({
+        quotePolicy: input.quotePolicy,
+        objectOwnership: input.objectOwnership
+    });
+    if (pool.status === "declined") {
+        return pool;
+    }
+    try {
+        assertTransactionFundingMatches(input.reviewTimeSimulation.transaction.funding, input.objectOwnership.funding);
+    }
+    catch {
+        return { status: "declined", reason: "simulation and ownership funding evidence differ" };
+    }
+    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 sourceReferences = [
+        ...pool.sourceReferences,
+        simulation.sourceReferences,
+        ...gas.sourceReferences,
+        expiry.sourceReferences
+    ];
+    const sourceIds = new Set();
+    for (const record of sourceReferences) {
+        if (sourceIds.has(record.id)) {
+            return { status: "declined", reason: `duplicate sourceReferences 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 = {
+        schemaVersion: TRANSACTION_REVIEW_SCHEMA_VERSION,
+        adapterId: input.adapterId,
+        protocol: input.protocol,
+        actionKind: input.actionKind,
+        network: "sui:mainnet",
+        inputProvenance: buildWalletReviewInputProvenance(input.provenance),
+        sourceReferences,
+        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(),
+        reviewedTransactionDigest: input.reviewedTransactionDigest
+    };
+    const parsed = transactionReviewDataSchema.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/accountAssetTimeline.js

@@ -0,0 +1,157 @@
+import { parseSuiAddress } from "../suiAddress.js";
+import { DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL, deepbookOfficialIndexerIntervalDurationMs } from "../read/deepbookOfficialIndexerSource.js";
+import { requestedAccountEffectsForTransaction } from "./transactionActivityAccountEffects.js";
+export function buildAccountAssetTimeline(input) {
+    const account = parseSuiAddress(input.account);
+    if (account === undefined) {
+        throw new Error("Account asset timeline account must be a valid Sui address");
+    }
+    const fromMs = parseRequiredUtc(input.from, "from");
+    const toMs = parseRequiredUtc(input.to, "to");
+    if (fromMs >= toMs) {
+        throw new Error("Account asset timeline from must be before to");
+    }
+    const interval = input.interval ?? DEFAULT_DEEPBOOK_OFFICIAL_INDEXER_INTERVAL;
+    const limitations = new Set(["no_balance_anchor"]);
+    if (!input.coverage.accountKnown) {
+        limitations.add("account_not_known");
+    }
+    for (const limitation of input.coverage.limitations) {
+        limitations.add(limitation);
+    }
+    if (input.transactionsTruncated === true) {
+        limitations.add("source_transactions_truncated");
+    }
+    const bucketMs = deepbookOfficialIndexerIntervalDurationMs(interval);
+    const bars = new Map();
+    let analyzedTransactionCount = 0;
+    let skippedTransactionCount = 0;
+    for (const transaction of input.transactions) {
+        if (transaction.account !== account) {
+            skippedTransactionCount += 1;
+            continue;
+        }
+        if (transaction.timestamp === undefined) {
+            skippedTransactionCount += 1;
+            limitations.add("transaction_timestamp_unavailable");
+            continue;
+        }
+        const timestampMs = Date.parse(transaction.timestamp);
+        if (!Number.isFinite(timestampMs)) {
+            skippedTransactionCount += 1;
+            limitations.add("transaction_timestamp_unavailable");
+            continue;
+        }
+        if (timestampMs < fromMs || timestampMs >= toMs) {
+            skippedTransactionCount += 1;
+            continue;
+        }
+        const effects = requestedAccountEffectsForTransaction(transactionRecordToActivityFact(transaction), account);
+        if (effects.balanceChangeCompleteness === "unavailable") {
+            limitations.add("transaction_details_unavailable");
+        }
+        if (effects.balanceChangeCompleteness === "truncated") {
+            limitations.add("provider_balance_changes_truncated");
+        }
+        analyzedTransactionCount += 1;
+        const bucketStartMs = Math.floor(timestampMs / bucketMs) * bucketMs;
+        const bucketEndMs = bucketStartMs + bucketMs;
+        for (const change of effects.balanceChanges) {
+            const amount = BigInt(change.amountRaw);
+            const key = `${bucketStartMs}\n${change.coinType}`;
+            const entry = bars.get(key) ?? {
+                bucketStartMs,
+                bucketEndMs,
+                coinType: change.coinType,
+                increaseRaw: 0n,
+                decreaseRaw: 0n,
+                netRaw: 0n,
+                digests: new Set()
+            };
+            entry.netRaw += amount;
+            if (amount > 0n) {
+                entry.increaseRaw += amount;
+            }
+            else if (amount < 0n) {
+                entry.decreaseRaw += -amount;
+            }
+            entry.digests.add(transaction.digest);
+            bars.set(key, entry);
+        }
+    }
+    const netFlowBars = [...bars.values()].map(netFlowBarFromAccumulator).sort(compareNetFlowBars);
+    if (netFlowBars.length === 0) {
+        limitations.add("no_observed_account_balance_changes");
+    }
+    return {
+        account,
+        requestedRange: {
+            from: input.from,
+            to: input.to
+        },
+        bucket: {
+            interval,
+            durationMs: bucketMs,
+            alignment: "utc_epoch"
+        },
+        status: statusForCoverage(input.coverage),
+        balanceStatus: "unavailable_no_balance_anchor",
+        coverage: input.coverage,
+        sourceTransactionCount: input.transactions.length,
+        analyzedTransactionCount,
+        skippedTransactionCount,
+        netFlowBars,
+        balanceBars: [],
+        quantitySemantics: {
+            netFlowBars: "observed_account_scoped_raw_token_balance_changes",
+            balanceBars: "unavailable_without_balance_anchor"
+        },
+        limitations: [...limitations].sort()
+    };
+}
+function transactionRecordToActivityFact(record) {
+    return {
+        digest: record.digest,
+        checkpoint: record.checkpoint,
+        timestamp: record.timestamp,
+        status: record.status,
+        details: record.details
+    };
+}
+function netFlowBarFromAccumulator(value) {
+    return {
+        bucketStart: new Date(value.bucketStartMs).toISOString(),
+        bucketEnd: new Date(value.bucketEndMs).toISOString(),
+        coinType: value.coinType,
+        increaseRaw: value.increaseRaw.toString(),
+        decreaseRaw: value.decreaseRaw.toString(),
+        netRaw: value.netRaw.toString(),
+        transactionCount: value.digests.size
+    };
+}
+function statusForCoverage(coverage) {
+    if (!coverage.accountKnown) {
+        return "account_not_known";
+    }
+    if (coverage.coverageStatus === "no_stored_scans") {
+        return "scan_needed";
+    }
+    if (coverage.coverageStatus === "partial") {
+        return "partial_coverage";
+    }
+    return "ok";
+}
+function parseRequiredUtc(value, field) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== value) {
+        throw new Error(`Account asset timeline ${field} must be an ISO 8601 UTC timestamp`);
+    }
+    return parsed.getTime();
+}
+function compareNetFlowBars(a, b) {
+    const bucketComparison = a.bucketStart.localeCompare(b.bucketStart);
+    if (bucketComparison !== 0) {
+        return bucketComparison;
+    }
+    return a.coinType.localeCompare(b.coinType);
+}

package/dist/core/activity/accountAssetTimelineUsdcReferences.js

@@ -0,0 +1,120 @@
+import { deepbookUsdcPriceHistoryQuantitySemantics, deepbookUsdcPriceHistoryResponseSummary } from "../read/deepbookReadHelpers.js";
+import { DEEPBOOK_OFFICIAL_INDEXER_SOURCE_BASE, DEEPBOOK_OFFICIAL_INDEXER_USDC_REFERENCE } from "../read/deepbookSourceOwners.js";
+import { DEEPBOOK_USDC_PRICE_HISTORY_UNSUPPORTED_CLAIMS } from "../read/readServiceTypes.js";
+export async function attachDeepbookUsdcReferencesToTimeline(input) {
+    const baseSummary = emptyReferenceSummary();
+    if (input.timeline.netFlowBars.length === 0) {
+        return {
+            ...input.timeline,
+            usdcReferences: { ...baseSummary, status: "no_timeline_bars" }
+        };
+    }
+    const barsByCoin = groupBarsByCoin(input.timeline.netFlowBars);
+    const coinReferences = [];
+    for (const [coinType, bars] of barsByCoin) {
+        const history = await input.getPriceHistory({
+            coinType,
+            interval: input.timeline.bucket.interval,
+            start: input.timeline.requestedRange.from,
+            end: input.timeline.requestedRange.to
+        });
+        coinReferences.push(referenceForHistory(coinType, bars, history));
+    }
+    return {
+        ...input.timeline,
+        usdcReferences: {
+            ...baseSummary,
+            status: referenceSummaryStatus(coinReferences),
+            coinReferences
+        }
+    };
+}
+function emptyReferenceSummary() {
+    return {
+        status: "unavailable",
+        ...DEEPBOOK_OFFICIAL_INDEXER_USDC_REFERENCE,
+        source: DEEPBOOK_OFFICIAL_INDEXER_SOURCE_BASE.kind,
+        chainRecomputedBySuiMcp: DEEPBOOK_OFFICIAL_INDEXER_SOURCE_BASE.chainRecomputedBySuiMcp,
+        quantitySemantics: deepbookUsdcPriceHistoryQuantitySemantics(),
+        responseSummary: deepbookUsdcPriceHistoryResponseSummary(),
+        unsupportedClaims: [...DEEPBOOK_USDC_PRICE_HISTORY_UNSUPPORTED_CLAIMS],
+        coinReferences: []
+    };
+}
+function referenceForHistory(coinType, timelineBars, history) {
+    if (history.status === "unsupported_pair") {
+        return {
+            coinType,
+            status: "unsupported_asset",
+            reason: history.reason,
+            matchingPoolNames: history.matchingPoolNames,
+            availablePoolNames: history.availablePoolNames
+        };
+    }
+    if (history.status === "unsupported_range") {
+        return {
+            coinType,
+            status: "unsupported_range",
+            reason: history.reason,
+            requested: history.requested
+        };
+    }
+    if (history.status === "source_unavailable") {
+        return {
+            coinType,
+            status: "source_unavailable",
+            reason: history.reason,
+            pair: history.pair,
+            source: history.source
+        };
+    }
+    const candlesByBucket = new Map(history.bars.map((bar) => [`${bar.start}\n${bar.end}`, bar]));
+    const barReferences = timelineBars.map((bar) => {
+        const candle = candlesByBucket.get(`${bar.bucketStart}\n${bar.bucketEnd}`);
+        return candle === undefined
+            ? {
+                bucketStart: bar.bucketStart,
+                bucketEnd: bar.bucketEnd,
+                status: "missing_candle"
+            }
+            : {
+                bucketStart: bar.bucketStart,
+                bucketEnd: bar.bucketEnd,
+                status: "available",
+                candle
+            };
+    });
+    return {
+        coinType,
+        status: barReferences.some((bar) => bar.status === "missing_candle")
+            ? "partial"
+            : "available",
+        pair: history.pair,
+        candleAvailability: history.candleAvailability,
+        source: history.source,
+        barReferences
+    };
+}
+function groupBarsByCoin(bars) {
+    const result = new Map();
+    for (const bar of bars) {
+        const existing = result.get(bar.coinType) ?? [];
+        existing.push(bar);
+        result.set(bar.coinType, existing);
+    }
+    return result;
+}
+function referenceSummaryStatus(coinReferences) {
+    if (coinReferences.length === 0) {
+        return "no_timeline_bars";
+    }
+    const availableCount = coinReferences.filter((entry) => entry.status === "available").length;
+    const partialCount = coinReferences.filter((entry) => entry.status === "partial").length;
+    if (availableCount === coinReferences.length) {
+        return "available";
+    }
+    if (availableCount > 0 || partialCount > 0) {
+        return "partial";
+    }
+    return "unavailable";
+}

package/dist/core/activity/activityStore.js

@@ -0,0 +1,16 @@
+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 const EXTERNAL_ACTIVITY_COVERAGE_SCAN_MAX_RECORDS = 100;
+export class ActivityStoreReadError extends Error {
+    kind;
+    details;
+    constructor(kind, message, details = {}) {
+        super(message);
+        this.kind = kind;
+        this.details = details;
+    }
+}

package/dist/core/activity/externalActivityCoverage.js

@@ -0,0 +1,76 @@
+export function buildExternalActivityCoverageResult(input) {
+    const completeAffectedAccountScanIds = input.scans
+        .filter((scan) => scanCompletesAffectedAccountRange(scan, input.from, input.to))
+        .map((scan) => scan.scanId);
+    const incompleteScanIds = input.scans
+        .filter((scan) => scan.windowComplete === false || scan.incompleteReason !== undefined)
+        .map((scan) => scan.scanId);
+    const sentOnlyScanIds = input.scans
+        .filter((scan) => scan.kind === "account_scan" && scan.relationship === "sent")
+        .map((scan) => scan.scanId);
+    const limitations = new Set();
+    const scansTruncated = input.scansTruncated === true;
+    if (input.scanCount === 0) {
+        limitations.add("no_stored_activity_scans");
+    }
+    if (completeAffectedAccountScanIds.length === 0) {
+        limitations.add("no_complete_affected_account_scan");
+    }
+    if (sentOnlyScanIds.length > 0) {
+        limitations.add("sent_only_scan_not_full_account_coverage");
+    }
+    if (incompleteScanIds.length > 0) {
+        limitations.add("scan_window_incomplete");
+    }
+    if (input.scans.some((scan) => scan.fromTimestamp === undefined || scan.toTimestamp === undefined)) {
+        limitations.add("scan_window_unbounded");
+    }
+    if (scansTruncated) {
+        limitations.add("scan_records_truncated");
+    }
+    return {
+        dataScope: {
+            account: input.scope.account,
+            from: input.from,
+            to: input.to,
+            recordCount: input.storedTransactionCount
+        },
+        accountSource: input.scope.accountSource,
+        accountKnown: input.scope.accountId !== undefined,
+        requestedRange: {
+            from: input.from,
+            to: input.to
+        },
+        coverageStatus: input.scanCount === 0
+            ? "no_stored_scans"
+            : completeAffectedAccountScanIds.length > 0
+                ? "complete"
+                : "partial",
+        scanCount: input.scanCount,
+        returnedScanCount: input.scans.length,
+        scansTruncated,
+        storedTransactionCount: input.storedTransactionCount,
+        ...(input.storedTransactionRange === undefined ? {} : { storedTransactionRange: input.storedTransactionRange }),
+        coverageEvidence: {
+            completeAffectedAccountScanIds,
+            incompleteScanIds,
+            sentOnlyScanIds
+        },
+        limitations: [...limitations].sort(),
+        scans: input.scans
+    };
+}
+export function scanOverlapsRequestedRange(scan, from, to) {
+    return (scan.fromTimestamp === undefined || scan.fromTimestamp < to) &&
+        (scan.toTimestamp === undefined || scan.toTimestamp > from);
+}
+function scanCompletesAffectedAccountRange(scan, from, to) {
+    return scan.kind === "account_scan" &&
+        scan.relationship === "affected" &&
+        scan.windowComplete === true &&
+        scan.incompleteReason === undefined &&
+        scan.fromTimestamp !== undefined &&
+        scan.toTimestamp !== undefined &&
+        scan.fromTimestamp <= from &&
+        scan.toTimestamp >= to;
+}