{"id":835510,"date":"2026-02-18T18:57:53","date_gmt":"2026-02-18T18:57:53","guid":{"rendered":"https:\/\/gridnet.org\/wpp\/?p=835510"},"modified":"2026-02-20T07:57:38","modified_gmt":"2026-02-20T07:57:38","slug":"talking-to-the-blockchain-cvmcontext-deep-dive","status":"publish","type":"post","link":"https:\/\/mag.gridnet.org\/index.php\/2026\/02\/18\/talking-to-the-blockchain-cvmcontext-deep-dive\/","title":{"rendered":"Talking to the Blockchain \u2014 CVMContext Deep Dive"},"content":{"rendered":"

I. What CVMContext Is \u2014 And Why It Matters<\/h2>\n

Every revolution needs a bridge between worlds. The steam engine needed the drive shaft. The internet needed the browser. And GRIDNET OS \u2014 the world’s first fully decentralized operating system \u2014 needs CVMContext<\/code>.<\/p>\n

CVMContext<\/code> (defined in \/lib\/VMContext.js<\/code>) is the singular JavaScript singleton<\/strong> that connects your UI dApp, running inside a Shadow DOM in the user’s browser, to the entire decentralized stack beneath: the blockchain state machine, the decentralized filesystem, cryptographic identity, WebRTC swarms, consensus tasks, and more. It is not merely an API wrapper. It is the beating heart of every GRIDNET OS application \u2014 the central nervous system through which all signals flow.<\/p>\n

If you are a web developer building on GRIDNET OS, this is the<\/strong> document you need. Every method. Every event. Every pattern. From first connection to final commit.<\/p>\n

The architecture is deceptively simple. Your dApp is standard HTML, CSS, and JavaScript \u2014 skills you already have. CVMContext<\/code> bridges that familiar world to the decentralized one. It communicates with GRIDNET Core full-nodes over WebSocket, serializing commands through the VM Meta Data Protocol<\/strong> (BER-encoded ASN.1) and the DFS Protocol<\/strong> for filesystem operations. The result is that your JavaScript code can navigate directories, read files, send value, deploy contracts, and subscribe to blockchain events \u2014 all through a clean, event-driven API.<\/p>\n

\n\/\/ The most important line in any GRIDNET OS dApp\nconst ctx = CVMContext.getInstance();\n<\/pre>\n
That single call returns the global singleton. There is only ever one CVMContext<\/code> \u2014 it manages the WebSocket connection, the session key negotiation, the filesystem abstraction, the swarm manager, the channels manager, the keychain, and all event dispatch. Everything flows through it.<\/p>\n
<\/p>\n
II. Connection Lifecycle \u2014 From Boot to Ready<\/h2>\n
\"Connection
The connection lifecycle: WebSocket establishment, cryptographic handshake, session key negotiation, and VM thread spawning.<\/figcaption><\/figure>\n
When GRIDNET OS boots in the browser, the bootloader instantiates CVMContext<\/code> with one or more full-node URIs. What follows is a carefully orchestrated dance of connection, cryptography, and state synchronization.<\/p>\n
Phase 1: WebSocket Connection<\/h3>\n
The CVMContext<\/code> constructor stores the provided node URIs and starts an internal controller thread (a JavaScript interval at ~2000ms) that manages state transitions. When the context enters the active<\/code> state, it selects a node URI \u2014 either the “closest” one (based on a time-seeded hash heuristic) for the first connection, or a random one for reconnections \u2014 and opens a WebSocket.<\/p>\n
\n\/\/ The bootloader does this internally:\nconst ctx = new CVMContext(['wss:\/\/node1.gridnet.org:26039', 'wss:\/\/node2.gridnet.org:26039']);\nctx.initialize();\n<\/pre>\n
Phase 2: Hello Handshake & Key Exchange<\/h3>\n
Once the WebSocket opens, CVMContext<\/code> automatically sends a Hello Request<\/strong> containing a CSessionDescription<\/code> with the browser’s ephemeral X25519 public key and a random challenge. The full-node responds with its own CSessionDescription<\/code>. Through ECDH (Elliptic Curve Diffie-Hellman), both parties derive a shared session key<\/strong> used for all subsequent communication via ChaCha20-Poly1305 AEAD encryption.<\/p>\n
Phase 3: System Thread Spawning<\/h3>\n
After the session key is established, the full-node spawns a System Thread<\/strong> \u2014 a dedicated decentralized processing thread for this connection. The thread ID is communicated back to CVMContext<\/code>, which stores it. From this point, all GridScript commands execute within this thread’s context.<\/p>\n
Connection States<\/h3>\n
The connection progresses through states defined by eConnectionState<\/code>:<\/p>\n
\n\/\/ Monitor connection state changes\nCVMContext.getInstance().addConnectionStatusChangedListener(function(state) {\n    switch(state) {\n        case eConnectionState.disconnected:\n            console.log('Disconnected from GRIDNET Core');\n            break;\n        case eConnectionState.connecting:\n            console.log('Connecting...');\n            break;\n        case eConnectionState.connected:\n            console.log('Connected and ready!');\n            break;\n        case eConnectionState.aboutToShutDown:\n            console.log('Connection weakening (keepalive timeout approaching)');\n            break;\n    }\n}, this.mID);\n<\/pre>\n
CVMContext<\/code> handles reconnection autonomously. If the connection drops, the controller thread detects it and initiates a new connection to a randomly selected node. For keychain-based logins, the user session persists across reconnections \u2014 only QR-based sessions require re-authentication.<\/p>\n
VM States<\/h3>\n
The virtual machine on the full-node also transitions through states tracked by eVMState<\/code>:<\/p>\n
\n\/\/ All eVMState values (from \/lib\/enums.js):\n\/\/ eVMState.initializing          = 0  \u2014 VM is booting up\n\/\/ eVMState.ready                 = 1  \u2014 VM is ready for commands\n\/\/ eVMState.aboutToShutDown       = 2  \u2014 VM is about to shut down\n\/\/ eVMState.disabled              = 3  \u2014 VM thread is disabled \/ unavailable\n\/\/ eVMState.limitReached          = 4  \u2014 Resource limit reached\n\/\/ eVMState.errored               = 5  \u2014 VM encountered an error\n\/\/ eVMState.synced                = 6  \u2014 VM has been synchronized\n\/\/ eVMState.newPerspectiveAvailable = 7 \u2014 New blockchain perspective available\n\nCVMContext.getInstance().addVMStateChangedListener(function(arg) {\n    \/\/ arg.state contains the eVMState value\n    \/\/ arg.extended \u2014 if true, additional fields are available:\n    \/\/   arg.vmFlags, arg.vmID, arg.terminalID, arg.conversationID\n    \/\/ arg.threadID \u2014 the thread this state applies to\n    \n    switch(arg.state) {\n        case eVMState.initializing:\n            console.log('VM is initializing...');\n            break;\n        case eVMState.ready:\n            console.log('VM is ready \u2014 you can now execute commands');\n            break;\n        case eVMState.aboutToShutDown:\n            console.log('VM is about to shut down');\n            break;\n        case eVMState.disabled:\n            console.log('VM thread has been disabled');\n            break;\n        case eVMState.limitReached:\n            console.log('Resource limit reached');\n            break;\n        case eVMState.errored:\n            console.log('VM encountered an error');\n            break;\n        case eVMState.synced:\n            console.log('VM synchronized');\n            break;\n        case eVMState.newPerspectiveAvailable:\n            console.log('New perspective available \u2014 refresh state');\n            break;\n    }\n}, this.mID);\n<\/pre>\n
III. Navigation API \u2014 cd, ls, pwd, and Domain Resolution<\/h2>\n
\"Decentralized
Navigating the decentralized filesystem: state domains as root directories, hierarchical paths, and familiar shell commands.<\/figcaption><\/figure>\n
GRIDNET OS organizes all data into State Domains<\/strong> \u2014 analogous to user accounts or home directories \u2014 stored in Merkle Patricia Tries on the blockchain. Navigation within this filesystem feels intentionally familiar: it uses the same commands as Linux\/DOS shells.<\/p>\n
The filesystem is accessed through CVMContext.getInstance().getFileSystem<\/code>, which returns the CFileSystem<\/code> singleton. All filesystem operations ultimately compile to GridScript commands sent to the full-node.<\/p>\n
Changing Directory: cd<\/code><\/h3>\n
\nconst fs = CVMContext.getInstance().getFileSystem;\n\n\/\/ Navigate to a state domain (like a user's home directory)\nfs.doCD('\/alice.gridnet', true, false, false, threadID);\n\n\/\/ Navigate to a subdirectory\nfs.doCD('documents', true, false, false, threadID);\n\n\/\/ Navigate to root\nfs.doCD('\/', true, false, false, threadID);\n<\/pre>\n
The doCD(path, updatePWD, isAbsolute, silent, threadID)<\/code> method sends a cd<\/code> GridScript command to the full-node. The path can be absolute (starting with \/<\/code>) or relative. Each State Domain is a top-level directory under \/<\/code>.<\/p>\n
Listing Directory Contents: ls<\/code><\/h3>\n
\n\/\/ List current directory\nconst reqID = fs.doLS(threadID);\n\n\/\/ Listen for the result\nCVMContext.getInstance().addNewDFSMsgListener(function(dfsMsg) {\n    \/\/ DFS message contains VM Meta Data with directory listing\n    \/\/ Parse entries from the response\n}, this.mID);\n<\/pre>\n
Listing State Domains: csds<\/code><\/h3>\n
\n\/\/ List all state domains on the blockchain (like listing all user accounts)\n\/\/ Executed as raw GridScript\nCVMContext.getInstance().processGridScript('csds', threadID, processHandle);\n<\/pre>\n
Processing GridScript Commands Directly<\/h3>\n
For navigation and other operations, you can execute any GridScript command through the processGridScript()<\/code> method:<\/p>\n
\nconst ctx = CVMContext.getInstance();\n\n\/\/ Full signature:\n\/\/ processGridScript(cmd, threadID, processHandle, mode, reqID)\n\/\/   cmd          \u2014 GridScript command string (default: \"\")\n\/\/   threadID     \u2014 Decentralized thread ID (default: system thread)\n\/\/   processHandle \u2014 Calling CWindow\/process (REQUIRED for user-mode)\n\/\/   mode         \u2014 eVMMetaCodeExecutionMode (default: RAW)\n\/\/   reqID        \u2014 Request ID (default: 0, auto-generated)\n\n\/\/ User-mode method (requires a valid process handle)\nctx.processGridScript('cd \/alice.gridnet', threadID, myProcessHandle);\nctx.processGridScript('ls', threadID, myProcessHandle);\nctx.processGridScript('pwd', threadID, myProcessHandle);\n\n\/\/ With explicit mode (e.g., for terminal-style output)\nctx.processGridScript('ls', threadID, myProcessHandle, eVMMetaCodeExecutionMode.GUITerminal);\n<\/pre>\n
Important:<\/strong> processGridScript()<\/code> is a user-mode method that requires<\/em> a valid process handle. Anonymous calls will be rejected. This is a security feature \u2014 every operation on the decentralized state machine must be attributable to a registered process. For kernel-mode usage (system processes), use processGridScriptKM()<\/code> which accepts additional parameters including register<\/code> and promiseInfo<\/code> for async promise integration. There is also processGridScriptA()<\/code> which returns a Promise<\/code> for async\/await usage.<\/p>\n
IV. File Operations \u2014 Full CRUD on the Decentralized Filesystem<\/h2>\n
The decentralized filesystem supports complete CRUD operations. Each operation maps to a GridScript codeword that the full-node executes against the Merkle Patricia Trie state.<\/p>\n
touch<\/code> \u2014 Create an Empty File<\/h3>\n
\n\/\/ Create a new empty file\nctx.processGridScript('touch myfile.txt', threadID, processHandle);\n<\/pre>\n
write<\/code> \u2014 Write Data to a File<\/h3>\n
\n\/\/ Write content to a file\nctx.processGridScript('write myfile.txt', threadID, processHandle);\n\/\/ Note: content is provided through the DFS protocol's data fields\n<\/pre>\n
For file uploads, the FileManager dApp uses the DFS (Decentralized File System) protocol directly:<\/p>\n
\nconst fs = CVMContext.getInstance().getFileSystem;\n\n\/\/ The DFS protocol handles file content through specialized messages\n\/\/ Files can be stored as eternal (permanent) or voted (crowd-funded) storage\nfs.doCommit(false, threadID); \/\/ Commit changes to blockchain\n<\/pre>\n
cat<\/code> \u2014 Read File Contents<\/h3>\n
\n\/\/ Read a file's contents\nctx.processGridScript('cat myfile.txt', threadID, processHandle);\n\n\/\/ Result arrives via GridScript result listener\nctx.addNewGridScriptResultListener(function(result) {\n    if (result.reqID === myReqID) {\n        \/\/ result.data contains the file content\n        \/\/ result.types contains data type information\n        console.log('File content:', result.data);\n    }\n}, this.mID);\n<\/pre>\n
mkdir<\/code> \u2014 Create a Directory<\/h3>\n
\nctx.processGridScript('mkdir documents', threadID, processHandle);\n<\/pre>\n
rm<\/code> \u2014 Remove a File or Directory<\/h3>\n
\nctx.processGridScript('rm myfile.txt', threadID, processHandle);\n<\/pre>\n
head<\/code> \/ tail<\/code> \u2014 Read Portions of Files<\/h3>\n
\nctx.processGridScript('head myfile.txt', threadID, processHandle);\nctx.processGridScript('tail myfile.txt', threadID, processHandle);\n<\/pre>\n
Access Control: chown<\/code>, setfacl<\/code>, getfacl<\/code><\/h3>\n
\n\/\/ Change ownership of a file (base58-encoded address)\nctx.processGridScript('chown <base58address> myfile.txt', threadID, processHandle);\n\n\/\/ Set access control list\nctx.processGridScript('setfacl <base58address> myfile.txt', threadID, processHandle);\n\n\/\/ Get current ACL\nctx.processGridScript('getfacl myfile.txt', threadID, processHandle);\n<\/pre>\n
The DFS Commit Cycle<\/h3>\n
All filesystem modifications are transactional<\/strong>. Changes are staged locally and then committed to the blockchain through the DFS protocol. The commit cycle follows this pattern:<\/p>\n
\nconst fs = CVMContext.getInstance().getFileSystem;\n\n\/\/ 1. Make changes (cd, mkdir, touch, write, rm...)\n\/\/ 2. Synchronize\nfs.doSync();\n\n\/\/ 3. Commit changes to blockchain\nfs.doCommit(false, threadID);\n\n\/\/ 4. Listen for commit result\nCVMContext.getInstance().addVMCommitStateChangedListener(function(state) {\n    switch(state) {\n        case eCommitState.prePending:\n            console.log('Commit lock acquired locally');\n            break;\n        case eCommitState.pending:\n            console.log('Full-node confirmed commit is pending');\n            break;\n        case eCommitState.success:\n            console.log('Commit successful! Changes are on the blockchain.');\n            break;\n        case eCommitState.aborted:\n            console.log('Commit was aborted');\n            break;\n    }\n}, this.mID);\n<\/pre>\n
V. Transaction API \u2014 BT\/CT, Sending Value, Deploying Contracts<\/h2>\n
\"Transaction
The transaction lifecycle: BEGIN TRANSACTION (BT), execute operations, authenticate, COMMIT TRANSACTION (CT) \u2014 mapping directly to familiar SQL transaction semantics.<\/figcaption><\/figure>\n
GRIDNET OS uses a transaction model that will feel instantly familiar to any database developer. BT<\/code> (Begin Transaction) opens a transaction context, and CT<\/code> (Commit Transaction) finalizes it. Between them, you can send value, deploy smart contracts, and modify blockchain state. This maps directly to SQL’s BEGIN<\/code>\/COMMIT<\/code> paradigm.<\/p>\n
Sending Value (GNC Transfer)<\/h3>\n
GRIDNET OS supports two transaction modes:<\/p>\n
1. Remote Mode (Decentralized Threads API)<\/strong> \u2014 Commands are sent as GridScript to the full-node for compilation and execution:<\/p>\n
\n\/\/ Remote transaction: full-node compiles and executes\nconst ctx = CVMContext.getInstance();\n\n\/\/ The Wallet dApp constructs the GridScript command sequence:\nlet cmd = '';\ncmd += 'BT ';                           \/\/ Begin Transaction\ncmd += 'send ' + amount + ' ' + recipientAddress;  \/\/ Transfer value\ncmd += ' CT';                            \/\/ Commit Transaction\n\nctx.processGridScript(cmd, threadID, processHandle, eVMMetaCodeExecutionMode.RAW);\n\n\/\/ Authentication happens via QR code or local keychain signing\n\/\/ The full-node sends a QRIntentAuth request that CVMContext handles\n<\/pre>\n
2. Local Mode (Trustless Browser Compilation)<\/strong> \u2014 The transaction bytecode is compiled locally using GridScriptCompiler<\/code> and sent pre-compiled:<\/p>\n
\nimport { GridScriptCompiler } from '\/lib\/GridScriptCompiler.js';\nimport { CTransaction } from '\/lib\/Transaction.js';\n\n\/\/ Compile GridScript locally\nconst compiler = new GridScriptCompiler();\nconst script = 'send ' + amount + ' ' + recipientAddress;\nconst result = await compiler.compile(script);\n\nif (result.success) {\n    \/\/ Create and sign the transaction locally\n    const tx = new CTransaction();\n    tx.setBytecode(result.bytecode);\n    \/\/ ... set other transaction fields ...\n    \n    \/\/ Submit pre-compiled transaction\n    const result = await ctx.submitPreCompiledTransactionA(\n        tx.getPackedData(),\n        processHandle,  \/\/ process handle (required)\n        threadID,       \/\/ thread ID (optional)\n        30000           \/\/ timeout in ms\n    );\n}\n<\/pre>\n
The Commit Lock Mechanism<\/h3>\n
Before any commit, your dApp must acquire the commit lock<\/strong>. This prevents multiple applications from attempting simultaneous commits:<\/p>\n
\nconst ctx = CVMContext.getInstance();\n\n\/\/ 1. Try to acquire the commit lock\nif (ctx.tryLockCommit(processHandle)) {\n    \/\/ Lock acquired \u2014 proceed with commit\n    \n    \/\/ 2. Execute the commit\n    ctx.commit(processHandle, false, 'system');\n    \n    \/\/ 3. The Magic Button UI changes to \"committing\" state\n    \/\/ 4. Full-node sends commitPending \u2192 commitSuccess\/commitAborted\n} else {\n    console.log('Another application is currently committing');\n}\n<\/pre>\n
The lock has a timeout (mCommitLockTime<\/code>, default 60 seconds). If the full-node doesn’t confirm within the timeout, CVMContext<\/code> automatically retries up to 3 times with exponential backoff, then breaks the lock and sends an abort notification.<\/p>\n
The submitPreCompiledTransactionA()<\/code> Method<\/h3>\n
\n\/**\n * Submits a pre-compiled transaction to the network (user-mode, async)\n * @param {Uint8Array|ArrayBuffer} txData - BER-encoded transaction bytecode\n * @param {Object} processHandle - Calling process (CWindow instance, required)\n * @param {ArrayBuffer} [threadID=new ArrayBuffer()] - Thread to execute on (default: system thread)\n * @param {number} [timeoutMS=30000] - Timeout in milliseconds\n * @returns {Promise} - Resolves with result on success\n *\/\nasync submitPreCompiledTransactionA(txData, processHandle, threadID = new ArrayBuffer(), timeoutMS = 30000)\n<\/pre>\n
VI. Identity & Authentication<\/h2>\n
\"Identity
Two authentication paths: QR code scanning with the mobile app, or headless local keychain signing for seamless browser-only authentication.<\/figcaption><\/figure>\n
Authentication on GRIDNET OS is cryptographic, not password-based. Your identity is your key pair. CVMContext<\/code> provides two authentication pathways:<\/p>\n
QR Code Authentication<\/h3>\n
The traditional flow: a QR code is displayed containing the connection’s conversation ID, the full-node’s address, and a random challenge. The user scans it with the GRIDNET Token mobile app, which signs the challenge with their private key and sends the signature back through the full-node.<\/p>\n
\n\/\/ Trigger QR login\nctx.requestQRLogon();\n\n\/\/ Listen for login\nctx.addUserLogonListener(function(sessionDesc) {\n    console.log('User logged in:', ctx.getUserID);\n}, this.mID);\n<\/pre>\n
Local Keychain Authentication (Headless)<\/h3>\n
The newer, browser-only flow. Users can store encrypted keychains locally (protected by a master password). On login, CVMContext<\/code> decrypts the keychain and uses it to sign authentication challenges without any mobile device:<\/p>\n
\n\/\/ Request login \u2014 automatically detects available keychains\nawait ctx.requestLoginChoice();\n\n\/\/ Or directly request keychain login\nawait ctx.requestKeychainLogin();\n\n\/\/ Check login status\nif (ctx.isLoggedIn) {\n    console.log('Logged in as:', ctx.getUserID);\n    console.log('Keychain login:', ctx.mIsKeychainLogin);\n}\n<\/pre>\n
Identity Properties<\/h3>\n
\n\/\/ Get current user ID (State Domain name \/ address)\nctx.getUserID              \/\/ \u2192 \"alice.gridnet\" or \"Anonymous4521\"\n\n\/\/ Get full State Domain ID\nctx.getUserFullID          \/\/ \u2192 full state domain identifier\n\n\/\/ Check if logged in\nctx.isLoggedIn             \/\/ \u2192 true\/false\n\n\/\/ Get user session description (contains pubkey, address, etc.)\nctx.getUserSessionDescription  \/\/ \u2192 CSessionDescription object\n\n\/\/ Get key chain manager for programmatic key operations\nctx.getKeyChainManager     \/\/ \u2192 CKeyChainManager instance\n<\/pre>\n
Session Management<\/h3>\n
\n\/\/ Logout\nawait ctx.logout();\n\n\/\/ Switch identity (keychain logins only)\nawait ctx.switchIdentity();\n\n\/\/ Lock screen\nawait ctx.lockScreen();\n<\/pre>\n
VII. GridScript Compilation \u2014 The GridScriptCompiler<\/h2>\n
\"GridScript
The GridScriptCompiler transforms human-readable GridScript source into V2 bytecode with keyword hash chains \u2014 enabling trustless browser-side transaction compilation.<\/figcaption><\/figure>\n
The GridScriptCompiler<\/code> is a pure JavaScript implementation that compiles GridScript source code into bytecode compatible with GRIDNET Core’s C++ VM. This enables local, trustless transaction compilation<\/strong> \u2014 your browser can construct valid blockchain transactions without relying on the full-node for compilation.<\/p>\n
\nimport { GridScriptCompiler } from '\/lib\/GridScriptCompiler.js';\n\nconst compiler = new GridScriptCompiler();\n\n\/\/ Compile a simple value transfer\nconst result = await compiler.compile('send 100 recipientAddress');\n\nif (result.success) {\n    console.log('Bytecode:', result.bytecode);  \/\/ Uint8Array\n    console.log('No errors');\n} else {\n    console.log('Compilation errors:', result.errors);\n}\n<\/pre>\n
Bytecode Format<\/h3>\n
The compiler generates V2 bytecode<\/strong> by default:<\/p>\n
\nV2: [VERSION_BYTE][32_BYTE_HASH][OPCODES...]\n\n- VERSION_BYTE: 194 (0xC2) for V2\n- 32_BYTE_HASH: SHA-256 keyword image hash chain\n- OPCODES: Encoded codeword instructions\n<\/pre>\n
The keyword hash chain provides integrity verification: H\u2080 = SHA256(\"GRIDSCRIPT_V2_KEYWORD_IMAGE\")<\/code>, then H\u2099 = SHA256(H\u2099\u208b\u2081 || keyword)<\/code> for each compiled keyword. This ensures the bytecode hasn’t been tampered with.<\/p>\n
Opcode Encoding<\/h3>\n
\n- ID \u2264 127: Single byte [ID]\n- ID > 127: Two bytes [HIGH_BYTE | 0x80][LOW_BYTE] (little-endian with bit 7 set)\n<\/pre>\n
Key Codewords for dApp Developers<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Codeword<\/th>\nOpcode<\/th>\nDescription<\/th>\n<\/tr>\n
cd<\/code><\/td>\n162<\/td>\nChange directory<\/td>\n<\/tr>\n
ls<\/code><\/td>\n174<\/td>\nList directory contents<\/td>\n<\/tr>\n
mkdir<\/code><\/td>\n165<\/td>\nCreate directory<\/td>\n<\/tr>\n
touch<\/code><\/td>\n262<\/td>\nCreate empty file<\/td>\n<\/tr>\n
rm<\/code><\/td>\n263<\/td>\nRemove file\/directory<\/td>\n<\/tr>\n
write<\/code><\/td>\n233<\/td>\nWrite to file<\/td>\n<\/tr>\n
cat<\/code><\/td>\n104<\/td>\nRead file contents<\/td>\n<\/tr>\n
send<\/code><\/td>\n195<\/td>\nTransfer value (2 inline params)<\/td>\n<\/tr>\n
balance<\/code><\/td>\n198<\/td>\nQuery balance<\/td>\n<\/tr>\n
chown<\/code><\/td>\n225<\/td>\nChange ownership (base58)<\/td>\n<\/tr>\n
setfacl<\/code><\/td>\n223<\/td>\nSet access control (base58)<\/td>\n<\/tr>\n
getfacl<\/code><\/td>\n227<\/td>\nGet access control<\/td>\n<\/tr>\n
call<\/code><\/td>\n152<\/td>\nCall smart contract<\/td>\n<\/tr>\n
echo<\/code><\/td>\n157<\/td>\nOutput text<\/td>\n<\/tr>\n
whoami<\/code><\/td>\n235<\/td>\nCurrent identity<\/td>\n<\/tr>\n
info<\/code><\/td>\n199<\/td>\nDomain information<\/td>\n<\/tr>\n<\/table>\n
Encoding Utilities: CTools<\/h3>\n
The full CTools<\/code> class is exported from \/lib\/tools.js<\/code> and provides a comprehensive set of utilities \u2014 encoding, formatting, BigInt conversion, logging, GNC value formatting, and much more. This is the CTools<\/code> that CVMContext<\/code> itself uses internally.<\/p>\n
Important distinction:<\/strong> \/lib\/GridScriptCompiler.js<\/code> also exports a class named CTools<\/code>, but it is a stripped-down, environment-agnostic version<\/strong> containing only crypto and encoding utilities (SHA-256, Base58Check, Base64Check). This lightweight version exists so the compiler can run in both browser and Node.js environments without DOM dependencies. If you need the full toolkit (GNC formatting, path parsing, byte vector comparison, logging, etc.), import from \/lib\/tools.js<\/code>.<\/p>\n
\n\/\/ Full CTools \u2014 used by CVMContext and most dApps\nimport { CTools } from '\/lib\/tools.js';\nconst tools = CTools.getInstance();\n\n\/\/ Base58Check encode\/decode (for addresses)\nconst encoded = await tools.encodeBase58Check(binaryData);\nconst decoded = await tools.decodeBase58Check(encodedString);\n\n\/\/ Base64Check encode\/decode\nconst b64 = await tools.encodeBase64Check(binaryData);\n\n\/\/ SHA-256\nconst hash = await tools.sha256(data);\n\n\/\/ String \u2194 Bytes\nconst bytes = tools.stringToBytes('hello');\nconst str = tools.bytesToString(bytes);\n\n\/\/ GNC value formatting\nconst formatted = tools.formatGNCValue(valueInAttoGNC, 5); \/\/ \u2192 \"1.5 GNC\"\n\n\/\/ --- Stripped-down CTools for compiler\/Node.js use ---\n\/\/ import { CTools } from '\/lib\/GridScriptCompiler.js';\n\/\/ Only has: encodeBase58Check, decodeBase58Check, encodeBase64Check,\n\/\/           decodeBase64Check, sha256, stringToBytes, bytesToString\n<\/pre>\n
VIII. The Event System \u2014 Subscriptions and State Notifications<\/h2>\n
\"Event-driven
The event-driven architecture: register listeners, receive callbacks. Every state change, every network message, every block \u2014 all dispatched through a unified notification system.<\/figcaption><\/figure>\n
CVMContext’s architecture is fundamentally event-driven<\/strong>. Rather than polling for state changes, you register callback functions that fire when specific events occur. Every listener method returns a unique listener ID<\/strong> that can be used for later removal.<\/p>\n
Complete Event Listener Registry<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method<\/th>\nEvent<\/th>\n<\/tr>\n
addConnectionStatusChangedListener(cb, appID)<\/code><\/td>\nWebSocket connection state changes<\/td>\n<\/tr>\n
addVMStateChangedListener(cb, appID)<\/code><\/td>\nDecentralized VM state transitions<\/td>\n<\/tr>\n
addVMCommitStateChangedListener(cb, appID)<\/code><\/td>\nCommit operation state changes<\/td>\n<\/tr>\n
addContextStateChangedListener(cb, appID)<\/code><\/td>\nCVMContext internal state changes<\/td>\n<\/tr>\n
addNewNetMsgListener(cb, appID)<\/code><\/td>\nRaw network messages (CNetMsg)<\/td>\n<\/tr>\n
addNewDFSMsgListener(cb, appID)<\/code><\/td>\nDFS protocol messages<\/td>\n<\/tr>\n
addVMMetaDataListener(cb, appID)<\/code><\/td>\nVM Meta Data protocol messages<\/td>\n<\/tr>\n
addNewGridScriptResultListener(cb, appID)<\/code><\/td>\nGridScript execution results<\/td>\n<\/tr>\n
addNewTerminalDataListener(cb, appID)<\/code><\/td>\nTerminal I\/O data<\/td>\n<\/tr>\n
addNewAppDataListener(cb, appID)<\/code><\/td>\nApplication-specific data<\/td>\n<\/tr>\n
addUserLogonListener(cb, appID)<\/code><\/td>\nUser login events<\/td>\n<\/tr>\n
addUserActionRequestListener(cb, appID)<\/code><\/td>\nUser interaction requests (QR, password)<\/td>\n<\/tr>\n
addUserNotificationsListener(cb, appID)<\/code><\/td>\nSystem notifications<\/td>\n<\/tr>\n
addNewKeyBlockListener(cb, appID)<\/code><\/td>\nNew key blocks appended to chain<\/td>\n<\/tr>\n
addNewDataBlockListener(cb, appID)<\/code><\/td>\nNew data blocks appended to chain<\/td>\n<\/tr>\n
addNewConsensusActionListener(cb, appID)<\/code><\/td>\nConsensus task updates<\/td>\n<\/tr>\n
addSessionKeyAvailableListener(cb, appID)<\/code><\/td>\nSession key established<\/td>\n<\/tr>\n
addOperationStatusListener(cb, appID)<\/code><\/td>\nOperation status notifications<\/td>\n<\/tr>\n
addNewSwarmSDPMsgListener(cb, appID)<\/code><\/td>\nWebRTC SDP signaling messages<\/td>\n<\/tr>\n
addDFSRequestCompletedListener(cb, appID)<\/code><\/td>\nDFS request completion<\/td>\n<\/tr>\n
addNewSearchResultsListener(cb, appID)<\/code><\/td>\nBlockchain search results<\/td>\n<\/tr>\n
addNewBlockDetailsListener(cb, appID)<\/code><\/td>\nBlock detail responses<\/td>\n<\/tr>\n
addNewDomainDetailsListener(cb, appID)<\/code><\/td>\nDomain detail responses<\/td>\n<\/tr>\n
addNewTransactionDetailsListener(cb, appID)<\/code><\/td>\nTransaction detail responses<\/td>\n<\/tr>\n
addBlockchainStatsListener(cb, appID)<\/code><\/td>\nBlockchain statistics<\/td>\n<\/tr>\n<\/table>\n
Pattern: Register \u2192 Listen \u2192 Unregister<\/h3>\n
\nclass MyDApp extends CWindow {\n    constructor() {\n        super(\/* ... *\/);\n        \n        \/\/ Register listeners \u2014 store the IDs for cleanup\n        this.vmListenerID = CVMContext.getInstance()\n            .addVMStateChangedListener(this.onVMStateChanged.bind(this), this.mID);\n        this.dfsListenerID = CVMContext.getInstance()\n            .addNewDFSMsgListener(this.onDFSMessage.bind(this), this.mID);\n    }\n    \n    onVMStateChanged(arg) {\n        if (arg.state === eVMState.ready) {\n            this.loadData();\n        }\n    }\n    \n    onDFSMessage(dfsMsg) {\n        \/\/ Process filesystem responses\n    }\n    \n    \/\/ Clean up when window closes\n    closeWindow() {\n        CVMContext.getInstance().unregisterEventListenersByAppID(this.mID);\n        super.closeWindow();\n    }\n}\n<\/pre>\n
Critical:<\/strong> Always unregister your listeners when your dApp window closes. Use unregisterEventListenersByAppID(appID)<\/code> for bulk cleanup, or unregisterEventListenerByID(id)<\/code> for individual removal.<\/p>\n
IX. WebRTC Swarms \u2014 Cross-Browser Communication<\/h2>\n
\"WebRTC
WebRTC Swarms: browsers communicate directly through peer-to-peer data channels, using GRIDNET Core nodes for ICE signaling.<\/figcaption><\/figure>\n
GRIDNET OS includes a built-in WebRTC Swarms<\/strong> system that enables direct browser-to-browser communication without relying on the full-node for data transfer. The full-node serves only as the signaling server<\/strong> for ICE negotiation.<\/p>\n
\nconst ctx = CVMContext.getInstance();\nconst swarms = ctx.getSwarmsManager; \/\/ CSwarmsManager instance\n\n\/\/ Join the global swarm\nconst swarmID = ctx.getMainSwarmID; \/\/ 'global'\n\n\/\/ Listen for SDP signaling messages\nctx.addNewSwarmSDPMsgListener(function(sdpEntity) {\n    \/\/ Handle WebRTC signaling\n    \/\/ sdpEntity contains offer\/answer\/ICE candidates\n}, this.mID);\n\n\/\/ Get ICE server configuration\nconst iceServers = ctx.ICEServers;\n<\/pre>\n
The Messenger dApp demonstrates the full WebRTC pattern: SDP offer\/answer exchange through the GRIDNET signaling infrastructure, ICE candidate gathering, and direct peer data channel establishment. This enables real-time messaging, file sharing, and collaborative features between browsers.<\/p>\n
X. Blockchain Explorer API<\/h2>\n
CVMContext<\/code> provides a comprehensive set of methods for querying blockchain data. Each method comes in two variants: a callback-based<\/strong> version (returns a request ID) and an async\/Promise-based<\/strong> version (suffixed with A<\/code>).<\/p>\n
Async API Examples<\/h3>\n
\nconst ctx = CVMContext.getInstance();\n\n\/\/ Get blockchain status\nconst status = await ctx.getBlockchainStatusA(threadID, processHandle);\n\n\/\/ Get recent blocks\nconst blocks = await ctx.getRecentBlocksA(10, 1, eSortBlocksBy.timestampDesc, \n    threadID, processHandle);\n\n\/\/ Get recent transactions\nconst txs = await ctx.getRecentTransactionsA(10, 1, false, threadID, processHandle);\n\n\/\/ Search the blockchain\nconst results = await ctx.searchBlockchainA('alice', 10, 1, null, \n    threadID, processHandle);\n\n\/\/ Get domain details\nconst domain = await ctx.getDomainDetailsA('alice.gridnet', '', false, \n    threadID, processHandle);\n\n\/\/ Get domain transaction history\nconst history = await ctx.getDomainHistoryA('alice.gridnet', 10, 1, \n    eSortTransactionsBy.timestampDesc, '', threadID, processHandle);\n\n\/\/ Get block details\nconst block = await ctx.getBlockDetailsA(blockID, true, false, false, \n    threadID, processHandle);\n\n\/\/ Get transaction details\nconst tx = await ctx.getTransactionDetailsA(txID, threadID, processHandle);\n\n\/\/ Get blockchain height\nconst height = await ctx.getHeightA(false, threadID, processHandle);\nconst keyHeight = await ctx.getHeightA(true, threadID, processHandle);\n\n\/\/ Get USDT price\nconst price = await ctx.getUSDTPriceA(threadID, processHandle);\n\n\/\/ Get market data\nconst market = await ctx.getMarketDataA(true, true, 1, 50, null, \n    eSortOrder.ascending, threadID, processHandle);\n\n\/\/ Subscribe to real-time updates\nawait ctx.subscribeToBlockchainUpdatesA(threadID, processHandle);\n<\/pre>\n
XI. Advanced Features \u2014 Token Pools, State-Less Channels, DFS<\/h2>\n
\"Advanced
Advanced features: Multi-Dimensional Token Pools for custom tokens, State-Less Channels for instant off-chain payments, and DFS for decentralized file storage.<\/figcaption><\/figure>\n
Token Pools<\/h3>\n
GRIDNET OS supports Multi-Dimensional Token Pools<\/strong> \u2014 custom tokens that can be deployed on the blockchain. The CStateLessChannelsManager<\/code> and related classes handle token pool operations:<\/p>\n
\nconst ctx = CVMContext.getInstance();\nconst channels = ctx.getChannelsManager; \/\/ CStateLessChannelsManager\n\n\/\/ User's token pools are tracked\nconst pools = ctx.getUserTokenPools;\n\n\/\/ Token pool operations use GridScript:\n\/\/ regPool \u2014 register a token pool\n\/\/ getPool \u2014 query pool state\n\/\/ xTT \u2014 transfer tokens\n\/\/ poll \u2014 poll for updates\n<\/pre>\n
State-Less Channels<\/h3>\n
State-Less Channels provide instant, off-chain payment channels<\/strong>. They work by establishing a cryptographic commitment between parties that can be settled on-chain at any time:<\/p>\n
\nconst channels = CVMContext.getInstance().getChannelsManager;\n\/\/ CStateLessChannelsManager handles channel lifecycle\n\/\/ CStateLessChannel represents individual channels\n\/\/ CTransmissionToken represents off-chain payment proofs\n<\/pre>\n
Process & Thread Management<\/h3>\n
\n\/\/ Create a JavaScript thread (runs in browser)\nconst threadID = ctx.createJSThread(\n    myFunction,         \/\/ function to execute\n    processID,          \/\/ owning process\n    1000,              \/\/ interval in ms\n    true,              \/\/ auto-start\n    false              \/\/ kernel mode\n);\n\n\/\/ Stop a thread\nctx.stopJSThread(threadID);\n\n\/\/ Create a decentralized thread (runs on full-node)\nconst reqID = ctx.createThread(threadID, processID);\n\n\/\/ Free a decentralized thread\nctx.freeThread(threadID, processID);\n\n\/\/ Send data to a thread\nctx.sendDataToThread(threadID, data);\n<\/pre>\n
Terminal Integration<\/h3>\n
\n\/\/ Send a line to the terminal\nctx.sendLine('ls -la\\r\\n', processID);\n\n\/\/ Send a keystroke\nctx.sendKeyStroke(13, processID, threadID); \/\/ Enter key\n\n\/\/ Send terminal dimensions\nctx.sendTerminalDimensions(24, 80, processID);\n<\/pre>\n
XII. Complete CVMContext Method Reference<\/h2>\n
\"Complete
The complete CVMContext API \u2014 every method, property, and accessor available to your dApp.<\/figcaption><\/figure>\n
Core Singleton & Identity<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method\/Property<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
CVMContext.getInstance(...nodeURIs)<\/code><\/td>\nCVMContext<\/td>\nGet or create the singleton instance<\/td>\n<\/tr>\n
initialize()<\/code><\/td>\nvoid<\/td>\nInitialize all subsystems (called by bootloader)<\/td>\n<\/tr>\n
genRequestID()<\/code><\/td>\nnumber<\/td>\nGenerate a unique request ID<\/td>\n<\/tr>\n
get getUserID<\/code><\/td>\nstring<\/td>\nCurrent user identifier<\/td>\n<\/tr>\n
set setUserID<\/code><\/td>\nvoid<\/td>\nSet user identifier<\/td>\n<\/tr>\n
get getUserFullID<\/code><\/td>\nstring<\/td>\nFull state domain identifier<\/td>\n<\/tr>\n
get isLoggedIn<\/code><\/td>\nboolean<\/td>\nWhether a user session is active<\/td>\n<\/tr>\n
get getUserSessionDescription<\/code><\/td>\nCSessionDescription<\/td>\nCurrent user session details<\/td>\n<\/tr>\n
requestLoginChoice()<\/code><\/td>\nvoid<\/td>\nShow login method selection dialog<\/td>\n<\/tr>\n
requestQRLogon()<\/code><\/td>\nvoid<\/td>\nShow QR code for mobile app login<\/td>\n<\/tr>\n
requestKeychainLogin()<\/code><\/td>\nPromise<\/td>\nLogin via local keychain<\/td>\n<\/tr>\n
logout()<\/code><\/td>\nPromise<\/td>\nLogout and clear session<\/td>\n<\/tr>\n
switchIdentity()<\/code><\/td>\nPromise<\/td>\nSwitch sub-identity (keychain only)<\/td>\n<\/tr>\n
lockScreen()<\/code><\/td>\nPromise<\/td>\nLock screen requiring re-auth<\/td>\n<\/tr>\n<\/table>\n
Connection & State<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method\/Property<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
get getConnectionState<\/code><\/td>\neConnectionState<\/td>\nCurrent WebSocket connection state<\/td>\n<\/tr>\n
get getVMState<\/code><\/td>\neVMState<\/td>\nCurrent VM state<\/td>\n<\/tr>\n
get getState<\/code><\/td>\neContextState<\/td>\nContext internal state<\/td>\n<\/tr>\n
get getCommitState<\/code><\/td>\neCommitState<\/td>\nCurrent commit operation state<\/td>\n<\/tr>\n
get getFullNodeIP<\/code><\/td>\nstring<\/td>\nCurrent full-node IP address<\/td>\n<\/tr>\n
get getCurrentNodeURI<\/code><\/td>\nstring<\/td>\nCurrent WebSocket URI<\/td>\n<\/tr>\n
get getSessionKey<\/code><\/td>\nArrayBuffer<\/td>\nCurrent session encryption key<\/td>\n<\/tr>\n
get getConversationID<\/code><\/td>\nArrayBuffer<\/td>\nLocal conversation identifier<\/td>\n<\/tr>\n
get getSystemThreadID<\/code><\/td>\nArrayBuffer<\/td>\nSystem decentralized thread ID<\/td>\n<\/tr>\n
get getIsCommiting<\/code><\/td>\nboolean<\/td>\nWhether a commit is in progress<\/td>\n<\/tr>\n
forceNode(nodeURI)<\/code><\/td>\nvoid<\/td>\nForce connection to specific node<\/td>\n<\/tr>\n
clearForcedNode()<\/code><\/td>\nvoid<\/td>\nClear forced node selection<\/td>\n<\/tr>\n
endConnection()<\/code><\/td>\nvoid<\/td>\nTerminate current connection<\/td>\n<\/tr>\n<\/table>\n
GridScript Execution<\/h3>\n\n\n\n\n\n\n\n
Method<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
processGridScript(cmd, threadID, processHandle, mode?, reqID?)<\/code><\/td>\nboolean|reqID<\/td>\nExecute GridScript (user-mode, requires process handle). Defaults: mode=RAW, reqID=auto<\/td>\n<\/tr>\n
processGridScriptA(cmd, threadID, processHandle, mode?, reqID?, timeoutMS?)<\/code><\/td>\nPromise<\/td>\nExecute GridScript (async\/Promise-based, user-mode)<\/td>\n<\/tr>\n
processGridScriptKM(cmd, threadID, processHandle, mode?, reqID?, register?, promiseInfo?)<\/code><\/td>\nnumber|false<\/td>\nExecute GridScript (kernel-mode, returns reqID)<\/td>\n<\/tr>\n
submitPreCompiledTransactionA(txData, processHandle, threadID?, timeoutMS?)<\/code><\/td>\nPromise<\/td>\nSubmit pre-compiled transaction bytecode (user-mode, async)<\/td>\n<\/tr>\n
processVMMetaData(generator, processHandle)<\/code><\/td>\nboolean<\/td>\nSend VM Meta Data (user-mode)<\/td>\n<\/tr>\n<\/table>\n
Filesystem & Subsystems<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Property<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
get getFileSystem<\/code><\/td>\nCFileSystem<\/td>\nDecentralized filesystem interface<\/td>\n<\/tr>\n
get getSwarmsManager<\/code><\/td>\nCSwarmsManager<\/td>\nWebRTC swarms manager<\/td>\n<\/tr>\n
get getChannelsManager<\/code><\/td>\nCStateLessChannelsManager<\/td>\nState-less channels manager<\/td>\n<\/tr>\n
get getKeyChainManager<\/code><\/td>\nCKeyChainManager<\/td>\nLocal keychain manager<\/td>\n<\/tr>\n
get getCryptoFactory<\/code><\/td>\nCX25519<\/td>\nCryptographic operations (ECDH, signing)<\/td>\n<\/tr>\n
get getLocalDataStore<\/code><\/td>\nCLocalDataStore<\/td>\nBrowser-local storage<\/td>\n<\/tr>\n
get getWindowManager<\/code><\/td>\nCWindowManager<\/td>\nWindow management<\/td>\n<\/tr>\n
get getPackageManager<\/code><\/td>\nCPackageManager<\/td>\ndApp package management<\/td>\n<\/tr>\n
get getSettingsManager<\/code><\/td>\nCSettingsManager<\/td>\nPer-user settings<\/td>\n<\/tr>\n
get getDNS<\/code><\/td>\nCDNS<\/td>\nDNS resolution<\/td>\n<\/tr>\n
get getMagicButton<\/code><\/td>\nCMagicButton<\/td>\nMagic Button (commit UI control)<\/td>\n<\/tr>\n
get getMetaParser<\/code><\/td>\nCVMMetaParser<\/td>\nVM Meta Data parser<\/td>\n<\/tr>\n
get getMetaGenerator<\/code><\/td>\nCVMMetaGenerator<\/td>\nVM Meta Data generator<\/td>\n<\/tr>\n<\/table>\n
Transaction & Commit<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n
Method<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
tryLockCommit(appHandle, breakLock)<\/code><\/td>\nboolean<\/td>\nAttempt to acquire commit lock<\/td>\n<\/tr>\n
commit(appHandle, breakLock, threadID)<\/code><\/td>\nboolean<\/td>\nExecute commit operation<\/td>\n<\/tr>\n
breakCommitLock(wasSuccess)<\/code><\/td>\nvoid<\/td>\nRelease the commit lock<\/td>\n<\/tr>\n
syncVM(breakCommit, processHandle)<\/code><\/td>\nboolean<\/td>\nSynchronize with VM state (user-mode)<\/td>\n<\/tr>\n
syncVMKF(breakCommit, processHandle)<\/code><\/td>\nboolean<\/td>\nSynchronize with VM state (kernel-mode)<\/td>\n<\/tr>\n
scopeSystemThread(scopeCommitTarget, scopeHomeDir)<\/code><\/td>\nboolean<\/td>\nScope system thread to user’s domain<\/td>\n<\/tr>\n
set setCommitTarget<\/code><\/td>\nvoid<\/td>\nSet target network (TestNet\/MainNet)<\/td>\n<\/tr>\n
get getCommitTarget<\/code><\/td>\neBlockchainMode<\/td>\nCurrent target network<\/td>\n<\/tr>\n
get getTotalPendingOutgressTransfer<\/code><\/td>\nBigInt<\/td>\nTotal pending outgoing value<\/td>\n<\/tr>\n<\/table>\n
Thread & Process Management<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
createJSThread(funcPtr, processID, intervalMS, autoRun, isKernelMode)<\/code><\/td>\nnumber<\/td>\nCreate a browser-side JS thread<\/td>\n<\/tr>\n
stopJSThread(threadID)<\/code><\/td>\nboolean<\/td>\nStop a JS thread<\/td>\n<\/tr>\n
createThread(threadID, processID)<\/code><\/td>\nnumber<\/td>\nCreate decentralized thread on full-node<\/td>\n<\/tr>\n
freeThread(threadID, processID)<\/code><\/td>\nboolean<\/td>\nFree a decentralized thread<\/td>\n<\/tr>\n
sendDataToThread(threadID, data, netMsgType)<\/code><\/td>\nboolean<\/td>\nSend data to a specific thread<\/td>\n<\/tr>\n
getThreadByID(id)<\/code><\/td>\nCThread|null<\/td>\nFind thread by ID across all processes<\/td>\n<\/tr>\n
getNewProcessID()<\/code><\/td>\nnumber<\/td>\nGenerate new user-mode process ID<\/td>\n<\/tr>\n
getNewThreadID(isKernelMode)<\/code><\/td>\nnumber<\/td>\nGenerate new thread ID<\/td>\n<\/tr>\n
registerProcessByWinHandle(windowHandle)<\/code><\/td>\nboolean<\/td>\nRegister a CWindow as a process<\/td>\n<\/tr>\n
unregisterProcess(processID)<\/code><\/td>\nboolean<\/td>\nUnregister a process<\/td>\n<\/tr>\n
getProcessByID(id)<\/code><\/td>\nCProcess<\/td>\nFind process by ID<\/td>\n<\/tr>\n
getProcessByThreadID(id)<\/code><\/td>\nCProcess|null<\/td>\nFind process owning a thread<\/td>\n<\/tr>\n<\/table>\n
Blockchain Explorer API<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
getRecentTransactions(size, page, includeMem, ...)<\/code><\/td>\nreqID<\/td>\nGet recent transactions (callback)<\/td>\n<\/tr>\n
getRecentTransactionsA(size, page, ...)<\/code><\/td>\nPromise<CSearchResults><\/td>\nGet recent transactions (async)<\/td>\n<\/tr>\n
getRecentBlocks(size, page, sort, ...)<\/code><\/td>\nreqID<\/td>\nGet recent blocks (callback)<\/td>\n<\/tr>\n
getRecentBlocksA(size, page, ...)<\/code><\/td>\nPromise<\/td>\nGet recent blocks (async)<\/td>\n<\/tr>\n
searchBlockchain(query, size, page, flags, ...)<\/code><\/td>\nreqID<\/td>\nSearch blockchain (callback)<\/td>\n<\/tr>\n
searchBlockchainA(query, ...)<\/code><\/td>\nPromise<\/td>\nSearch blockchain (async)<\/td>\n<\/tr>\n
getBlockDetails(blockID, includeTX, ...)<\/code><\/td>\nreqID<\/td>\nGet block details (callback)<\/td>\n<\/tr>\n
getBlockDetailsA(blockID, ...)<\/code><\/td>\nPromise<\/td>\nGet block details (async)<\/td>\n<\/tr>\n
getDomainDetails(address, perspective, ...)<\/code><\/td>\nreqID<\/td>\nGet domain details (callback)<\/td>\n<\/tr>\n
getDomainDetailsA(address, ...)<\/code><\/td>\nPromise<\/td>\nGet domain details (async)<\/td>\n<\/tr>\n
getDomainHistory(address, size, page, ...)<\/code><\/td>\nreqID<\/td>\nGet domain tx history (callback)<\/td>\n<\/tr>\n
getDomainHistoryA(address, ...)<\/code><\/td>\nPromise<\/td>\nGet domain tx history (async)<\/td>\n<\/tr>\n
getTransactionDetails(txID, ...)<\/code><\/td>\nreqID<\/td>\nGet transaction details (callback)<\/td>\n<\/tr>\n
getTransactionDetailsA(txID, ...)<\/code><\/td>\nPromise<\/td>\nGet transaction details (async)<\/td>\n<\/tr>\n
getBlockchainStatus(...)<\/code><\/td>\nreqID<\/td>\nGet blockchain status (callback)<\/td>\n<\/tr>\n
getBlockchainStatusA(...)<\/code><\/td>\nPromise<\/td>\nGet blockchain status (async)<\/td>\n<\/tr>\n
getHeight(isKeyHeight, ...)<\/code><\/td>\nreqID<\/td>\nGet chain height (callback, cached)<\/td>\n<\/tr>\n
getHeightA(isKeyHeight, ...)<\/code><\/td>\nPromise<number><\/td>\nGet chain height (async, cached)<\/td>\n<\/tr>\n
getUSDTPrice(...)<\/code><\/td>\nreqID<\/td>\nGet USDT price (callback)<\/td>\n<\/tr>\n
getUSDTPriceA(...)<\/code><\/td>\nPromise<\/td>\nGet USDT price (async)<\/td>\n<\/tr>\n
getLiveness(...)<\/code><\/td>\nreqID<\/td>\nGet liveness state (callback)<\/td>\n<\/tr>\n
getLivenessA(...)<\/code><\/td>\nPromise<\/td>\nGet liveness state (async)<\/td>\n<\/tr>\n
getTransactionDailyStats(days, ...)<\/code><\/td>\nreqID<\/td>\nGet daily tx stats (callback)<\/td>\n<\/tr>\n
getTransactionDailyStatsA(days, ...)<\/code><\/td>\nPromise<\/td>\nGet daily tx stats (async)<\/td>\n<\/tr>\n
getNetworkUtilization24h(...)<\/code><\/td>\nreqID<\/td>\n24h network utilization (callback)<\/td>\n<\/tr>\n
getNetworkUtilization24hA(...)<\/code><\/td>\nPromise<\/td>\n24h network utilization (async)<\/td>\n<\/tr>\n
getBlockSize24h(...)<\/code><\/td>\nreqID<\/td>\n24h avg block size (callback)<\/td>\n<\/tr>\n
getBlockSize24hA(...)<\/code><\/td>\nPromise<\/td>\n24h avg block size (async)<\/td>\n<\/tr>\n
getBlockRewards24h(...)<\/code><\/td>\nreqID<\/td>\n24h avg rewards (callback)<\/td>\n<\/tr>\n
getBlockRewards24hA(...)<\/code><\/td>\nPromise<\/td>\n24h avg rewards (async)<\/td>\n<\/tr>\n
getAverageBlockTime24h(...)<\/code><\/td>\nreqID<\/td>\n24h avg block time (callback)<\/td>\n<\/tr>\n
getAverageBlockTime24hA(...)<\/code><\/td>\nPromise<\/td>\n24h avg block time (async)<\/td>\n<\/tr>\n
getAverageKeyBlockTime24h(...)<\/code><\/td>\nreqID<\/td>\n24h avg key-block time (callback)<\/td>\n<\/tr>\n
getAverageKeyBlockTime24hA(...)<\/code><\/td>\nPromise<\/td>\n24h avg key-block time (async)<\/td>\n<\/tr>\n
getMiningDifficulty(count, start, end, ...)<\/code><\/td>\nreqID<\/td>\nMining difficulty stats (callback)<\/td>\n<\/tr>\n
getMiningDifficultyA(count, ...)<\/code><\/td>\nPromise<\/td>\nMining difficulty stats (async, cacheable)<\/td>\n<\/tr>\n
getMarketData(getMarketCap, getBalances, ...)<\/code><\/td>\nreqID<\/td>\nMarket data (callback)<\/td>\n<\/tr>\n
getMarketDataA(getMarketCap, ...)<\/code><\/td>\nPromise<\/td>\nMarket data (async)<\/td>\n<\/tr>\n
subscribeToBlockchainUpdates(...)<\/code><\/td>\nboolean<\/td>\nSubscribe to real-time updates<\/td>\n<\/tr>\n
subscribeToBlockchainUpdatesA(...)<\/code><\/td>\nPromise<boolean><\/td>\nSubscribe to updates (async)<\/td>\n<\/tr>\n
unsubscribeFromBlockchainUpdates(...)<\/code><\/td>\nboolean<\/td>\nUnsubscribe from updates<\/td>\n<\/tr>\n
unsubscribeFromBlockchainUpdatesA(...)<\/code><\/td>\nPromise<boolean><\/td>\nUnsubscribe from updates (async)<\/td>\n<\/tr>\n<\/table>\n
Networking & Security<\/h3>\n\n\n\n\n\n\n\n\n\n\n
Method\/Property<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
sendNetMsg(msg, breakCommit, UINotifyOnError)<\/code><\/td>\nboolean<\/td>\nSend authenticated\/encrypted CNetMsg<\/td>\n<\/tr>\n
sendDFSMsg(msg, breakCommit)<\/code><\/td>\nboolean<\/td>\nSend DFS protocol message<\/td>\n<\/tr>\n
notifyMobileToken(status, scope, reqID)<\/code><\/td>\nboolean<\/td>\nSend notification to mobile app via onion routing<\/td>\n<\/tr>\n
notifyOperationStatus(status, scope, reqID)<\/code><\/td>\nboolean<\/td>\nNotify operation status to peer<\/td>\n<\/tr>\n
get getKeyPair<\/code><\/td>\nObject<\/td>\nEphemeral X25519 key pair<\/td>\n<\/tr>\n
get ICEServers<\/code><\/td>\nArray<\/td>\nWebRTC ICE server configuration<\/td>\n<\/tr>\n
set setDoSignOutgressMsgs<\/code><\/td>\nvoid<\/td>\nEnable\/disable message signing<\/td>\n<\/tr>\n
get publicIPAddress<\/code><\/td>\nstring<\/td>\nAuto-detected public IP<\/td>\n<\/tr>\n<\/table>\n
UI & Logging<\/h3>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Method\/Property<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
logAppEvent(info, process, entryType, priority)<\/code><\/td>\nvoid<\/td>\nLog a user-mode application event<\/td>\n<\/tr>\n
set setLoggingEnabled<\/code><\/td>\nvoid<\/td>\nEnable\/disable logging<\/td>\n<\/tr>\n
set setLogVMStatus<\/code><\/td>\nvoid<\/td>\nEnable\/disable VM status logging<\/td>\n<\/tr>\n
set setLogNetPackets<\/code><\/td>\nvoid<\/td>\nEnable\/disable network packet logging<\/td>\n<\/tr>\n
set setLogVMmeta<\/code><\/td>\nvoid<\/td>\nEnable\/disable VM Meta Data logging<\/td>\n<\/tr>\n
set setLogTerminalPackets<\/code><\/td>\nvoid<\/td>\nEnable\/disable terminal packet logging<\/td>\n<\/tr>\n
set setLogAppEvents<\/code><\/td>\nvoid<\/td>\nEnable\/disable app event logging<\/td>\n<\/tr>\n
addGUITask(task, dispatchNotifications)<\/code><\/td>\nboolean<\/td>\nAdd a task to the GUI task queue<\/td>\n<\/tr>\n
playSound(sound)<\/code><\/td>\nvoid<\/td>\nPlay a system sound<\/td>\n<\/tr>\n
enterFullscreen()<\/code><\/td>\nvoid<\/td>\nEnter fullscreen mode<\/td>\n<\/tr>\n
exitFullscreen()<\/code><\/td>\nvoid<\/td>\nExit fullscreen mode<\/td>\n<\/tr>\n
set setGamingModeEnabled<\/code><\/td>\nvoid<\/td>\nToggle performance\/gaming mode<\/td>\n<\/tr>\n<\/table>\n
Consensus Tasks<\/h3>\n\n\n\n\n\n\n\n
Method<\/th>\nReturns<\/th>\nDescription<\/th>\n<\/tr>\n
addConsensusTask(task, isLocal)<\/code><\/td>\nvoid<\/td>\nAdd a consensus task to the queue<\/td>\n<\/tr>\n
getConsensusTaskByDescription(desc, subDesc)<\/code><\/td>\nCConsensusTask|null<\/td>\nFind task by description<\/td>\n<\/tr>\n
get getConsensusTasks<\/code><\/td>\nArray<\/td>\nAll pending consensus tasks<\/td>\n<\/tr>\n
get getConsensusTasksCount<\/code><\/td>\nnumber<\/td>\nNumber of pending tasks<\/td>\n<\/tr>\n
clearPendngConsensusTasks()<\/code><\/td>\nvoid<\/td>\nClear all pending tasks<\/td>\n<\/tr>\n<\/table>\n
XIII. Putting It All Together \u2014 A Complete dApp Pattern<\/h2>\n
Here is the canonical pattern for a GRIDNET OS UI dApp that uses CVMContext<\/code>:<\/p>\n
\nimport { CWindow } from '\/lib\/window.js';\n\nclass MyDApp extends CWindow {\n    \n    static getPackageID() {\n        return 'org.example.mydapp';\n    }\n    \n    static getIcon() {\n        return '\/images\/mydapp-icon.png';\n    }\n    \n    constructor(x, y, w, h) {\n        super(x, y, w, h, myHTMLBody, 'My dApp', MyDApp.getIcon(), false);\n        \n        const ctx = CVMContext.getInstance();\n        \n        \/\/ 1. Register for events\n        ctx.addVMStateChangedListener(this.onVMStateChanged.bind(this), this.mID);\n        ctx.addNewDFSMsgListener(this.onDFSMessage.bind(this), this.mID);\n        ctx.addNewGridScriptResultListener(this.onGridScriptResult.bind(this), this.mID);\n        ctx.addConnectionStatusChangedListener(this.onConnectionChanged.bind(this), this.mID);\n        ctx.addVMCommitStateChangedListener(this.onCommitStateChanged.bind(this), this.mID);\n    }\n    \n    onVMStateChanged(arg) {\n        if (arg.state === eVMState.ready) {\n            \/\/ VM is ready \u2014 safe to execute commands\n            this.loadInitialData();\n        }\n    }\n    \n    onConnectionChanged(state) {\n        if (state === eConnectionState.disconnected) {\n            this.showDisconnectedUI();\n        }\n    }\n    \n    async loadInitialData() {\n        const ctx = CVMContext.getInstance();\n        \n        if (ctx.getConnectionState !== eConnectionState.connected) {\n            this.showNotConnectedError();\n            return;\n        }\n        \n        \/\/ Navigate to user's home directory\n        const fs = ctx.getFileSystem;\n        fs.doCD('\/' + ctx.getUserID, true, false, false, this.getThreadID);\n        fs.doLS(this.getThreadID);\n    }\n    \n    onDFSMessage(dfsMsg) {\n        \/\/ Handle filesystem responses\n    }\n    \n    onGridScriptResult(result) {\n        \/\/ Handle GridScript execution results\n    }\n    \n    onCommitStateChanged(state) {\n        \/\/ Handle commit lifecycle\n    }\n    \n    \/\/ CRITICAL: Clean up listeners on close\n    closeWindow() {\n        CVMContext.getInstance().unregisterEventListenersByAppID(this.mID);\n        super.closeWindow();\n    }\n}\n<\/pre>\n
XIV. Conclusion \u2014 The Bridge Is Open<\/h2>\n
CVMContext is not just an API \u2014 it is the philosophical bridge<\/strong> between the familiar world of web development and the uncharted territory of decentralized computing. Through it, every HTML form submission can become a blockchain transaction. Every file save can become an immutable state change. Every chat message can traverse a peer-to-peer mesh without touching a central server.<\/p>\n
The design philosophy is clear: meet developers where they are<\/strong>. You don’t need to learn a new language. You don’t need to understand Merkle Patricia Tries. You don’t need to implement cryptographic protocols. CVMContext handles all of that. You write JavaScript. You subscribe to events. You call methods. The decentralized world opens up.<\/p>\n
This is Article 4 in our UI dApp Developer Series. With the foundation laid in previous articles on Shadow DOM architecture and the WebUI framework, and with this deep dive into CVMContext, you now possess the knowledge to build production-grade decentralized applications on GRIDNET OS.<\/p>\n
The bridge is open. Start building.<\/p>\n
\u2014 The Wizards of GRIDNET OS<\/em><\/p>\n","protected":false},"excerpt":{"rendered":"
I. What CVMContext Is \u2014 And Why It Matters Every revolution needs a bridge between worlds. The steam engine needed the drive…<\/p>\n","protected":false},"author":1,"featured_media":835504,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[162,17,163],"tags":[168,139,155,164,197,142,156,215,212,169,165],"class_list":["post-835510","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-development","category-tutorial","category-tutorials","tag-api","tag-blockchain","tag-cvmcontext","tag-dapp","tag-dapps","tag-gridnet-os","tag-javascript","tag-state-management","tag-ui-development","tag-vmcontext","tag-web-development"],"_links":{"self":[{"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/posts\/835510","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/comments?post=835510"}],"version-history":[{"count":6,"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/posts\/835510\/revisions"}],"predecessor-version":[{"id":840112,"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/posts\/835510\/revisions\/840112"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/media\/835504"}],"wp:attachment":[{"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/media?parent=835510"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/categories?post=835510"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mag.gridnet.org\/index.php\/wp-json\/wp\/v2\/tags?post=835510"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}