@kynesyslabs/demosdk 2.4.19 → 2.4.20

package/build/index.d.ts

@@ -12,3 +12,4 @@ export * as abstraction from "./abstraction";
 export * as web2 from "./websdk/Web2Calls";
 export * as bridge from "./bridge";
 export * as instantMessaging from "./instant_messaging";
+export * as storage from "./storage";

package/build/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.instantMessaging = exports.bridge = exports.web2 = exports.abstraction = exports.websdk = exports.l2ps = exports.demoswork = exports.wallet = exports.xmcore = exports.xmwebsdk = exports.xmlocalsdk = exports.utils = exports.encryption = exports.types = void 0;
+exports.storage = exports.instantMessaging = exports.bridge = exports.web2 = exports.abstraction = exports.websdk = exports.l2ps = exports.demoswork = exports.wallet = exports.xmcore = exports.xmwebsdk = exports.xmlocalsdk = exports.utils = exports.encryption = exports.types = void 0;
 // Common types and constants
 exports.types = __importStar(require("./types"));
 // Basic cryptographic and data manipulation functions
@@ -52,4 +52,5 @@ exports.web2 = __importStar(require("./websdk/Web2Calls"));
 // Export bridge module and its types
 exports.bridge = __importStar(require("./bridge"));
 exports.instantMessaging = __importStar(require("./instant_messaging"));
+exports.storage = __importStar(require("./storage"));
 //# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAA6B;AAC7B,iDAAgC;AAChC,sDAAsD;AACtD,2DAA0C;AAC1C,iDAAgC;AAEhC,gCAAgC;AAChC,oEAAmD;AACnD,gEAA+C;AAC/C,4DAA2C,CAAC,gCAAgC;AAE5E,mDAAkC;AAClC,yDAAwC;AAExC,+CAA8B;AAE9B,mDAAkC;AAClC,6DAA4C;AAC5C,2DAA0C;AAE1C,qCAAqC;AACrC,mDAAkC;AAElC,wEAAuD"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAA6B;AAC7B,iDAAgC;AAChC,sDAAsD;AACtD,2DAA0C;AAC1C,iDAAgC;AAEhC,gCAAgC;AAChC,oEAAmD;AACnD,gEAA+C;AAC/C,4DAA2C,CAAC,gCAAgC;AAE5E,mDAAkC;AAClC,yDAAwC;AAExC,+CAA8B;AAE9B,mDAAkC;AAClC,6DAA4C;AAC5C,2DAA0C;AAE1C,qCAAqC;AACrC,mDAAkC;AAElC,wEAAuD;AAEvD,qDAAoC"}

package/build/storage/StorageProgram.d.ts

