@cmdoss/memwal-sdk 0.6.0

package/dist/generated/pdw/memory.js

@@ -0,0 +1,681 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/**
+ * Memory management module for Personal Data Wallet
+ *
+ * This module provides memory record management with:
+ *
+ * - Rich metadata for encrypted content stored on Walrus
+ * - Support for both capability-based and legacy address-based access
+ * - Vector embedding storage for semantic search
+ * - Knowledge graph integration
+ *
+ * V2 Changes (Capability-based):
+ *
+ * - Added capability_id field to link memories to MemoryCap
+ * - New create_memory_with_cap() for capability-based creation
+ * - Maintains backward compatibility with existing functions
+ */
+import { MoveStruct, normalizeMoveArguments } from '../utils/index.js';
+import { bcs } from '@mysten/sui/bcs';
+import * as vec_map from './deps/sui/vec_map.js';
+import * as object from './deps/sui/object.js';
+const $moduleName = '@local-pkg/pdw::memory';
+export const MemoryCreated = new MoveStruct({ name: `${$moduleName}::MemoryCreated`, fields: {
+        id: bcs.Address,
+        owner: bcs.Address,
+        category: bcs.string(),
+        vector_id: bcs.u64(),
+        /** V2: Link to MemoryCap object ID */
+        capability_id: bcs.option(bcs.Address),
+        /**
+         * V2: App context for filtering (e.g., "MEMO", "HEALTH")
+         *
+         * - Query all: no filter
+         * - Query by context: filter by app_id
+         */
+        app_id: bcs.option(bcs.string())
+    } });
+export const MemoryIndexUpdated = new MoveStruct({ name: `${$moduleName}::MemoryIndexUpdated`, fields: {
+        id: bcs.Address,
+        owner: bcs.Address,
+        version: bcs.u64(),
+        index_blob_id: bcs.string(),
+        graph_blob_id: bcs.string()
+    } });
+export const MemoryMetadataUpdated = new MoveStruct({ name: `${$moduleName}::MemoryMetadataUpdated`, fields: {
+        memory_id: bcs.Address,
+        metadata_blob_id: bcs.string(),
+        embedding_dimension: bcs.u64()
+    } });
+export const MemoryUpdated = new MoveStruct({ name: `${$moduleName}::MemoryUpdated`, fields: {
+        id: bcs.Address,
+        owner: bcs.Address,
+        /**
+         * Fields that were updated (bitmask: 1=blob_id, 2=category, 4=topic, 8=importance,
+         * 16=embedding)
+         */
+        updated_fields: bcs.u8(),
+        new_blob_id: bcs.option(bcs.string()),
+        new_category: bcs.option(bcs.string()),
+        updated_at: bcs.u64()
+    } });
+export const MemoryMetadata = new MoveStruct({ name: `${$moduleName}::MemoryMetadata`, fields: {
+        content_type: bcs.string(),
+        content_size: bcs.u64(),
+        content_hash: bcs.string(),
+        category: bcs.string(),
+        topic: bcs.string(),
+        importance: bcs.u8(),
+        embedding_blob_id: bcs.string(),
+        embedding_dimension: bcs.u64(),
+        created_timestamp: bcs.u64(),
+        updated_timestamp: bcs.u64(),
+        custom_metadata: vec_map.VecMap(bcs.string(), bcs.string())
+    } });
+export const MemoryIndex = new MoveStruct({ name: `${$moduleName}::MemoryIndex`, fields: {
+        id: object.UID,
+        owner: bcs.Address,
+        version: bcs.u64(),
+        index_blob_id: bcs.string(),
+        graph_blob_id: bcs.string()
+    } });
+export const Memory = new MoveStruct({ name: `${$moduleName}::Memory`, fields: {
+        id: object.UID,
+        owner: bcs.Address,
+        category: bcs.string(),
+        vector_id: bcs.u64(),
+        blob_id: bcs.string(),
+        metadata: MemoryMetadata,
+        /**
+         * V2: Link to MemoryCap for capability-based access control If set, access is
+         * controlled via MemoryCap ownership If none, falls back to owner-based access
+         * (legacy)
+         */
+        capability_id: bcs.option(bcs.Address),
+        /**
+         * V2: App context for context-based querying Copied from MemoryCap.app_id for
+         * efficient filtering
+         *
+         * - Query all memories: getOwnedObjects without filter
+         * - Query by context: filter by app_id field
+         */
+        app_id: bcs.option(bcs.string())
+    } });
+/** Create a new memory index for a user */
+export function createMemoryIndex(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        'vector<u8>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["indexBlobId", "graphBlobId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'create_memory_index',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Update an existing memory index with new blob IDs */
+export function updateMemoryIndex(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryIndex`,
+        'u64',
+        'vector<u8>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["memoryIndex", "expectedVersion", "newIndexBlobId", "newGraphBlobId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'update_memory_index',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Create metadata struct with embedding */
+export function createMemoryMetadata(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        'vector<u8>',
+        'u64',
+        'vector<u8>',
+        'vector<u8>',
+        'vector<u8>',
+        'u8',
+        'vector<u8>',
+        'u64',
+        'u64'
+    ];
+    const parameterNames = ["contentType", "contentSize", "contentHash", "category", "topic", "importance", "embeddingBlobId", "embeddingDimension", "createdTimestamp"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'create_memory_metadata',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Create a new memory record with rich metadata (LEGACY - for backward
+ * compatibility)
+ *
+ * NOTE: For new implementations, use create_memory_with_cap() instead which
+ * provides capability-based access control.
+ */
+export function createMemoryRecord(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        'vector<u8>',
+        'u64',
+        'vector<u8>',
+        'vector<u8>',
+        'u64',
+        'vector<u8>',
+        'vector<u8>',
+        'u8',
+        'vector<u8>'
+    ];
+    const parameterNames = ["category", "vectorId", "blobId", "contentType", "contentSize", "contentHash", "topic", "importance", "embeddingBlobId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'create_memory_record',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Create a new memory record with capability-based access control (V2 -
+ * RECOMMENDED)
+ *
+ * This function links the memory to a MemoryCap for SEAL-compliant access control.
+ * Benefits:
+ *
+ * - Access controlled via MemoryCap ownership
+ * - Cross-dApp sharing "just works" (same owner = access)
+ * - No allowlist management needed
+ *
+ * @param cap: Reference to the MemoryCap (proves ownership) @param category:
+ * Memory category @param vector_id: Links to HNSW index @param blob_id: Pointer to
+ * encrypted content on Walrus @param content_type: MIME type @param content_size:
+ * Size in bytes @param content_hash: Content hash (blob_id) @param topic: Topic
+ * classification @param importance: Importance scale (1-10) @param
+ * embedding_blob_id: Pointer to embedding on Walrus @param ctx: Transaction
+ * context
+ */
+export function createMemoryWithCap(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::capability::MemoryCap`,
+        'vector<u8>',
+        'u64',
+        'vector<u8>',
+        'vector<u8>',
+        'u64',
+        'vector<u8>',
+        'vector<u8>',
+        'u8',
+        'vector<u8>'
+    ];
+    const parameterNames = ["cap", "category", "vectorId", "blobId", "contentType", "contentSize", "contentHash", "topic", "importance", "embeddingBlobId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'create_memory_with_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Update metadata for an existing memory */
+export function updateMemoryMetadata(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`,
+        'vector<u8>',
+        'u8'
+    ];
+    const parameterNames = ["memory", "newTopic", "newImportance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'update_memory_metadata',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Add custom metadata field */
+export function addCustomMetadata(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`,
+        'vector<u8>',
+        'vector<u8>'
+    ];
+    const parameterNames = ["memory", "key", "value"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'add_custom_metadata',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Comprehensive update for a memory record
+ *
+ * Updates multiple fields of a Memory object in a single transaction. Only
+ * non-empty values will be updated (empty vector<u8> = skip update).
+ *
+ * This function follows Sui's object model where:
+ *
+ * - Objects are passed as mutable references (&mut)
+ * - Version number is automatically incremented by Sui runtime
+ * - Changes are atomic within the transaction
+ *
+ * @param memory: Mutable reference to the Memory object @param new_blob_id: New
+ * Walrus blob ID (empty = no change) @param new_category: New category (empty = no
+ * change) @param new_topic: New topic (empty = no change) @param new_importance:
+ * New importance (0 = no change, 1-10 = update) @param new_embedding_blob_id: New
+ * embedding blob ID (empty = no change) @param new_content_hash: New content hash
+ * (empty = no change) @param new_content_size: New content size (0 = no change)
+ * @param ctx: Transaction context
+ */
+export function updateMemoryRecord(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`,
+        'vector<u8>',
+        'vector<u8>',
+        'vector<u8>',
+        'u8',
+        'vector<u8>',
+        'vector<u8>',
+        'u64'
+    ];
+    const parameterNames = ["memory", "newBlobId", "newCategory", "newTopic", "newImportance", "newEmbeddingBlobId", "newContentHash", "newContentSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'update_memory_record',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Update memory record with capability verification (V2)
+ *
+ * Same as update_memory_record but verifies the caller owns the associated
+ * MemoryCap. Use this for capability-based memories to ensure proper access
+ * control.
+ *
+ * @param cap: Reference to the MemoryCap (proves ownership) @param memory: Mutable
+ * reference to the Memory object @param new_blob_id: New Walrus blob ID (empty =
+ * no change) @param new_category: New category (empty = no change) @param
+ * new_topic: New topic (empty = no change) @param new_importance: New importance
+ * (0 = no change, 1-10 = update) @param new_embedding_blob_id: New embedding blob
+ * ID (empty = no change) @param new_content_hash: New content hash (empty = no
+ * change) @param new_content_size: New content size (0 = no change) @param ctx:
+ * Transaction context
+ */
+export function updateMemoryWithCap(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::capability::MemoryCap`,
+        `${packageAddress}::memory::Memory`,
+        'vector<u8>',
+        'vector<u8>',
+        'vector<u8>',
+        'u8',
+        'vector<u8>',
+        'vector<u8>',
+        'u64'
+    ];
+    const parameterNames = ["cap", "memory", "newBlobId", "newCategory", "newTopic", "newImportance", "newEmbeddingBlobId", "newContentHash", "newContentSize"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'update_memory_with_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Create a lightweight memory record (for use with Walrus metadata) - LEGACY
+ *
+ * This function creates a minimal on-chain Memory struct with only essential
+ * queryable fields. Rich metadata should be stored as Walrus blob metadata.
+ *
+ * Use this when:
+ *
+ * - Gas costs are a concern
+ * - Rich metadata is stored on Walrus blob
+ * - Only need basic filtering (category, vector_id)
+ *
+ * NOTE: For new implementations, use create_memory_lightweight_with_cap() instead
+ */
+export function createMemoryRecordLightweight(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        'vector<u8>',
+        'u64',
+        'vector<u8>',
+        'vector<u8>',
+        'u8'
+    ];
+    const parameterNames = ["category", "vectorId", "blobId", "blobObjectId", "importance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'create_memory_record_lightweight',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Create a lightweight memory record with capability-based access (V2 -
+ * RECOMMENDED)
+ *
+ * Gas-optimized version for capability-based access control.
+ *
+ * @param cap: Reference to the MemoryCap (proves ownership) @param category:
+ * Memory category @param vector_id: Links to HNSW index @param blob_id: Pointer to
+ * encrypted content on Walrus @param blob_object_id: Optional Walrus blob object
+ * ID @param importance: Importance scale (1-10) @param ctx: Transaction context
+ */
+export function createMemoryLightweightWithCap(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::capability::MemoryCap`,
+        'vector<u8>',
+        'u64',
+        'vector<u8>',
+        'vector<u8>',
+        'u8'
+    ];
+    const parameterNames = ["cap", "category", "vectorId", "blobId", "blobObjectId", "importance"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'create_memory_lightweight_with_cap',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Delete a memory record */
+export function deleteMemoryRecord(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'delete_memory_record',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getIndexBlobId(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryIndex`
+    ];
+    const parameterNames = ["memoryIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_index_blob_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getGraphBlobId(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryIndex`
+    ];
+    const parameterNames = ["memoryIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_graph_blob_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getVersion(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryIndex`
+    ];
+    const parameterNames = ["memoryIndex"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_version',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getMemoryBlobId(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_memory_blob_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getMemoryVectorId(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_memory_vector_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getMemoryCategory(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_memory_category',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getMetadata(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_metadata',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getEmbeddingBlobId(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_embedding_blob_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getContentType(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_content_type',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getContentSize(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_content_size',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getTopic(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_topic',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getImportance(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_importance',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getCreatedTimestamp(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_created_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getUpdatedTimestamp(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_updated_timestamp',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function getCustomMetadata(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::MemoryMetadata`
+    ];
+    const parameterNames = ["metadata"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_custom_metadata',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Get the capability_id from a memory (if linked to a MemoryCap) */
+export function getCapabilityId(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_capability_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Check if memory is linked to a capability (V2) */
+export function hasCapability(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'has_capability',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Check if memory is using legacy owner-based access */
+export function isLegacyAccess(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'is_legacy_access',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/**
+ * Get the app_id from a memory (for context-based querying) Returns None for
+ * legacy memories without capability
+ */
+export function getAppId(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`
+    ];
+    const parameterNames = ["memory"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'get_app_id',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Check if memory belongs to a specific app context */
+export function isAppContext(options) {
+    const packageAddress = options.package ?? '@local-pkg/pdw';
+    const argumentsTypes = [
+        `${packageAddress}::memory::Memory`,
+        '0x0000000000000000000000000000000000000000000000000000000000000001::string::String'
+    ];
+    const parameterNames = ["memory", "appId"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'memory',
+        function: 'is_app_context',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+//# sourceMappingURL=memory.js.map