Zetrix MCP Server

# ✅ Zetrix Smart Contract Development Integration Complete! The Zetrix MCP server now includes comprehensive smart contract development support! ## 🎯 What Was Added ### 5 New Smart Contract Development Tools 1. **zetrix_contract_get_chain_functions** - Complete documentation for all Chain object methods - Metadata management (store, load, del) - Account queries (getBalance, getAccountMetadata, etc.) - Transaction functions (payCoin, payAsset, issueAsset) - Contract operations (contractCall, contractQuery, delegateCall) - Logging and events (tlog) - Built-in objects (Chain.block, Chain.tx, Chain.msg, Chain.thisAddress) 2. **zetrix_contract_get_utils_functions** - Complete documentation for all Utils object methods - 256-bit and 64-bit integer operations (add, sub, mul, div, mod, compare) - Cryptographic functions (sha256, ecVerify, toAddress) - Validation functions (addressCheck, stoI64Check, stoI256Check) - Utility functions (log, assert, toBaseUnit, hexToDec) - Zero-knowledge proof functions (bpRangeProofVerify, pedersenTallyVerify) 3. **zetrix_contract_get_structure_guide** - ES5 JavaScript class patterns for contracts - Public/private/protected method simulation - Inheritance patterns with constructor calls - Storage patterns for efficient data management - Entry point functions (init, main, query) 4. **zetrix_contract_get_token_standard** - ZTP20 (Fungible Tokens) - ERC20-like standard - ZTP721 (NFTs) - ERC721-like standard - ZTP1155 (Multi-Token) - ERC1155-like standard - Standard methods, events, and variants - Implementation examples 5. **zetrix_contract_get_testing_guide** - TEST_INVOKE for transaction testing - TEST_QUERY for state validation - Test conditions (EQUALS, GREATER_THAN, LESSER_THAN, CONTAINS) - Integration and unit test organization ## 📦 Files Created/Modified **New Files:** - `SMART_CONTRACT_DEVELOPMENT.md` - Comprehensive development guide (150+ lines) - `src/zetrix-contract-docs.ts` - Documentation helper module - `CONTRACT_DEVELOPMENT_INTEGRATION.md` - This integration summary **Modified Files:** - `src/index.ts` - Added 5 contract development tool definitions and handlers - `README.md` - Added "Smart Contract Development" section ## 🏗️ Contract Development Features ### Built-in Functions Reference **Chain Object (30+ functions):** ```javascript // Storage Chain.store(key, value); Chain.load(key); Chain.del(key); // Transactions Chain.payCoin(address, amount); Chain.payAsset(address, issuer, code, amount); // Contract Operations Chain.contractCall(address, asset, amount, input); Chain.contractQuery(address, input); // Logging Chain.tlog(topic, arg1, arg2, arg3, arg4, arg5); // Built-in Objects Chain.block.number Chain.tx.initiator Chain.msg.sender Chain.thisAddress ``` **Utils Object (25+ functions):** ```javascript // Math Operations Utils.int256Add(x, y); Utils.int256Sub(x, y); Utils.int256Compare(x, y); // Cryptography Utils.sha256(data, dataType); Utils.ecVerify(signature, publicKey, data); Utils.toAddress(publicKey); // Validation Utils.addressCheck(address); Utils.assert(condition, message); ``` ### Contract Structure Patterns **ES5 Class Pattern:** ```javascript const MyContract = function() { const self = this; self.p = {}; // Protected namespace // Private method const _privateMethod = function() {}; // Public method self.publicMethod = function() {}; // Protected method self.p.protectedMethod = function() {}; }; ``` **Inheritance Pattern:** ```javascript const ChildContract = function() { const self = this; ParentContract.call(self); // Call parent // Override parent method const _parentMethod = self.p.parentMethod; self.p.parentMethod = function() { // Extended logic _parentMethod.call(self); }; }; ``` ### Token Standards **ZTP20 Variants:** - Core - Basic fungible token - Burnable - Can destroy tokens - Permit - Gasless approvals - Pausable - Emergency stop - Capped - Maximum supply limit **ZTP721 Variants:** - Core - Basic NFT - Burnable - Destroyable NFTs - Pausable - Emergency stop - Enumerable - Token enumeration **ZTP1155 Variants:** - Core - Basic multi-token - Burnable - Destroyable tokens - Pausable - Emergency stop - Supply - Track total supply - URI Storage - Token metadata ### Testing Framework **TEST_INVOKE Example:** ```javascript TEST_INVOKE( "Transfer tokens", contractAddress, senderAddress, { method: "transfer", params: { to: recipientAddress, amount: "1000" } }, TEST_RESULT.SUCCESS ); ``` **TEST_QUERY Example:** ```javascript TEST_QUERY( "Check balance", contractAddress, { method: "balanceOf", params: { address: userAddress } }, TEST_CONDITION.EQUALS, "1000", ["result", "balance"] ); ``` ## 📊 Total Tool Count The Zetrix MCP server now provides **42 tools**: - **6** Account operations (HTTP) - **3** Block & Ledger operations (HTTP) - **6** Transaction operations (HTTP) - **1** Contract operations (HTTP) - **2** Utility operations (HTTP) - **5** WebSocket operations (Real-time) - **6** Official SDK operations - **8** Cryptography operations - **5** Smart Contract Development (NEW!) ## 🚀 Usage Examples ### Get Chain Functions Documentation **Ask Claude:** ``` Show me all the Chain object functions available in Zetrix smart contracts ``` **Claude uses:** `zetrix_contract_get_chain_functions` ### Get Token Standard **Ask Claude:** ``` What is the ZTP20 token standard? Show me the methods and how to implement it ``` **Claude uses:** `zetrix_contract_get_token_standard` with `standard: "ZTP20"` ### Get Contract Structure Guide **Ask Claude:** ``` How do I structure a Zetrix smart contract with multiple classes? ``` **Claude uses:** `zetrix_contract_get_structure_guide` ### Get Testing Guide **Ask Claude:** ``` How do I test my Zetrix smart contract? Show me the testing framework ``` **Claude uses:** `zetrix_contract_get_testing_guide` ## 📚 Reference Documentation ### SMART_CONTRACT_DEVELOPMENT.md Complete development guide covering: - All 30+ Chain object functions with examples - All 25+ Utils object functions with examples - ES5 class patterns and inheritance - Storage patterns and best practices - ZTP20, ZTP721, ZTP1155 token standards - Testing framework (TEST_INVOKE, TEST_QUERY) - Security best practices - Gas optimization techniques - Code organization patterns **Sections:** 1. Built-in Functions Reference 2. Contract Structure and Patterns 3. Testing Framework 4. Token Standards 5. Best Practices ## ✅ What's Working - [x] Chain object documentation (30+ functions) - [x] Utils object documentation (25+ functions) - [x] Contract structure guide (ES5 patterns) - [x] Token standard documentation (3 standards) - [x] Testing framework guide - [x] MCP tool integration - [x] README updated - [x] Project builds successfully ## 🎨 Key Features ### Comprehensive Documentation Every built-in function is documented with: - Function signature - Parameter descriptions - Return value documentation - Code examples - Use cases ### Pattern Libraries Standard patterns for: - Class creation (ES5 function constructors) - Inheritance (call-based) - Access modifiers (public/protected/private simulation) - Storage management - Error handling - Event logging ### Token Standards Full specifications for: - Fungible tokens (ZTP20) - Non-fungible tokens (ZTP721) - Multi-token standards (ZTP1155) - All standard methods and events - Multiple implementation variants ### Testing Support Complete testing documentation: - Transaction testing (TEST_INVOKE) - State validation (TEST_QUERY) - Test conditions and assertions - Integration vs unit testing - Test organization ## 🔧 Developer Workflow 1. **Learn Built-in Functions** ``` Ask: "Show me all Chain object functions" Ask: "Show me all Utils functions" ``` 2. **Understand Contract Structure** ``` Ask: "How do I structure a contract with multiple classes?" Ask: "Show me inheritance patterns for Zetrix contracts" ``` 3. **Choose Token Standard** ``` Ask: "What is ZTP20? Show me the standard" Ask: "How do I implement a ZTP721 NFT?" ``` 4. **Learn Testing** ``` Ask: "How do I test my smart contract?" Ask: "Show me TEST_INVOKE and TEST_QUERY examples" ``` 5. **Reference Full Guide** ``` See: SMART_CONTRACT_DEVELOPMENT.md ``` ## 🎉 Summary The Zetrix MCP server now provides **complete smart contract development support** through: 1. **Built-in Functions** - All Chain and Utils methods documented 2. **Contract Patterns** - ES5 class structures and inheritance 3. **Token Standards** - ZTP20, ZTP721, ZTP1155 specifications 4. **Testing Framework** - TEST_INVOKE and TEST_QUERY guides 5. **Best Practices** - Security, gas optimization, code organization You can now: - Query all built-in functions and their usage - Learn contract structure patterns - Understand token standards - Master the testing framework - Build production-ready smart contracts - All through natural language with Claude! ## 🆘 Support For contract development: - Check [SMART_CONTRACT_DEVELOPMENT.md](SMART_CONTRACT_DEVELOPMENT.md:1) for complete guide - Review [README.md](README.md) for all available tools - Visit [Zetrix Contract Development Tool](https://github.com/armmarov/zetrix-contract-development-tool) - See [Zetrix Documentation](https://docs.zetrix.com/) --- **Happy building on Zetrix!** 🏗️🚀