@@ -0,0 +1,192 @@
+import type { StorageProgramPayload, StorageProgramAccessControl } from "../types/blockchain/TransactionSubtypes/StorageProgramTransaction";
+/**
+ * Storage Program class for creating and managing key-value storage on Demos Network
+ *
+ * Features:
+ * - Deterministic address derivation (stor-{sha256})
+ * - Key-value storage with 128KB limit
+ * - Access control (private, public, restricted, deployer-only)
+ * - Nested data structures (max 64 levels)
+ *
+ * @example
+ * ```typescript
+ * import { StorageProgram } from '@kynesyslabs/demosdk'
+ *
+ * // Derive storage address
+ * const address = StorageProgram.deriveStorageAddress(
+ *   'myDeployerAddress',
+ *   'myAppConfig',
+ *   'randomSalt123'
+ * )
+ *
+ * // Create storage program
+ * const payload = StorageProgram.createStorageProgram(
+ *   'myDeployerAddress',
+ *   'myAppConfig',
+ *   { apiKey: 'secret', endpoint: 'https://api.example.com' },
+ *   'public',
+ *   'randomSalt123'
+ * )
+ * ```
+ */
+export declare class StorageProgram {
+    /**
+     * Derive a deterministic storage program address
+     *
+     * @param deployerAddress - Address of the program deployer
+     * @param programName - Name of the storage program
+     * @param salt - Optional random salt for uniqueness (default: empty string)
+     * @returns Storage address in format: stor-{first 40 chars of sha256}
+     *
+     * @example
+     * ```typescript
+     * const address = StorageProgram.deriveStorageAddress(
+     *   'demos1abc...',
+     *   'myConfig',
+     *   'salt123'
+     * )
+     * // Returns: 'stor-7a8b9c...' (40 chars after prefix)
+     * ```
+     */
+    static deriveStorageAddress(deployerAddress: string, programName: string, salt?: string): string;
+    /**
+     * Create a new Storage Program
+     *
+     * @param deployerAddress - Address creating the storage program (will be the deployer)
+     * @param programName - Name of the storage program
+     * @param initialData - Initial key-value data to store
+     * @param accessControl - Access control mode (default: 'private')
+     * @param salt - Optional random salt for address derivation
+     * @param allowedAddresses - List of allowed addresses (for 'restricted' mode)
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * const payload = StorageProgram.createStorageProgram(
+     *   'demos1abc...',
+     *   'userPreferences',
+     *   { theme: 'dark', language: 'en' },
+     *   'private'
+     * )
+     * ```
+     */
+    static createStorageProgram(deployerAddress: string, programName: string, initialData: Record<string, any>, accessControl?: StorageProgramAccessControl, salt?: string, allowedAddresses?: string[]): StorageProgramPayload;
+    /**
+     * Write or update key-value data in a Storage Program
+     *
+     * @param storageAddress - The storage program address (stor-{hash})
+     * @param data - Key-value data to write/update
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * const payload = StorageProgram.writeStorage(
+     *   'stor-7a8b9c...',
+     *   { newKey: 'value', existingKey: 'updatedValue' }
+     * )
+     * ```
+     */
+    static writeStorage(storageAddress: string, data: Record<string, any>): StorageProgramPayload;
+    /**
+     * Read data from a Storage Program (query operation, not a transaction)
+     *
+     * Note: This creates a payload for validation purposes.
+     * Actual reads should use RPC endpoints like GET /storage-program/:address
+     *
+     * @param storageAddress - The storage program address to read from
+     * @returns StorageProgramPayload for validation
+     *
+     * @example
+     * ```typescript
+     * // For transaction validation (not typical usage)
+     * const payload = StorageProgram.readStorage('stor-7a8b9c...')
+     *
+     * // Typical usage: Use RPC endpoint
+     * // fetch(`${rpcUrl}/storage-program/${storageAddress}`)
+     * ```
+     */
+    static readStorage(storageAddress: string): StorageProgramPayload;
+    /**
+     * Update access control settings for a Storage Program (deployer only)
+     *
+     * @param storageAddress - The storage program address
+     * @param accessControl - New access control mode
+     * @param allowedAddresses - Updated list of allowed addresses (for 'restricted' mode)
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * // Change from private to public
+     * const payload = StorageProgram.updateAccessControl(
+     *   'stor-7a8b9c...',
+     *   'public'
+     * )
+     *
+     * // Set restricted access with allowlist
+     * const payload = StorageProgram.updateAccessControl(
+     *   'stor-7a8b9c...',
+     *   'restricted',
+     *   ['demos1user1...', 'demos1user2...']
+     * )
+     * ```
+     */
+    static updateAccessControl(storageAddress: string, accessControl: StorageProgramAccessControl, allowedAddresses?: string[]): StorageProgramPayload;
+    /**
+     * Delete an entire Storage Program (deployer only)
+     *
+     * WARNING: This operation is irreversible and will delete all stored data.
+     *
+     * @param storageAddress - The storage program address to delete
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * const payload = StorageProgram.deleteStorageProgram('stor-7a8b9c...')
+     * ```
+     */
+    static deleteStorageProgram(storageAddress: string): StorageProgramPayload;
+    /**
+     * Validate storage size against 128KB limit
+     *
+     * @param data - The data object to validate
+     * @returns true if size is within limit, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const data = { key: 'value', nested: { data: 'here' } }
+     * if (StorageProgram.validateSize(data)) {
+     *   // Safe to store
+     * }
+     * ```
+     */
+    static validateSize(data: Record<string, any>): boolean;
+    /**
+     * Get the size of data in bytes
+     *
+     * @param data - The data object to measure
+     * @returns Size in bytes
+     *
+     * @example
+     * ```typescript
+     * const size = StorageProgram.getDataSize({ key: 'value' })
+     * console.log(`Data size: ${size} bytes`)
+     * ```
+     */
+    static getDataSize(data: Record<string, any>): number;
+    /**
+     * Validate nesting depth (max 64 levels)
+     *
+     * @param data - The data object to validate
+     * @param maxDepth - Maximum allowed nesting depth (default: 64)
+     * @returns true if nesting depth is within limit
+     *
+     * @example
+     * ```typescript
+     * const data = { level1: { level2: { level3: 'value' } } }
+     * if (StorageProgram.validateNestingDepth(data)) {
+     *   // Safe nesting depth
+     * }
+     * ```
+     */
+    static validateNestingDepth(data: any, maxDepth?: number): boolean;
+}

