@varity-labs/sdk 2.0.0-alpha.1

package/dist/cli/commands/generate.js

@@ -0,0 +1,303 @@
+/**
+ * varity generate - Code generation commands
+ *
+ * Generate contracts, types, tests, and deployment scripts
+ */
+import { Command } from 'commander';
+import * as path from 'path';
+import { Logger } from '../utils/logger';
+import { promptGenerateContracts } from '../utils/prompts';
+import { generateContracts } from '../../generators/contracts/generator';
+import { generateTypes } from '../../generators/types/generator';
+import { generateTests } from '../../generators/tests/generator';
+import { generateUIComponents } from '../../generators/ui/component-generator';
+import { generateDashboards } from '../../generators/ui/dashboard-generator';
+/**
+ * varity generate contracts
+ */
+const generateContractsCommand = new Command('contracts')
+    .description('Generate Solidity smart contracts from template configuration')
+    .option('-t, --template <path>', 'Path to template JSON file')
+    .option('-o, --output <path>', 'Output directory for contracts')
+    .option('--no-tests', 'Skip generating test files')
+    .action(async (options) => {
+    try {
+        Logger.header('🔨 Generate Smart Contracts');
+        // Get options from prompts if not provided
+        let templatePath = options.template;
+        let outputPath = options.output;
+        let includeTests = options.tests !== false;
+        if (!templatePath || !outputPath) {
+            const answers = await promptGenerateContracts();
+            templatePath = templatePath || answers.templatePath;
+            outputPath = outputPath || answers.outputPath;
+            if (options.tests === undefined) {
+                includeTests = answers.includeTests;
+            }
+        }
+        // Resolve paths
+        templatePath = path.resolve(templatePath);
+        outputPath = path.resolve(outputPath);
+        Logger.step(1, 3, `Loading template configuration from ${templatePath}...`);
+        // Generate contracts
+        Logger.step(2, 3, 'Generating smart contracts...');
+        const result = await generateContracts({
+            templatePath,
+            outputPath,
+            includeTests
+        });
+        Logger.step(3, 3, 'Finalizing...');
+        // Display results
+        Logger.newline();
+        if (result.success) {
+            Logger.success('Smart contracts generated successfully!');
+            Logger.newline();
+            if (result.contracts.length > 0) {
+                Logger.info('Generated contracts:');
+                result.contracts.forEach(contract => {
+                    Logger.code(`  ✓ ${contract}`);
+                });
+                Logger.newline();
+            }
+            if (result.tests.length > 0) {
+                Logger.info('Generated tests:');
+                result.tests.forEach(test => {
+                    Logger.code(`  ✓ ${test}`);
+                });
+                Logger.newline();
+            }
+            Logger.info('Next steps:');
+            Logger.code('  1. Review generated contracts');
+            Logger.code('  2. Compile with: npx hardhat compile');
+            Logger.code('  3. Run tests with: npx hardhat test');
+            Logger.code('  4. Deploy with: varity generate scripts');
+            Logger.newline();
+        }
+        else {
+            Logger.error('Failed to generate contracts');
+            Logger.newline();
+            result.errors.forEach(error => {
+                Logger.error(error);
+            });
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        Logger.error(`Failed to generate contracts: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+/**
+ * varity generate types
+ */
+const generateTypesCommand = new Command('types')
+    .description('Generate TypeScript types from contract ABIs')
+    .option('-a, --abi-dir <path>', 'Directory containing contract ABIs', './contracts/abis')
+    .option('-o, --output <path>', 'Output directory for TypeScript types', './src/types')
+    .action(async (options) => {
+    try {
+        Logger.header('📝 Generate TypeScript Types');
+        const abiDir = path.resolve(options.abiDir);
+        const outputPath = path.resolve(options.output);
+        Logger.step(1, 2, `Loading ABIs from ${abiDir}...`);
+        // Generate types
+        Logger.step(2, 2, 'Generating TypeScript types...');
+        const result = await generateTypes({
+            abiDir,
+            outputPath
+        });
+        // Display results
+        Logger.newline();
+        if (result.success) {
+            Logger.success('TypeScript types generated successfully!');
+            Logger.newline();
+            if (result.types.length > 0) {
+                Logger.info('Generated type files:');
+                result.types.forEach(typeFile => {
+                    Logger.code(`  ✓ ${typeFile}`);
+                });
+                Logger.newline();
+            }
+            Logger.info('Next steps:');
+            Logger.code('  1. Import types in your TypeScript code');
+            Logger.code('  2. Use with ethers.js: const contract: MyContract = ...');
+            Logger.newline();
+        }
+        else {
+            Logger.error('Failed to generate types');
+            Logger.newline();
+            result.errors.forEach(error => {
+                Logger.error(error);
+            });
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        Logger.error(`Failed to generate types: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+/**
+ * varity generate tests
+ */
+const generateTestsCommand = new Command('tests')
+    .description('Generate comprehensive test suites for contracts')
+    .option('-t, --template <path>', 'Path to template JSON file')
+    .option('-c, --contracts <path>', 'Directory containing contracts', './contracts')
+    .option('-o, --output <path>', 'Output directory for tests', './test')
+    .action(async (options) => {
+    try {
+        Logger.header('🧪 Generate Test Suites');
+        const templatePath = path.resolve(options.template || './templates/template.json');
+        const contractsPath = path.resolve(options.contracts);
+        const outputPath = path.resolve(options.output);
+        Logger.step(1, 3, `Loading template from ${templatePath}...`);
+        // Generate tests
+        Logger.step(2, 3, 'Generating test suites...');
+        const result = await generateTests({
+            templatePath,
+            contractsPath,
+            outputPath
+        });
+        Logger.step(3, 3, 'Finalizing...');
+        // Display results
+        Logger.newline();
+        if (result.success) {
+            Logger.success('Test suites generated successfully!');
+            Logger.newline();
+            if (result.tests.length > 0) {
+                Logger.info('Generated test files:');
+                result.tests.forEach(test => {
+                    Logger.code(`  ✓ ${test}`);
+                });
+                Logger.newline();
+            }
+            Logger.info('Next steps:');
+            Logger.code('  1. Review generated tests');
+            Logger.code('  2. Add custom test cases as needed');
+            Logger.code('  3. Run with: npx hardhat test');
+            Logger.newline();
+        }
+        else {
+            Logger.error('Failed to generate tests');
+            Logger.newline();
+            result.errors.forEach(error => {
+                Logger.error(error);
+            });
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        Logger.error(`Failed to generate tests: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+/**
+ * varity generate ui
+ */
+const generateUICommand = new Command('ui')
+    .description('Generate React UI components from template entities')
+    .option('-t, --template <path>', 'Path to template JSON file', './templates/template.json')
+    .option('-o, --output <path>', 'Output directory for UI components', '.')
+    .action(async (options) => {
+    try {
+        Logger.header('🎨 Generate UI Components');
+        const templatePath = path.resolve(options.template);
+        const outputPath = path.resolve(options.output);
+        Logger.step(1, 2, `Loading template configuration from ${templatePath}...`);
+        // Generate UI components
+        Logger.step(2, 2, 'Generating React components...');
+        const result = await generateUIComponents({
+            templatePath,
+            outputPath
+        });
+        // Display results
+        Logger.newline();
+        if (result.success) {
+            Logger.success('UI components generated successfully!');
+            Logger.newline();
+            if (result.components.length > 0) {
+                Logger.info('Generated components:');
+                result.components.forEach(component => {
+                    Logger.code(`  ✓ ${component}`);
+                });
+                Logger.newline();
+            }
+            Logger.info('Next steps:');
+            Logger.code('  1. Review generated components');
+            Logger.code('  2. Import components in your app');
+            Logger.code('  3. Customize styling as needed');
+            Logger.newline();
+        }
+        else {
+            Logger.error('Failed to generate UI components');
+            Logger.newline();
+            result.errors.forEach(error => {
+                Logger.error(error);
+            });
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        Logger.error(`Failed to generate UI: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+/**
+ * varity generate dashboard
+ */
+const generateDashboardCommand = new Command('dashboard')
+    .description('Generate dashboard layouts from template configuration')
+    .option('-t, --template <path>', 'Path to template JSON file', './templates/template.json')
+    .option('-o, --output <path>', 'Output directory for dashboards', '.')
+    .action(async (options) => {
+    try {
+        Logger.header('📊 Generate Dashboard Layouts');
+        const templatePath = path.resolve(options.template);
+        const outputPath = path.resolve(options.output);
+        Logger.step(1, 2, `Loading template configuration from ${templatePath}...`);
+        // Generate dashboards
+        Logger.step(2, 2, 'Generating dashboard layouts...');
+        const result = await generateDashboards({
+            templatePath,
+            outputPath
+        });
+        // Display results
+        Logger.newline();
+        if (result.success) {
+            Logger.success('Dashboard layouts generated successfully!');
+            Logger.newline();
+            if (result.dashboards.length > 0) {
+                Logger.info('Generated dashboards:');
+                result.dashboards.forEach(dashboard => {
+                    Logger.code(`  ✓ ${dashboard}`);
+                });
+                Logger.newline();
+            }
+            Logger.info('Next steps:');
+            Logger.code('  1. Review generated dashboards');
+            Logger.code('  2. Import dashboards in your app routing');
+            Logger.code('  3. Customize widgets as needed');
+            Logger.newline();
+        }
+        else {
+            Logger.error('Failed to generate dashboards');
+            Logger.newline();
+            result.errors.forEach(error => {
+                Logger.error(error);
+            });
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        Logger.error(`Failed to generate dashboards: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+export const generateCommand = new Command('generate')
+    .description('Generate contracts, types, tests, UI components, dashboards, and deployment scripts')
+    .addCommand(generateContractsCommand)
+    .addCommand(generateTypesCommand)
+    .addCommand(generateTestsCommand)
+    .addCommand(generateUICommand)
+    .addCommand(generateDashboardCommand);

package/dist/cli/commands/init.d.ts

@@ -0,0 +1,8 @@
+/**
+ * varity init - Initialize new template project
+ *
+ * Creates a new template project with all necessary files
+ */
+import { Command } from 'commander';
+export declare const initCommand: Command;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/init.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAOnC,eAAO,MAAM,WAAW,SAwEpB,CAAA"}

package/dist/cli/commands/init.js

@@ -0,0 +1,317 @@
+/**
+ * varity init - Initialize new template project
+ *
+ * Creates a new template project with all necessary files
+ */
+import { Command } from 'commander';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Logger } from '../utils/logger';
+import { promptInit } from '../utils/prompts';
+export const initCommand = new Command('init')
+    .description('Initialize a new template project')
+    .option('-n, --name <name>', 'Template name')
+    .option('-d, --dir <directory>', 'Output directory', '.')
+    .action(async (options) => {
+    try {
+        Logger.header('🚀 Initialize New Varity Template Project');
+        // Get template configuration from prompts
+        const answers = await promptInit();
+        // Parse entities
+        const entities = answers.entities
+            .split(',')
+            .map(e => e.trim())
+            .filter(e => e.length > 0);
+        // Parse contracts (or auto-generate from entities)
+        let contracts;
+        if (answers.contracts && answers.contracts.trim().length > 0) {
+            contracts = answers.contracts
+                .split(',')
+                .map(c => c.trim())
+                .filter(c => c.length > 0);
+        }
+        else {
+            // Auto-generate contract names from entities
+            contracts = entities.map(entity => {
+                const capitalized = entity.charAt(0).toUpperCase() + entity.slice(1);
+                return `${capitalized}Registry`;
+            });
+        }
+        // Create output directory
+        const outputDir = path.join(options.dir, answers.templateName);
+        if (fs.existsSync(outputDir)) {
+            Logger.error(`Directory ${outputDir} already exists`);
+            process.exit(1);
+        }
+        Logger.step(1, 5, 'Creating project structure...');
+        createProjectStructure(outputDir);
+        Logger.step(2, 5, 'Generating template configuration...');
+        const template = generateTemplateConfig(answers, entities, contracts);
+        fs.writeFileSync(path.join(outputDir, 'templates', `${answers.templateName}.template.json`), JSON.stringify(template, null, 2));
+        Logger.step(3, 5, 'Creating environment configuration...');
+        generateEnvFile(outputDir, answers);
+        Logger.step(4, 5, 'Generating package.json...');
+        generatePackageJson(outputDir, answers);
+        Logger.step(5, 5, 'Creating README.md...');
+        generateReadme(outputDir, answers, entities);
+        Logger.newline();
+        Logger.success('Template project initialized successfully!');
+        Logger.newline();
+        Logger.info('Next steps:');
+        Logger.code(`  cd ${answers.templateName}`);
+        Logger.code(`  npm install`);
+        Logger.code(`  npx varity generate contracts`);
+        Logger.code(`  npx varity dev --watch`);
+        Logger.newline();
+    }
+    catch (error) {
+        Logger.error(`Failed to initialize project: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        process.exit(1);
+    }
+});
+function createProjectStructure(baseDir) {
+    const dirs = [
+        baseDir,
+        path.join(baseDir, 'contracts'),
+        path.join(baseDir, 'contracts', 'abis'),
+        path.join(baseDir, 'templates'),
+        path.join(baseDir, 'scripts'),
+        path.join(baseDir, 'test'),
+        path.join(baseDir, 'frontend'),
+        path.join(baseDir, 'frontend', 'src')
+    ];
+    dirs.forEach(dir => {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    });
+    // Create .gitignore
+    const gitignore = `
+node_modules
+.env
+.env.local
+dist
+build
+*.log
+.DS_Store
+deployments
+`.trim();
+    fs.writeFileSync(path.join(baseDir, '.gitignore'), gitignore);
+}
+function generateTemplateConfig(answers, entities, contracts) {
+    return {
+        type: answers.templateName,
+        name: `${answers.templateName.charAt(0).toUpperCase() + answers.templateName.slice(1)} Business Template`,
+        version: '1.0.0',
+        description: answers.description,
+        contracts: contracts.map((contractName, idx) => ({
+            name: contractName,
+            description: `${entities[idx]} management contract`,
+            abi: `../../contracts/abis/${answers.templateName}/${contractName}.json`,
+            addresses: {
+                'arbitrum-sepolia': '',
+                'arbitrum-l3-testnet': '',
+                'arbitrum-l3-mainnet': ''
+            },
+            required: true
+        })),
+        entities: entities.map(entity => ({
+            name: entity,
+            displayName: entity.charAt(0).toUpperCase() + entity.slice(1),
+            description: `${entity.charAt(0).toUpperCase() + entity.slice(1)} entity`,
+            idField: `${entity}Id`,
+            displayField: `${entity}Name`,
+            fields: [
+                {
+                    name: `${entity}Id`,
+                    label: `${entity.charAt(0).toUpperCase() + entity.slice(1)} ID`,
+                    type: 'string',
+                    description: `Unique ${entity} identifier`,
+                    required: true
+                },
+                {
+                    name: `${entity}Name`,
+                    label: `${entity.charAt(0).toUpperCase() + entity.slice(1)} Name`,
+                    type: 'string',
+                    description: `${entity.charAt(0).toUpperCase() + entity.slice(1)} name`,
+                    required: true
+                },
+                {
+                    name: 'createdAt',
+                    label: 'Created At',
+                    type: 'number',
+                    description: 'Creation timestamp',
+                    required: true
+                },
+                {
+                    name: 'isActive',
+                    label: 'Is Active',
+                    type: 'boolean',
+                    description: 'Active status',
+                    required: true
+                }
+            ]
+        })),
+        events: [
+            {
+                name: `${entities[0]}_created`,
+                displayName: `${entities[0].charAt(0).toUpperCase() + entities[0].slice(1)} Created`,
+                description: `New ${entities[0]} created`,
+                category: 'entity'
+            }
+        ],
+        metrics: [
+            {
+                name: `total_${entities[0]}s`,
+                displayName: `Total ${entities[0].charAt(0).toUpperCase() + entities[0].slice(1)}s`,
+                description: `Total number of ${entities[0]}s`,
+                type: 'count',
+                source: 'contract'
+            }
+        ],
+        storage: {
+            varityNamespace: `varity-internal-${answers.templateName}`,
+            industryNamespace: `industry-${answers.templateName}-rag`,
+            customerNamespacePattern: `customer-${answers.templateName}-{company-id}-{data-type}`,
+            encryptionEnabled: true,
+            litProtocolEnabled: true,
+            celestiaDAEnabled: true,
+            zkProofsEnabled: true
+        },
+        api: {
+            basePath: `/api/v1/${answers.templateName}`
+        },
+        features: {
+            analytics: true,
+            forecasting: true,
+            notifications: true,
+            export: true,
+            cache: true,
+            monitoring: true,
+            webhooks: true
+        }
+    };
+}
+function generateEnvFile(baseDir, answers) {
+    const envContent = `# Varity SDK Configuration
+
+# Network
+VARITY_NETWORK=${answers.network}
+
+# API Configuration
+VARITY_API_KEY=
+VARITY_API_ENDPOINT=https://api.varity.io
+
+# RPC URLs
+ARBITRUM_SEPOLIA_RPC=https://sepolia-rollup.arbitrum.io/rpc
+ARBITRUM_L3_TESTNET_RPC=
+ARBITRUM_L3_MAINNET_RPC=
+
+# Contract Addresses (populated after deployment)
+# ${answers.network.toUpperCase().replace(/-/g, '_')} contracts
+# Add your contract addresses here after deployment
+
+# Storage Configuration
+PINATA_API_KEY=
+CELESTIA_TESTNET_RPC=https://rpc-mocha.pops.one
+
+# Private Key (NEVER commit this!)
+PRIVATE_KEY=
+`;
+    fs.writeFileSync(path.join(baseDir, '.env.example'), envContent);
+}
+function generatePackageJson(baseDir, answers) {
+    const packageJson = {
+        name: `varity-${answers.templateName}-template`,
+        version: '1.0.0',
+        description: answers.description,
+        scripts: {
+            'generate:contracts': 'varity generate contracts',
+            'generate:types': 'varity generate types',
+            'generate:tests': 'varity generate tests',
+            'dev': 'varity dev --watch',
+            'validate': 'varity validate',
+            'test': 'hardhat test',
+            'deploy:sepolia': 'hardhat run scripts/deploy.ts --network arbitrum-sepolia',
+            'deploy:testnet': 'hardhat run scripts/deploy.ts --network arbitrum-l3-testnet',
+            'deploy:mainnet': 'hardhat run scripts/deploy.ts --network arbitrum-l3-mainnet'
+        },
+        dependencies: {
+            '@varity-labs/sdk': '^2.0.0-beta.1',
+            'ethers': '^6.9.0'
+        },
+        devDependencies: {
+            '@nomicfoundation/hardhat-toolbox': '^4.0.0',
+            'hardhat': '^2.19.0',
+            'typescript': '^5.0.0'
+        }
+    };
+    fs.writeFileSync(path.join(baseDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+}
+function generateReadme(baseDir, answers, entities) {
+    const readme = `# ${answers.templateName.charAt(0).toUpperCase() + answers.templateName.slice(1)} Template
+
+${answers.description}
+
+## Quick Start
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Generate smart contracts
+npm run generate:contracts
+
+# Start development mode (hot-reload)
+npm run dev
+
+# Validate template configuration
+npm run validate
+\`\`\`
+
+## Business Entities
+
+${entities.map(e => `- **${e.charAt(0).toUpperCase() + e.slice(1)}**: ${e} management`).join('\n')}
+
+## Smart Contracts
+
+Contracts will be generated in \`contracts/\` directory when you run:
+
+\`\`\`bash
+npm run generate:contracts
+\`\`\`
+
+## Testing
+
+Deploy and test on Arbitrum Sepolia before production:
+
+\`\`\`bash
+# Deploy to testnet
+npm run deploy:sepolia
+
+# Run tests
+npm test
+\`\`\`
+
+## Production Deployment
+
+When ready for production:
+
+\`\`\`bash
+# Deploy to mainnet
+npm run deploy:mainnet
+\`\`\`
+
+## Documentation
+
+- [Varity SDK Documentation](https://docs.varity.com)
+- [Template Guide](https://docs.varity.com/templates)
+- [Quick Start Guide](../../docs/QUICK_START_TEMPLATE.md)
+
+## Support
+
+- Discord: https://discord.gg/varity
+- Email: support@varity.com
+`;
+    fs.writeFileSync(path.join(baseDir, 'README.md'), readme);
+}

package/dist/cli/commands/validate.d.ts

@@ -0,0 +1,8 @@
+/**
+ * varity validate - Template validation
+ *
+ * Validates template configuration and structure
+ */
+import { Command } from 'commander';
+export declare const validateCommand: Command;
+//# sourceMappingURL=validate.d.ts.map

package/dist/cli/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/validate.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAKnC,eAAO,MAAM,eAAe,SAoExB,CAAA"}