@zktx.io/sui-mcp 0.5.0

package/dist/core/activity/transactionActivityDetails.js

@@ -0,0 +1,229 @@
+import { Buffer } from "node:buffer";
+import { MIST_PER_SUI, SUI_DECIMALS } from "@mysten/sui/utils";
+import { z } from "zod";
+import { parseSuiAddress } from "../suiAddress.js";
+import { classifySuiDeFiActivity, protocolActivityClassifierMatchSchema } from "./transactionActivityClassifier.js";
+export const EXTERNAL_ACTIVITY_TRANSACTION_DETAIL_JSON_MAX_BYTES = 64 * 1024;
+export const SUI_GAS_UNIT_SOURCE = "@mysten/sui MIST_PER_SUI";
+export const externalActivityGasCostFactSchema = z.object({
+    netCostRaw: z.string().regex(/^-?\d+$/),
+    rawUnit: z.literal("MIST"),
+    display: z.string().regex(/^-?\d+(?:\.\d+)?$/),
+    displayUnit: z.literal("SUI"),
+    decimals: z.literal(SUI_DECIMALS),
+    unitSource: z.literal(SUI_GAS_UNIT_SOURCE)
+}).strict();
+export const externalActivityTransactionDetailSchema = z.object({
+    transactionKind: z.string().optional(),
+    moveCalls: z.array(z.object({
+        commandIndex: z.number().int().nonnegative(),
+        package: z.string(),
+        module: z.string(),
+        function: z.string(),
+        target: z.string()
+    }).strict()),
+    balanceChanges: z.array(z.object({
+        index: z.number().int().nonnegative(),
+        owner: z.string().optional(),
+        coinType: z.string(),
+        amountRaw: z.string().regex(/^-?\d+$/),
+        direction: z.enum(["increase", "decrease", "zero"])
+    }).strict()),
+    objectChanges: z.array(z.object({
+        index: z.number().int().nonnegative(),
+        objectId: z.string(),
+        changeKind: z.enum(["created", "mutated", "deleted"]),
+        inputType: z.string().optional(),
+        outputType: z.string().optional()
+    }).strict()),
+    events: z.array(z.object({
+        sequenceNumber: z.string().regex(/^\d+$/),
+        sender: z.string().optional(),
+        package: z.string().optional(),
+        module: z.string().optional(),
+        eventType: z.string().optional()
+    }).strict()),
+    gas: z.object({
+        gasObjectId: z.string().optional(),
+        computationCostRaw: z.string().regex(/^\d+$/).optional(),
+        storageCostRaw: z.string().regex(/^\d+$/).optional(),
+        storageRebateRaw: z.string().regex(/^\d+$/).optional(),
+        nonRefundableStorageFeeRaw: z.string().regex(/^\d+$/).optional(),
+        netGasCostRaw: z.string().regex(/^-?\d+$/).optional()
+    }).strict().optional(),
+    executionError: z.object({
+        message: z.string(),
+        abortCodeRaw: z.string().regex(/^\d+$/).optional(),
+        identifier: z.string().optional(),
+        instructionOffset: z.number().int().nonnegative().optional(),
+        sourceLineNumber: z.number().int().nonnegative().optional(),
+        package: z.string().optional(),
+        module: z.string().optional(),
+        function: z.string().optional()
+    }).strict().optional(),
+    truncation: z.object({
+        moveCalls: z.boolean(),
+        balanceChanges: z.boolean(),
+        objectChanges: z.boolean(),
+        events: z.boolean()
+    }).strict()
+}).strict();
+export const externalActivityTransactionCompactFactsSchema = z.object({
+    factScope: z.literal("transaction"),
+    requestedAccountScoped: z.literal(false),
+    moveCallTargets: z.array(z.string()),
+    balanceChanges: z.array(z.object({
+        coinType: z.string(),
+        amountRaw: z.string().regex(/^-?\d+$/),
+        direction: z.enum(["increase", "decrease", "zero"]),
+        count: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional()
+    }).strict()),
+    objectChangeCounts: z.object({
+        created: z.number().int().nonnegative(),
+        mutated: z.number().int().nonnegative(),
+        deleted: z.number().int().nonnegative()
+    }).strict(),
+    eventTypes: z.array(z.string()),
+    gasCost: externalActivityGasCostFactSchema.optional(),
+    gasNetCostRaw: z.string().regex(/^-?\d+$/).optional(),
+    executionError: z.object({
+        message: z.string(),
+        abortCodeRaw: z.string().regex(/^\d+$/).optional(),
+        package: z.string().optional(),
+        module: z.string().optional(),
+        function: z.string().optional()
+    }).strict().optional(),
+    detailTruncated: z.boolean(),
+    protocolMatches: z.array(protocolActivityClassifierMatchSchema).optional()
+}).strict();
+export function externalActivityTransactionDetailJsonByteLength(value) {
+    return Buffer.byteLength(value, "utf8");
+}
+export function sanitizeExternalActivityTransactionDetailsForKnownAccount(details, storageAccount) {
+    return {
+        ...details,
+        balanceChanges: details.balanceChanges.map((change) => {
+            if (addressMatches(change.owner, storageAccount)) {
+                return { ...change, owner: storageAccount };
+            }
+            const { owner: _owner, ...withoutOwner } = change;
+            return withoutOwner;
+        }),
+        events: details.events.map((event) => {
+            if (addressMatches(event.sender, storageAccount)) {
+                return { ...event, sender: storageAccount };
+            }
+            const { sender: _sender, ...withoutSender } = event;
+            return withoutSender;
+        })
+    };
+}
+export function externalActivityTransactionTouchesAccount(transaction, account) {
+    return externalActivityTransactionBalanceOwners(transaction).includes(account);
+}
+export function externalActivityTransactionBalanceOwners(transaction) {
+    const owners = transaction.details?.balanceChanges.flatMap((change) => {
+        const owner = change.owner === undefined ? undefined : parseSuiAddress(change.owner);
+        return owner === undefined ? [] : [owner];
+    }) ?? [];
+    return [...new Set(owners)];
+}
+export function externalActivityTransactionDetailsReferenceOnlyAccount(details, account) {
+    return details.balanceChanges.every((change) => change.owner === undefined || addressMatches(change.owner, account))
+        && details.events.every((event) => event.sender === undefined || addressMatches(event.sender, account));
+}
+export function compactExternalActivityTransactionDetails(details) {
+    const objectChangeCounts = {
+        created: 0,
+        mutated: 0,
+        deleted: 0
+    };
+    for (const change of details.objectChanges) {
+        objectChangeCounts[change.changeKind] += 1;
+    }
+    const executionError = details.executionError === undefined
+        ? undefined
+        : {
+            message: details.executionError.message,
+            ...(details.executionError.abortCodeRaw === undefined ? {} : { abortCodeRaw: details.executionError.abortCodeRaw }),
+            ...(details.executionError.package === undefined ? {} : { package: details.executionError.package }),
+            ...(details.executionError.module === undefined ? {} : { module: details.executionError.module }),
+            ...(details.executionError.function === undefined ? {} : { function: details.executionError.function })
+        };
+    const protocolMatches = classifySuiDeFiActivity(details);
+    return {
+        factScope: "transaction",
+        requestedAccountScoped: false,
+        moveCallTargets: uniqueStrings(details.moveCalls.map((call) => call.target)),
+        balanceChanges: compactBalanceChanges(details.balanceChanges),
+        objectChangeCounts,
+        eventTypes: uniqueStrings(details.events.flatMap((event) => event.eventType === undefined ? [] : [event.eventType])),
+        ...(details.gas?.netGasCostRaw === undefined ? {} : { gasCost: suiGasCostFact(details.gas.netGasCostRaw) }),
+        ...(details.gas?.netGasCostRaw === undefined ? {} : { gasNetCostRaw: details.gas.netGasCostRaw }),
+        ...(executionError === undefined ? {} : { executionError }),
+        detailTruncated: details.truncation.moveCalls
+            || details.truncation.balanceChanges
+            || details.truncation.objectChanges
+            || details.truncation.events,
+        ...(protocolMatches.length === 0 ? {} : { protocolMatches })
+    };
+}
+export function suiGasCostFact(netCostRaw) {
+    return {
+        netCostRaw,
+        rawUnit: "MIST",
+        display: formatSignedMistAsSui(netCostRaw),
+        displayUnit: "SUI",
+        decimals: SUI_DECIMALS,
+        unitSource: SUI_GAS_UNIT_SOURCE
+    };
+}
+function formatSignedMistAsSui(raw) {
+    if (!/^-?\d+$/.test(raw)) {
+        throw new Error("gas raw amount must be a signed integer string");
+    }
+    const negative = raw.startsWith("-");
+    const unsignedRaw = negative ? raw.slice(1) : raw;
+    const amount = BigInt(unsignedRaw);
+    const whole = amount / MIST_PER_SUI;
+    const fractional = amount % MIST_PER_SUI;
+    const sign = negative && amount !== 0n ? "-" : "";
+    if (fractional === 0n) {
+        return `${sign}${whole.toString()}`;
+    }
+    const fractionalText = fractional
+        .toString()
+        .padStart(SUI_DECIMALS, "0")
+        .replace(/0+$/, "");
+    return `${sign}${whole.toString()}.${fractionalText}`;
+}
+function compactBalanceChanges(balanceChanges) {
+    const compacted = new Map();
+    for (const change of balanceChanges) {
+        const key = `${change.coinType}\n${change.amountRaw}\n${change.direction}`;
+        const existing = compacted.get(key);
+        if (existing === undefined) {
+            compacted.set(key, {
+                coinType: change.coinType,
+                amountRaw: change.amountRaw,
+                direction: change.direction,
+                count: 1
+            });
+            continue;
+        }
+        existing.count += 1;
+    }
+    return [...compacted.values()].map((change) => ({
+        coinType: change.coinType,
+        amountRaw: change.amountRaw,
+        direction: change.direction,
+        ...(change.count === 1 ? {} : { count: change.count })
+    }));
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function addressMatches(candidate, account) {
+    const normalized = candidate === undefined ? undefined : parseSuiAddress(candidate);
+    return normalized !== undefined && normalized === account;
+}

package/dist/core/activity/transactionActivityProtocolRules.js

@@ -0,0 +1,218 @@
+import { parseSuiAddress } from "../suiAddress.js";
+export const protocolActivityPrimaryActions = [
+    "order",
+    "swap",
+    "liquidity",
+    "lending",
+    "fee_or_reward",
+    "admin_or_versioning",
+    "unknown"
+];
+const DEEPBOOK_PINNED_SDK_PACKAGE = "0xf48222c4e057fa468baf136bff8e12504209d43850c5778f76159292a96f621e";
+const DEEPBOOK_DOCS_SNAPSHOT_PACKAGE = "0x337f4f4f6567fcd778d5454f27c16c70e2f274cc6377ea6249ddf491482ef497";
+const DEEPTRADE_CORE_PACKAGE = "0xc10d536b6580d809711b9bb8eee3945d5e96f92a346c84d74ff7a0697e664695";
+const CETUS_CLMM_PACKAGE = "0x25ebb9a7c50eb17b3fa9c5a30fb8b5ad8f97caaf4928943acbcff7153dfee5e3";
+const SUILEND_MVR_CORE_PACKAGE = "0xe53906c2c058d1e369763114418f3c144d1b74960d29b2785718a782fec09b61";
+const SUILEND_MAIN_MARKET_TYPE_PACKAGE = "0xf95b06141ed4a174f239417323bde3f209b972f5930d8521ea38a52aff3a6ddf";
+const AFTERMATH_AFSUI_EVENTS_PACKAGE = "0x7f6ce7ade63857c4fd16ef7783fed2dfc4d7fb7e40615abdb653030b76aef0c6";
+const AFTERMATH_AFSUI_PACKAGE = "0x1575034d2729907aefca1ac757d6ccfcd3fc7e9e77927523c06007d8353ad836";
+export const SUI_DEFI_ACTIVITY_PROTOCOL_RULES = [
+    {
+        protocolId: "deepbook-v3",
+        displayName: "DeepBook V3",
+        activityCategory: "CLOB / order book",
+        packages: normalizePackageMap({
+            [DEEPBOOK_PINNED_SDK_PACKAGE]: {
+                source: "mvr_current_mainnet_resolution_and_pinned_sdk_local_registry",
+                mvrName: "@deepbook/core"
+            },
+            [DEEPBOOK_DOCS_SNAPSHOT_PACKAGE]: {
+                source: "sui_docs_research_snapshot",
+                limitation: "deepbook_package_conflict_open"
+            }
+        }),
+        sharedObjects: normalizeObjectMap({
+            "0xaf16199a2dff736e9f07a845f23c5da6df6f756eddb631aed9d24a93efc4549d": "deepbook_registry"
+        }),
+        actionForMoveCall: deepbookActionForMoveCall
+    },
+    {
+        protocolId: "deeptrade-core",
+        displayName: "DeepTrade Core",
+        activityCategory: "DeepBook wrapper and fee system",
+        packages: normalizePackageMap({
+            [DEEPTRADE_CORE_PACKAGE]: {
+                source: "mvr_current_mainnet_resolution_and_deeptrade_research_snapshot",
+                mvrName: "@deeptrade/deeptrade-core"
+            }
+        }),
+        sharedObjects: normalizeObjectMap({
+            "0xb90e2d3de41817016b7d39f49c724c5b0616bd30f1d5e6383048efafabe6232b": "deeptrade_treasury",
+            "0xe6a7158cbbee252f2ef9488663d91b42d84b3933609c3f891937240f4be65086": "deeptrade_pool_creation_config",
+            "0xcb757e55db3a502dc826c40b8ced507d017b41d926c5bf554e69855510bb855e": "deeptrade_trading_fee_config",
+            "0x6a06100001533356fb2e9f68ee299c15565777dfb28c741ec440cb08b168cbff": "deeptrade_loyalty_program"
+        }),
+        actionForMoveCall: deeptradeActionForMoveCall
+    },
+    {
+        protocolId: "cetus-clmm",
+        displayName: "Cetus CLMM",
+        activityCategory: "CLMM / AMM",
+        packages: normalizePackageMap({
+            [CETUS_CLMM_PACKAGE]: {
+                source: "mvr_current_mainnet_resolution_and_cetus_research_snapshot",
+                mvrName: "@cetuspackages/clmm"
+            }
+        }),
+        sharedObjects: normalizeObjectMap({
+            "0xdaa46292632c3c4d8f31f23ea0f9b36a28ff3677e9684980e4438403a67a3d8f": "cetus_global_config",
+            "0xf699e7f2276f5c9a75944b37a0c5b5d9ddfd2471bf6242483b03ab2887d198d0": "cetus_pools_table"
+        }),
+        actionForMoveCall: clmmActionForMoveCall
+    },
+    {
+        protocolId: "suilend-lending",
+        displayName: "Suilend Lending",
+        activityCategory: "Lending market",
+        packages: normalizePackageMap({
+            [SUILEND_MVR_CORE_PACKAGE]: {
+                source: "mvr_current_mainnet_resolution",
+                mvrName: "@suilend/core"
+            },
+            [SUILEND_MAIN_MARKET_TYPE_PACKAGE]: {
+                source: "suilend_research_snapshot_market_type",
+                matchKinds: ["eventType", "objectType"]
+            }
+        }),
+        sharedObjects: normalizeObjectMap({
+            "0x84030d26d85eaa7035084a057f2f11f701b7e2e4eda87551becbc7c97505ece1": "suilend_main_market",
+            "0xf7a4defe0b6566b6a2674a02a0c61c9f99bd012eed21bc741a069eaa82d35927": "suilend_main_market_owner_cap"
+        }),
+        actionForMoveCall: lendingActionForMoveCall
+    },
+    {
+        protocolId: "aftermath-afsui",
+        displayName: "Aftermath afSUI",
+        activityCategory: "Liquid staking",
+        packages: normalizePackageMap({
+            [AFTERMATH_AFSUI_EVENTS_PACKAGE]: {
+                source: "aftermath_research_snapshot",
+                matchKinds: ["eventType", "objectType"]
+            },
+            [AFTERMATH_AFSUI_PACKAGE]: {
+                source: "aftermath_research_snapshot",
+                matchKinds: ["eventType", "objectType"]
+            }
+        }),
+        sharedObjects: normalizeObjectMap({
+            "0x2f8f6d5da7f13ea37daa397724280483ed062769813b6f31e9788e59cc88994d": "aftermath_staked_sui_vault",
+            "0x55486449e41d89cfbdb20e005c1c5c1007858ad5b4d5d7c047d2b3b592fe8791": "aftermath_staked_sui_vault_state",
+            "0xd2b95022244757b0ab9f74e2ee2fb2c3bf29dce5590fa6993a85d64bd219d7e8": "aftermath_afsui_treasury"
+        })
+    }
+];
+function deepbookActionForMoveCall(call) {
+    if (call.module === "balance_manager") {
+        if (/^(deposit|withdraw|withdraw_all|mint_trade_cap|mint_deposit_cap|mint_withdraw_cap)/.test(call.function)) {
+            return "liquidity";
+        }
+        return "unknown";
+    }
+    if (call.module !== "pool") {
+        return "unknown";
+    }
+    if (/^(place_|modify_order|cancel_|withdraw_settled)/.test(call.function)) {
+        return "order";
+    }
+    if (/^swap_/.test(call.function)) {
+        return "swap";
+    }
+    if (/^(claim_|mint_referral|update_.*referral|burn_deep)/.test(call.function)) {
+        return "fee_or_reward";
+    }
+    if (/^(stake|unstake|submit_proposal|vote|create_|update_|adjust_|enable_|set_)/.test(call.function)) {
+        return "admin_or_versioning";
+    }
+    if (/^borrow_flashloan|^return_flashloan/.test(call.function)) {
+        return "liquidity";
+    }
+    return "unknown";
+}
+function deeptradeActionForMoveCall(call) {
+    if (call.module === "dt_order") {
+        return "order";
+    }
+    const combined = `${call.module}_${call.function}`;
+    if (isAdminOrVersioningCall(combined) || /multisig|dt_pool/.test(call.module) || /create_permissionless_pool/.test(call.function)) {
+        return "admin_or_versioning";
+    }
+    if (call.module === "swap") {
+        return "swap";
+    }
+    if (/fee|treasury|loyalty/.test(call.module) || /fee|loyalty|reserve/.test(call.function)) {
+        return "fee_or_reward";
+    }
+    return "unknown";
+}
+function clmmActionForMoveCall(call) {
+    const combined = `${call.module}_${call.function}`;
+    if (isAdminOrVersioningCall(combined)) {
+        return "admin_or_versioning";
+    }
+    if (/swap|exchange/.test(combined)) {
+        return "swap";
+    }
+    if (/fee|reward|collect|claim/.test(combined)) {
+        return "fee_or_reward";
+    }
+    if (/liquidity|position|mint|burn|open|close|increase|decrease/.test(combined)) {
+        return "liquidity";
+    }
+    return "unknown";
+}
+function lendingActionForMoveCall(call) {
+    const combined = `${call.module}_${call.function}`;
+    if (isAdminOrVersioningCall(combined) || /config|owner|risk|isolated|oracle/.test(combined)) {
+        return "admin_or_versioning";
+    }
+    if (/deposit|withdraw|borrow|repay|liquidat|redeem|mint|supply/.test(combined)) {
+        return "lending";
+    }
+    if (/reward|fee|claim/.test(combined)) {
+        return "fee_or_reward";
+    }
+    return "unknown";
+}
+export function protocolPackageRuleAllows(rule, kind) {
+    return rule.matchKinds === undefined || rule.matchKinds.includes(kind);
+}
+function isAdminOrVersioningCall(value) {
+    const tokens = value.split("_").filter((token) => token.length > 0);
+    return tokens.some((token) => [
+        "admin",
+        "config",
+        "owner",
+        "risk",
+        "oracle",
+        "version",
+        "registry",
+        "govern",
+        "pause",
+        "upgrade",
+        "set",
+        "update",
+        "allowed"
+    ].includes(token));
+}
+function normalizePackageMap(packages) {
+    return Object.fromEntries(Object.entries(packages).flatMap(([address, value]) => {
+        const normalized = parseSuiAddress(address);
+        return normalized === undefined ? [] : [[normalized, value]];
+    }));
+}
+function normalizeObjectMap(objects) {
+    return Object.fromEntries(Object.entries(objects).flatMap(([address, label]) => {
+        const normalized = parseSuiAddress(address);
+        return normalized === undefined ? [] : [[normalized, label]];
+    }));
+}

package/dist/core/activity/transactionActivityScanPolicy.js

@@ -0,0 +1,170 @@
+import { EXTERNAL_ACTIVITY_SCAN_DEFAULT_LIMIT, EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT } from "./activityStore.js";
+import { externalActivityTransactionTouchesAccount } from "./transactionActivityDetails.js";
+import { TransactionActivityError } from "./transactionActivityTypes.js";
+export function normalizeActivityLimit(limit) {
+    if (limit === undefined) {
+        return EXTERNAL_ACTIVITY_SCAN_DEFAULT_LIMIT;
+    }
+    if (!Number.isInteger(limit) || limit < 1 || limit > EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT) {
+        throw new TransactionActivityError("input_invalid", "limit must be an integer from 1 to 100", {
+            limit,
+            min: 1,
+            max: EXTERNAL_ACTIVITY_SCAN_MAX_LIMIT
+        });
+    }
+    return limit;
+}
+export function normalizeCheckpointBound(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!/^\d+$/.test(value)) {
+        throw new TransactionActivityError("input_invalid", "checkpoint bounds must be unsigned integer strings", { field });
+    }
+    if (BigInt(value) > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new TransactionActivityError("input_invalid", "checkpoint bounds exceed the current GraphQL numeric filter range", {
+            field,
+            max: String(Number.MAX_SAFE_INTEGER)
+        });
+    }
+    return value;
+}
+export function assertCheckpointRange(fromCheckpoint, toCheckpoint) {
+    if (fromCheckpoint !== undefined && toCheckpoint !== undefined && BigInt(fromCheckpoint) > BigInt(toCheckpoint)) {
+        throw new TransactionActivityError("input_invalid", "fromCheckpoint must be less than or equal to toCheckpoint", {
+            fromCheckpoint,
+            toCheckpoint
+        });
+    }
+}
+export function normalizeTimestampBound(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()) || parsed.toISOString() !== value) {
+        throw new TransactionActivityError("input_invalid", "timestamp bounds must be ISO 8601 UTC timestamps", { field });
+    }
+    return value;
+}
+export function assertTimestampRange(fromTimestamp, toTimestamp) {
+    if (fromTimestamp !== undefined && toTimestamp !== undefined && fromTimestamp > toTimestamp) {
+        throw new TransactionActivityError("input_invalid", "fromTimestamp must be less than or equal to toTimestamp", {
+            fromTimestamp,
+            toTimestamp
+        });
+    }
+}
+export function isMonotonicActivityOrder(transactions) {
+    let direction;
+    for (let index = 1; index < transactions.length; index += 1) {
+        const previous = transactions[index - 1];
+        const current = transactions[index];
+        const comparison = compareActivityFactTimeAscending(previous, current);
+        if (comparison === 0) {
+            continue;
+        }
+        const pairDirection = comparison < 0 ? "ascending" : "descending";
+        if (direction === undefined) {
+            direction = pairDirection;
+            continue;
+        }
+        if (direction !== pairDirection) {
+            return false;
+        }
+    }
+    return true;
+}
+export function compareActivityFactsDescending(a, b) {
+    return -compareActivityFactsAscending(a, b);
+}
+export function windowCompletion(input, page, orderingVerified) {
+    const hasLowerBound = input.fromCheckpoint !== undefined || input.fromTimestamp !== undefined;
+    const hasAnyWindowBound = hasLowerBound || input.toCheckpoint !== undefined || input.toTimestamp !== undefined;
+    if (!hasAnyWindowBound) {
+        return null;
+    }
+    if (!page.hasMore) {
+        return true;
+    }
+    if (!orderingVerified) {
+        return false;
+    }
+    const reachedCheckpoint = input.fromCheckpoint === undefined
+        ? false
+        : page.transactions.some((transaction) => transaction.checkpoint !== undefined && BigInt(transaction.checkpoint) <= BigInt(input.fromCheckpoint));
+    const reachedTimestamp = input.fromTimestamp === undefined
+        ? false
+        : page.transactions.some((transaction) => transaction.timestamp !== undefined && transaction.timestamp <= input.fromTimestamp);
+    return reachedCheckpoint || reachedTimestamp;
+}
+export function incompleteReasonForScan(input) {
+    if (!input.orderingVerified) {
+        return "ordering_unverified";
+    }
+    return input.windowComplete === false ? "limit_reached" : undefined;
+}
+export function filterTransactionsForRequestedWindow(transactions, input) {
+    return transactions.filter((transaction) => {
+        if (input.relationship === "sent" && transaction.sender !== input.account) {
+            return false;
+        }
+        if (input.fromCheckpoint !== undefined && (transaction.checkpoint === undefined || BigInt(transaction.checkpoint) < BigInt(input.fromCheckpoint))) {
+            return false;
+        }
+        if (input.toCheckpoint !== undefined && (transaction.checkpoint === undefined || BigInt(transaction.checkpoint) > BigInt(input.toCheckpoint))) {
+            return false;
+        }
+        if (input.fromTimestamp !== undefined && (transaction.timestamp === undefined || transaction.timestamp < input.fromTimestamp)) {
+            return false;
+        }
+        if (input.toTimestamp !== undefined && (transaction.timestamp === undefined || transaction.timestamp > input.toTimestamp)) {
+            return false;
+        }
+        return true;
+    });
+}
+export function transactionMatchesKnownStorageAccount(transaction, account, relationship) {
+    if (relationship === "sent") {
+        return transaction.sender === account;
+    }
+    return transaction.sender === account || externalActivityTransactionTouchesAccount(transaction, account);
+}
+function compareActivityFactsAscending(a, b) {
+    const timeComparison = compareActivityFactTimeAscending(a, b);
+    return timeComparison === 0 ? compareStringsAscending(a.digest, b.digest) : timeComparison;
+}
+function compareActivityFactTimeAscending(a, b) {
+    if (a.checkpoint !== undefined && b.checkpoint !== undefined) {
+        const checkpointDelta = BigInt(a.checkpoint) - BigInt(b.checkpoint);
+        if (checkpointDelta < 0n)
+            return -1;
+        if (checkpointDelta > 0n)
+            return 1;
+    }
+    else if (a.checkpoint !== undefined) {
+        return 1;
+    }
+    else if (b.checkpoint !== undefined) {
+        return -1;
+    }
+    if (a.timestamp !== undefined && b.timestamp !== undefined) {
+        const timestampDelta = compareStringsAscending(a.timestamp, b.timestamp);
+        if (timestampDelta !== 0)
+            return timestampDelta;
+    }
+    else if (a.timestamp !== undefined) {
+        return 1;
+    }
+    else if (b.timestamp !== undefined) {
+        return -1;
+    }
+    return 0;
+}
+function compareStringsAscending(a, b) {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+}