package/build/storage/StorageProgram.js

@@ -0,0 +1,257 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageProgram = void 0;
+const crypto_1 = require("crypto");
+// REVIEW: Storage Program class for key-value storage with access control
+/**
+ * Storage Program class for creating and managing key-value storage on Demos Network
+ *
+ * Features:
+ * - Deterministic address derivation (stor-{sha256})
+ * - Key-value storage with 128KB limit
+ * - Access control (private, public, restricted, deployer-only)
+ * - Nested data structures (max 64 levels)
+ *
+ * @example
+ * ```typescript
+ * import { StorageProgram } from '@kynesyslabs/demosdk'
+ *
+ * // Derive storage address
+ * const address = StorageProgram.deriveStorageAddress(
+ *   'myDeployerAddress',
+ *   'myAppConfig',
+ *   'randomSalt123'
+ * )
+ *
+ * // Create storage program
+ * const payload = StorageProgram.createStorageProgram(
+ *   'myDeployerAddress',
+ *   'myAppConfig',
+ *   { apiKey: 'secret', endpoint: 'https://api.example.com' },
+ *   'public',
+ *   'randomSalt123'
+ * )
+ * ```
+ */
+class StorageProgram {
+    /**
+     * Derive a deterministic storage program address
+     *
+     * @param deployerAddress - Address of the program deployer
+     * @param programName - Name of the storage program
+     * @param salt - Optional random salt for uniqueness (default: empty string)
+     * @returns Storage address in format: stor-{first 40 chars of sha256}
+     *
+     * @example
+     * ```typescript
+     * const address = StorageProgram.deriveStorageAddress(
+     *   'demos1abc...',
+     *   'myConfig',
+     *   'salt123'
+     * )
+     * // Returns: 'stor-7a8b9c...' (40 chars after prefix)
+     * ```
+     */
+    static deriveStorageAddress(deployerAddress, programName, salt = "") {
+        // Create hash input: deployerAddress:programName:salt
+        const hashInput = `${deployerAddress}:${programName}:${salt}`;
+        // SHA-256 hash and take first 40 characters
+        const hash = (0, crypto_1.createHash)("sha256").update(hashInput).digest("hex");
+        const addressHash = hash.substring(0, 40);
+        return `stor-${addressHash}`;
+    }
+    /**
+     * Create a new Storage Program
+     *
+     * @param deployerAddress - Address creating the storage program (will be the deployer)
+     * @param programName - Name of the storage program
+     * @param initialData - Initial key-value data to store
+     * @param accessControl - Access control mode (default: 'private')
+     * @param salt - Optional random salt for address derivation
+     * @param allowedAddresses - List of allowed addresses (for 'restricted' mode)
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * const payload = StorageProgram.createStorageProgram(
+     *   'demos1abc...',
+     *   'userPreferences',
+     *   { theme: 'dark', language: 'en' },
+     *   'private'
+     * )
+     * ```
+     */
+    static createStorageProgram(deployerAddress, programName, initialData, accessControl = "private", salt, allowedAddresses) {
+        // Derive storage address
+        const storageAddress = this.deriveStorageAddress(deployerAddress, programName, salt || "");
+        return {
+            operation: "CREATE_STORAGE_PROGRAM",
+            storageAddress,
+            programName,
+            data: initialData,
+            accessControl,
+            allowedAddresses,
+            salt,
+        };
+    }
+    /**
+     * Write or update key-value data in a Storage Program
+     *
+     * @param storageAddress - The storage program address (stor-{hash})
+     * @param data - Key-value data to write/update
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * const payload = StorageProgram.writeStorage(
+     *   'stor-7a8b9c...',
+     *   { newKey: 'value', existingKey: 'updatedValue' }
+     * )
+     * ```
+     */
+    static writeStorage(storageAddress, data) {
+        return {
+            operation: "WRITE_STORAGE",
+            storageAddress,
+            data,
+        };
+    }
+    /**
+     * Read data from a Storage Program (query operation, not a transaction)
+     *
+     * Note: This creates a payload for validation purposes.
+     * Actual reads should use RPC endpoints like GET /storage-program/:address
+     *
+     * @param storageAddress - The storage program address to read from
+     * @returns StorageProgramPayload for validation
+     *
+     * @example
+     * ```typescript
+     * // For transaction validation (not typical usage)
+     * const payload = StorageProgram.readStorage('stor-7a8b9c...')
+     *
+     * // Typical usage: Use RPC endpoint
+     * // fetch(`${rpcUrl}/storage-program/${storageAddress}`)
+     * ```
+     */
+    static readStorage(storageAddress) {
+        return {
+            operation: "READ_STORAGE",
+            storageAddress,
+        };
+    }
+    /**
+     * Update access control settings for a Storage Program (deployer only)
+     *
+     * @param storageAddress - The storage program address
+     * @param accessControl - New access control mode
+     * @param allowedAddresses - Updated list of allowed addresses (for 'restricted' mode)
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * // Change from private to public
+     * const payload = StorageProgram.updateAccessControl(
+     *   'stor-7a8b9c...',
+     *   'public'
+     * )
+     *
+     * // Set restricted access with allowlist
+     * const payload = StorageProgram.updateAccessControl(
+     *   'stor-7a8b9c...',
+     *   'restricted',
+     *   ['demos1user1...', 'demos1user2...']
+     * )
+     * ```
+     */
+    static updateAccessControl(storageAddress, accessControl, allowedAddresses) {
+        return {
+            operation: "UPDATE_ACCESS_CONTROL",
+            storageAddress,
+            accessControl,
+            allowedAddresses,
+        };
+    }
+    /**
+     * Delete an entire Storage Program (deployer only)
+     *
+     * WARNING: This operation is irreversible and will delete all stored data.
+     *
+     * @param storageAddress - The storage program address to delete
+     * @returns StorageProgramPayload for transaction creation
+     *
+     * @example
+     * ```typescript
+     * const payload = StorageProgram.deleteStorageProgram('stor-7a8b9c...')
+     * ```
+     */
+    static deleteStorageProgram(storageAddress) {
+        return {
+            operation: "DELETE_STORAGE_PROGRAM",
+            storageAddress,
+        };
+    }
+    /**
+     * Validate storage size against 128KB limit
+     *
+     * @param data - The data object to validate
+     * @returns true if size is within limit, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const data = { key: 'value', nested: { data: 'here' } }
+     * if (StorageProgram.validateSize(data)) {
+     *   // Safe to store
+     * }
+     * ```
+     */
+    static validateSize(data) {
+        const jsonString = JSON.stringify(data);
+        const sizeInBytes = new TextEncoder().encode(jsonString).length;
+        const maxSizeInBytes = 128 * 1024; // 128KB
+        return sizeInBytes <= maxSizeInBytes;
+    }
+    /**
+     * Get the size of data in bytes
+     *
+     * @param data - The data object to measure
+     * @returns Size in bytes
+     *
+     * @example
+     * ```typescript
+     * const size = StorageProgram.getDataSize({ key: 'value' })
+     * console.log(`Data size: ${size} bytes`)
+     * ```
+     */
+    static getDataSize(data) {
+        const jsonString = JSON.stringify(data);
+        return new TextEncoder().encode(jsonString).length;
+    }
+    /**
+     * Validate nesting depth (max 64 levels)
+     *
+     * @param data - The data object to validate
+     * @param maxDepth - Maximum allowed nesting depth (default: 64)
+     * @returns true if nesting depth is within limit
+     *
+     * @example
+     * ```typescript
+     * const data = { level1: { level2: { level3: 'value' } } }
+     * if (StorageProgram.validateNestingDepth(data)) {
+     *   // Safe nesting depth
+     * }
+     * ```
+     */
+    static validateNestingDepth(data, maxDepth = 64) {
+        const getDepth = (obj, currentDepth = 1) => {
+            if (typeof obj !== "object" || obj === null) {
+                return currentDepth;
+            }
+            const depths = Object.values(obj).map(value => getDepth(value, currentDepth + 1));
+            return Math.max(...depths, currentDepth);
+        };
+        return getDepth(data) <= maxDepth;
+    }
+}
+exports.StorageProgram = StorageProgram;
+//# sourceMappingURL=StorageProgram.js.map

