@stelis/say-ur-intent 0.0.0 → 0.0.2

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;
+}