@varity-labs/sdk 2.0.0-alpha.1

package/dist/dev/dev-server.js

@@ -0,0 +1,119 @@
+/**
+ * Development Server
+ *
+ * Hot-reload development mode with file watching
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import chokidar from 'chokidar';
+import { Logger } from '../cli/utils/logger';
+import { generateContracts } from '../generators/contracts/generator';
+import { generateTypes } from '../generators/types/generator';
+/**
+ * Start development server with hot-reload
+ */
+export async function startDevServer(options) {
+    Logger.success('Development server started!');
+    Logger.newline();
+    // Initial generation
+    await regenerateAll(options);
+    if (options.watch) {
+        Logger.info('👀 Watching for changes...');
+        Logger.code('  Press Ctrl+C to stop');
+        Logger.newline();
+        // Watch template file
+        const watcher = chokidar.watch(options.templatePath, {
+            persistent: true,
+            ignoreInitial: true
+        });
+        watcher.on('change', async (filePath) => {
+            Logger.newline();
+            Logger.warn(`Template changed: ${filePath}`);
+            await regenerateAll(options);
+            Logger.success('✓ Regeneration complete');
+            Logger.newline();
+            Logger.info('👀 Watching for changes...');
+        });
+        watcher.on('error', (error) => {
+            Logger.error(`Watcher error: ${error.message}`);
+        });
+        // Keep process alive
+        process.on('SIGINT', () => {
+            Logger.newline();
+            Logger.info('Stopping development server...');
+            watcher.close();
+            process.exit(0);
+        });
+    }
+    else {
+        Logger.info('Watch mode disabled. Run with --watch to enable.');
+    }
+}
+/**
+ * Regenerate all generated files
+ */
+async function regenerateAll(options) {
+    const startTime = Date.now();
+    try {
+        // Generate contracts
+        Logger.step(1, 3, 'Generating contracts...');
+        const contractResult = await generateContracts({
+            templatePath: options.templatePath,
+            outputPath: options.contractsPath,
+            includeTests: true
+        });
+        if (!contractResult.success) {
+            Logger.error('Contract generation failed:');
+            contractResult.errors.forEach(error => Logger.error(`  ${error}`));
+            return;
+        }
+        Logger.success(`  Generated ${contractResult.contracts.length} contracts`);
+        // Generate types
+        Logger.step(2, 3, 'Generating types...');
+        const abiDir = path.join(path.dirname(options.contractsPath), 'abis');
+        if (fs.existsSync(abiDir)) {
+            const typeResult = await generateTypes({
+                abiDir,
+                outputPath: path.join(path.dirname(options.contractsPath), 'types')
+            });
+            if (typeResult.success) {
+                Logger.success(`  Generated ${typeResult.types.length} type files`);
+            }
+        }
+        else {
+            Logger.warn('  No ABIs found, skipping type generation');
+        }
+        // Validation
+        Logger.step(3, 3, 'Validating output...');
+        const validation = validateGeneration(contractResult);
+        if (validation.valid) {
+            Logger.success('  Validation passed');
+        }
+        else {
+            Logger.warn('  Validation warnings:');
+            validation.warnings.forEach(warning => Logger.warn(`    ${warning}`));
+        }
+        const duration = Date.now() - startTime;
+        Logger.newline();
+        Logger.success(`✨ All done in ${duration}ms`);
+    }
+    catch (error) {
+        Logger.error(`Regeneration failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+/**
+ * Validate generated files
+ */
+function validateGeneration(contractResult) {
+    const warnings = [];
+    if (contractResult.contracts.length === 0) {
+        warnings.push('No contracts were generated');
+    }
+    if (contractResult.tests.length === 0) {
+        warnings.push('No test files were generated');
+    }
+    return {
+        valid: warnings.length === 0,
+        warnings
+    };
+}

package/dist/generators/contracts/generator.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Contract Generator
+ *
+ * Generates Solidity smart contracts from template configuration
+ */
+export interface GenerateContractsOptions {
+    templatePath: string;
+    outputPath: string;
+    includeTests?: boolean;
+}
+export interface GenerateContractsResult {
+    contracts: string[];
+    tests: string[];
+    success: boolean;
+    errors: string[];
+}
+/**
+ * Generate smart contracts from template configuration
+ */
+export declare function generateContracts(options: GenerateContractsOptions): Promise<GenerateContractsResult>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generators/contracts/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/contracts/generator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,uBAAuB,CAAC,CA8ElC"}

package/dist/generators/contracts/generator.js

@@ -0,0 +1,252 @@
+/**
+ * Contract Generator
+ *
+ * Generates Solidity smart contracts from template configuration
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import Handlebars from 'handlebars';
+/**
+ * Generate smart contracts from template configuration
+ */
+export async function generateContracts(options) {
+    const result = {
+        contracts: [],
+        tests: [],
+        success: false,
+        errors: []
+    };
+    try {
+        // Load template configuration
+        const templatePath = path.resolve(options.templatePath);
+        if (!fs.existsSync(templatePath)) {
+            throw new Error(`Template file not found: ${templatePath}`);
+        }
+        const templateContent = fs.readFileSync(templatePath, 'utf-8');
+        const template = JSON.parse(templateContent);
+        // Create output directory
+        const outputPath = path.resolve(options.outputPath);
+        if (!fs.existsSync(outputPath)) {
+            fs.mkdirSync(outputPath, { recursive: true });
+        }
+        // Load Handlebars template
+        const templatesDir = path.join(__dirname, 'templates');
+        const registryTemplate = fs.readFileSync(path.join(templatesDir, 'registry.sol.hbs'), 'utf-8');
+        const compiledTemplate = Handlebars.compile(registryTemplate);
+        // Generate contracts for each entity
+        for (const entity of template.entities) {
+            try {
+                const contractCode = generateContractForEntity(entity, template, compiledTemplate);
+                const contractName = getContractNameForEntity(entity);
+                const contractFile = path.join(outputPath, `${contractName}.sol`);
+                fs.writeFileSync(contractFile, contractCode);
+                result.contracts.push(contractFile);
+                // Generate test file if requested
+                if (options.includeTests) {
+                    const testCode = generateTestForEntity(entity, template, contractName);
+                    const testFile = path.join(path.dirname(outputPath), 'test', `${contractName}.test.ts`);
+                    // Create test directory if needed
+                    const testDir = path.dirname(testFile);
+                    if (!fs.existsSync(testDir)) {
+                        fs.mkdirSync(testDir, { recursive: true });
+                    }
+                    fs.writeFileSync(testFile, testCode);
+                    result.tests.push(testFile);
+                }
+            }
+            catch (error) {
+                result.errors.push(`Failed to generate contract for entity ${entity.name}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        }
+        result.success = result.errors.length === 0;
+    }
+    catch (error) {
+        result.errors.push(`Failed to generate contracts: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+    return result;
+}
+/**
+ * Generate contract code for a single entity
+ */
+function generateContractForEntity(entity, template, compiledTemplate) {
+    const contractName = getContractNameForEntity(entity);
+    const entityStructName = capitalize(entity.name);
+    const entityDisplayName = entity.displayName || capitalize(entity.name);
+    const entityNameLower = entity.name.toLowerCase();
+    // Find ID field
+    const idField = entity.fields.find(f => f.name === entity.idField) || entity.fields[0];
+    const idFieldType = mapTypeToSolidity(idField.type);
+    // Prepare template data
+    const templateData = {
+        contractName,
+        entityName: entity.name,
+        entityStructName,
+        entityDisplayName,
+        entityNameLower,
+        description: entity.description || `${entityDisplayName} registry contract`,
+        templateName: template.name,
+        timestamp: new Date().toISOString(),
+        idField: entity.idField,
+        idFieldType,
+        fields: entity.fields.map(field => ({
+            name: field.name,
+            type: mapTypeToSolidity(field.type),
+            description: field.description || field.name
+        })),
+        createParams: entity.fields
+            .filter(f => f.required && !['createdAt', 'isActive'].includes(f.name))
+            .map(field => ({
+            name: field.name,
+            type: mapTypeToSolidity(field.type),
+            description: field.description || field.name,
+            isMemory: needsMemoryKeyword(field.type)
+        })),
+        fieldAssignments: entity.fields.map(field => ({
+            name: field.name,
+            value: getFieldAssignmentValue(field)
+        })),
+        updateParams: [
+            {
+                name: entity.idField,
+                type: idFieldType,
+                description: `The ${entity.name} ID`,
+                isMemory: false
+            },
+            ...entity.fields
+                .filter(f => !['createdAt', 'isActive', entity.idField].includes(f.name))
+                .map(field => ({
+                name: field.name,
+                type: mapTypeToSolidity(field.type),
+                description: field.description || field.name,
+                isMemory: needsMemoryKeyword(field.type)
+            }))
+        ],
+        updateAssignments: entity.fields
+            .filter(f => !['createdAt', 'isActive', entity.idField].includes(f.name))
+            .map(field => ({
+            name: field.name,
+            value: field.name
+        })),
+        generateId: idFieldType === 'bytes32'
+            ? `keccak256(abi.encodePacked(${entity.fields.filter(f => f.name !== entity.idField && f.required).map(f => f.name).join(', ')}, block.timestamp))`
+            : '_${entityNameLower}Counter.current()'
+    };
+    return compiledTemplate(templateData);
+}
+/**
+ * Generate test file for entity contract
+ */
+function generateTestForEntity(entity, template, contractName) {
+    const entityDisplayName = entity.displayName || capitalize(entity.name);
+    return `import { expect } from "chai"
+import { ethers } from "hardhat"
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers"
+
+describe("${contractName}", function () {
+  async function deploy${contractName}Fixture() {
+    const [owner, manager, user] = await ethers.getSigners()
+
+    const Contract = await ethers.getContractFactory("${contractName}")
+    const contract = await Contract.deploy()
+
+    // Grant manager role
+    const MANAGER_ROLE = await contract.MANAGER_ROLE()
+    await contract.grantRole(MANAGER_ROLE, manager.address)
+
+    return { contract, owner, manager, user }
+  }
+
+  describe("Deployment", function () {
+    it("Should deploy successfully", async function () {
+      const { contract, owner } = await loadFixture(deploy${contractName}Fixture)
+      expect(await contract.hasRole(await contract.DEFAULT_ADMIN_ROLE(), owner.address)).to.be.true
+    })
+  })
+
+  describe("Create ${entityDisplayName}", function () {
+    it("Should create new ${entity.name}", async function () {
+      const { contract, manager } = await loadFixture(deploy${contractName}Fixture)
+
+      // TODO: Add test parameters based on entity fields
+      // const tx = await contract.connect(manager).create${entityDisplayName}(...)
+      // expect(tx).to.emit(contract, "${entityDisplayName}Created")
+    })
+
+    it("Should fail if not manager", async function () {
+      const { contract, user } = await loadFixture(deploy${contractName}Fixture)
+
+      // TODO: Add test logic
+    })
+  })
+
+  describe("Read ${entityDisplayName}", function () {
+    it("Should read ${entity.name} data", async function () {
+      const { contract } = await loadFixture(deploy${contractName}Fixture)
+
+      // TODO: Add test logic
+    })
+  })
+
+  describe("Update ${entityDisplayName}", function () {
+    it("Should update ${entity.name}", async function () {
+      const { contract, manager } = await loadFixture(deploy${contractName}Fixture)
+
+      // TODO: Add test logic
+    })
+  })
+
+  describe("Deactivate ${entityDisplayName}", function () {
+    it("Should deactivate ${entity.name}", async function () {
+      const { contract, owner } = await loadFixture(deploy${contractName}Fixture)
+
+      // TODO: Add test logic
+    })
+  })
+})
+`;
+}
+/**
+ * Get contract name for entity
+ */
+function getContractNameForEntity(entity) {
+    const baseName = capitalize(entity.name);
+    return `${baseName}Registry`;
+}
+/**
+ * Map template field types to Solidity types
+ */
+function mapTypeToSolidity(type) {
+    const typeMap = {
+        'string': 'string',
+        'number': 'uint256',
+        'boolean': 'bool',
+        'address': 'address',
+        'bytes': 'bytes',
+        'bytes32': 'bytes32'
+    };
+    return typeMap[type] || 'string';
+}
+/**
+ * Check if type needs memory keyword
+ */
+function needsMemoryKeyword(type) {
+    return ['string', 'bytes'].includes(type);
+}
+/**
+ * Get field assignment value
+ */
+function getFieldAssignmentValue(field) {
+    if (field.name === 'createdAt') {
+        return 'block.timestamp';
+    }
+    if (field.name === 'isActive') {
+        return 'true';
+    }
+    return field.name;
+}
+/**
+ * Capitalize first letter
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/generators/tests/generator.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Test Generator
+ *
+ * Generates comprehensive test suites for smart contracts
+ */
+export interface GenerateTestsOptions {
+    templatePath: string;
+    contractsPath: string;
+    outputPath: string;
+}
+export interface GenerateTestsResult {
+    tests: string[];
+    success: boolean;
+    errors: string[];
+}
+/**
+ * Generate test suites for contracts
+ */
+export declare function generateTests(options: GenerateTestsOptions): Promise<GenerateTestsResult>;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generators/tests/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/tests/generator.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,MAAM,EAAE,CAAA;CACjB;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAyD9B"}