package/build/storage/StorageProgram.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageProgram.js","sourceRoot":"","sources":["../../../src/storage/StorageProgram.ts"],"names":[],"mappings":"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"}

package/build/storage/index.d.ts

@@ -0,0 +1,2 @@
+export { StorageProgram } from "./StorageProgram";
+export type { StorageProgramPayload, StorageProgramAccessControl, StorageProgramOperation, StorageProgramTransactionContent, StorageProgramTransaction, } from "../types/blockchain/TransactionSubtypes/StorageProgramTransaction";

package/build/storage/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageProgram = void 0;
+var StorageProgram_1 = require("./StorageProgram");
+Object.defineProperty(exports, "StorageProgram", { enumerable: true, get: function () { return StorageProgram_1.StorageProgram; } });
+//# sourceMappingURL=index.js.map

package/build/storage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/storage/index.ts"],"names":[],"mappings":";;;AAAA,mDAAiD;AAAxC,gHAAA,cAAc,OAAA"}

package/build/types/blockchain/Transaction.d.ts

@@ -10,12 +10,13 @@ import { InstantMessagingPayload } from "../instantMessaging";
 import { NativeBridgeTxPayload } from "../../bridge/nativeBridgeTypes";
 import { L2PSEncryptedPayload } from "../../l2ps";
 import { StoragePayload } from "./TransactionSubtypes/StorageTransaction";
+import { StorageProgramPayload } from "./TransactionSubtypes/StorageProgramTransaction";
 import { L2PSHashPayload } from "./TransactionSubtypes/L2PSHashTransaction";
 import { ContractDeployPayload } from "./TransactionSubtypes/ContractDeployTransaction";
 import { ContractCallPayload } from "./TransactionSubtypes/ContractCallTransaction";
-export type TransactionContentData = ["web2Request", IWeb2Payload] | ["crosschainOperation", XMScript] | ["native", INativePayload] | ["demoswork", DemoScript] | ["l2psEncryptedTx", L2PSEncryptedPayload] | ["identity", IdentityPayload] | ["instantMessaging", InstantMessagingPayload] | ["nativeBridge", NativeBridgeTxPayload] | ["storage", StoragePayload] | ["l2ps_hash_update", L2PSHashPayload] | ["contractDeploy", ContractDeployPayload] | ["contractCall", ContractCallPayload];
+export type TransactionContentData = ["web2Request", IWeb2Payload] | ["crosschainOperation", XMScript] | ["native", INativePayload] | ["demoswork", DemoScript] | ["l2psEncryptedTx", L2PSEncryptedPayload] | ["identity", IdentityPayload] | ["instantMessaging", InstantMessagingPayload] | ["nativeBridge", NativeBridgeTxPayload] | ["storage", StoragePayload] | ["storageProgram", StorageProgramPayload] | ["l2ps_hash_update", L2PSHashPayload] | ["contractDeploy", ContractDeployPayload] | ["contractCall", ContractCallPayload];
 export interface TransactionContent {
-    type: "web2Request" | "crosschainOperation" | "subnet" | "native" | "demoswork" | "genesis" | "NODE_ONLINE" | "identity" | "instantMessaging" | "nativeBridge" | "l2psEncryptedTx" | "storage" | "l2ps_hash_update" | "contractDeploy" | "contractCall";
+    type: "web2Request" | "crosschainOperation" | "subnet" | "native" | "demoswork" | "genesis" | "NODE_ONLINE" | "identity" | "instantMessaging" | "nativeBridge" | "l2psEncryptedTx" | "storage" | "storageProgram" | "l2ps_hash_update" | "contractDeploy" | "contractCall";
     from: string;
     from_ed25519_address: string;
     to: string;

package/build/types/blockchain/Transaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"Transaction.js","sourceRoot":"","sources":["../../../../src/types/blockchain/Transaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAqFA,uCAAuC;AACvC,wDAAqC"}
+{"version":3,"file":"Transaction.js","sourceRoot":"","sources":["../../../../src/types/blockchain/Transaction.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAwFA,uCAAuC;AACvC,wDAAqC"}

package/build/types/blockchain/TransactionSubtypes/StorageProgramTransaction.d.ts

@@ -0,0 +1,70 @@
+import { Transaction, TransactionContent } from "../Transaction";
+/**
+ * Storage Program operations
+ *
+ * - CREATE_STORAGE_PROGRAM: Initialize a new storage program with access control
+ * - WRITE_STORAGE: Write/update key-value pairs in the storage
+ * - READ_STORAGE: Query operation (not a transaction, used for validation)
+ * - UPDATE_ACCESS_CONTROL: Modify access control settings (deployer only)
+ * - DELETE_STORAGE_PROGRAM: Remove the entire storage program (deployer only)
+ */
+export type StorageProgramOperation = "CREATE_STORAGE_PROGRAM" | "WRITE_STORAGE" | "READ_STORAGE" | "UPDATE_ACCESS_CONTROL" | "DELETE_STORAGE_PROGRAM";
+/**
+ * Access control modes for Storage Programs
+ *
+ * - private: Only deployer can read and write
+ * - public: Anyone can read, only deployer can write
+ * - restricted: Only addresses in allowedAddresses can read/write
+ * - deployer-only: Only deployer has all permissions (same as private but explicit)
+ */
+export type StorageProgramAccessControl = "private" | "public" | "restricted" | "deployer-only";
+/**
+ * Storage Program payload for transaction data
+ *
+ * @property operation - The storage operation to perform
+ * @property storageAddress - The storage program address (stor-{hash})
+ * @property programName - Name of the storage program (required for CREATE)
+ * @property data - Key-value data to write (required for CREATE and WRITE)
+ * @property accessControl - Access control mode (optional for CREATE, required for UPDATE_ACCESS_CONTROL)
+ * @property allowedAddresses - List of allowed addresses for 'restricted' mode
+ * @property salt - Random salt for address derivation (optional for CREATE)
+ */
+export interface StorageProgramPayload {
+    /** The storage operation to perform */
+    operation: StorageProgramOperation;
+    /** The storage program address (stor-{hash format}) */
+    storageAddress: string;
+    /** Name of the storage program (required for CREATE_STORAGE_PROGRAM) */
+    programName?: string;
+    /** Key-value data to write (for CREATE_STORAGE_PROGRAM and WRITE_STORAGE) */
+    data?: Record<string, any>;
+    /** Access control mode */
+    accessControl?: StorageProgramAccessControl;
+    /** Allowed addresses for 'restricted' access control */
+    allowedAddresses?: string[];
+    /** Random salt for deterministic address derivation (optional) */
+    salt?: string;
+}
+/**
+ * Transaction content type for Storage Program operations.
+ * Extends the base TransactionContent with storageProgram-specific type and data.
+ */
+export type StorageProgramTransactionContent = Omit<TransactionContent, "type" | "data"> & {
+    type: "storageProgram";
+    data: ["storageProgram", StorageProgramPayload];
+};
+/**
+ * Complete Storage Program transaction interface.
+ * Used for structured key-value storage on the blockchain with access control.
+ *
+ * Storage Programs support:
+ * - Key-value storage (max 128KB per program)
+ * - Access control (private, public, restricted, deployer-only)
+ * - Deterministic address derivation
+ * - Nested data structures (max 64 levels)
+ *
+ * @see STORAGE_PROGRAMS_SPEC.md for complete specification
+ */
+export interface StorageProgramTransaction extends Omit<Transaction, "content"> {
+    content: StorageProgramTransactionContent;
+}

package/build/types/blockchain/TransactionSubtypes/StorageProgramTransaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=StorageProgramTransaction.js.map

package/build/types/blockchain/TransactionSubtypes/StorageProgramTransaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StorageProgramTransaction.js","sourceRoot":"","sources":["../../../../../src/types/blockchain/TransactionSubtypes/StorageProgramTransaction.ts"],"names":[],"mappings":""}

package/build/types/blockchain/TransactionSubtypes/index.d.ts

@@ -8,6 +8,7 @@ export * from './IdentityTransaction';
 export * from './InstantMessagingTransaction';
 export * from './NativeBridgeTransaction';
 export * from './StorageTransaction';
+export * from './StorageProgramTransaction';
 export * from './ContractDeployTransaction';
 export * from './ContractCallTransaction';
 import { L2PSTransaction } from './L2PSTransaction';
@@ -20,6 +21,7 @@ import { IdentityTransaction } from './IdentityTransaction';
 import { InstantMessagingTransaction } from './InstantMessagingTransaction';
 import { NativeBridgeTransaction } from './NativeBridgeTransaction';
 import { StorageTransaction } from './StorageTransaction';
+import { StorageProgramTransaction } from './StorageProgramTransaction';
 import { ContractDeployTransaction } from './ContractDeployTransaction';
 import { ContractCallTransaction } from './ContractCallTransaction';
-export type SpecificTransaction = L2PSTransaction | L2PSHashTransaction | Web2Transaction | CrosschainTransaction | NativeTransaction | DemosworkTransaction | IdentityTransaction | InstantMessagingTransaction | NativeBridgeTransaction | StorageTransaction | ContractDeployTransaction | ContractCallTransaction;
+export type SpecificTransaction = L2PSTransaction | L2PSHashTransaction | Web2Transaction | CrosschainTransaction | NativeTransaction | DemosworkTransaction | IdentityTransaction | InstantMessagingTransaction | NativeBridgeTransaction | StorageTransaction | StorageProgramTransaction | ContractDeployTransaction | ContractCallTransaction;

package/build/types/blockchain/TransactionSubtypes/index.js

@@ -24,6 +24,7 @@ __exportStar(require("./IdentityTransaction"), exports);
 __exportStar(require("./InstantMessagingTransaction"), exports);
 __exportStar(require("./NativeBridgeTransaction"), exports);
 __exportStar(require("./StorageTransaction"), exports);
+__exportStar(require("./StorageProgramTransaction"), exports);
 __exportStar(require("./ContractDeployTransaction"), exports);
 __exportStar(require("./ContractCallTransaction"), exports);
 //# sourceMappingURL=index.js.map

package/build/types/blockchain/TransactionSubtypes/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/blockchain/TransactionSubtypes/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAiC;AACjC,wDAAqC;AACrC,oDAAiC;AACjC,0DAAuC;AACvC,sDAAmC;AACnC,yDAAsC;AACtC,wDAAqC;AACrC,gEAA6C;AAC7C,4DAAyC;AACzC,uDAAoC;AACpC,8DAA2C;AAC3C,4DAAyC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../src/types/blockchain/TransactionSubtypes/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAiC;AACjC,wDAAqC;AACrC,oDAAiC;AACjC,0DAAuC;AACvC,sDAAmC;AACnC,yDAAsC;AACtC,wDAAqC;AACrC,gEAA6C;AAC7C,4DAAyC;AACzC,uDAAoC;AACpC,8DAA2C;AAC3C,8DAA2C;AAC3C,4DAAyC"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kynesyslabs/demosdk",
-    "version": "2.4.19",
+    "version": "2.4.20",
     "description": "Demosdk is a JavaScript/TypeScript SDK that provides a unified interface for interacting with Demos network",
     "main": "build/index.js",
     "types": "build/index.d.ts",