scrypt-testgen 1.0.0 → 1.0.1

package/README.md

@@ -1,17 +1,21 @@
 # scrypt-testgen
 
-Automatic test generator for sCrypt-ts smart contracts. Generates comprehensive Mocha test files by analyzing contract structure using TypeScript Compiler API.
+Automatic test generator for sCrypt-ts smart contracts. Generates comprehensive Mocha test files by analyzing contract structure.
 
 ## Features
 
-- 📝 Parses sCrypt-ts contracts using TypeScript AST
-- 🧪 Generates ready-to-run Mocha test files
-- ✅ Includes happy-path tests for all public methods
-- 🚫 Generates revert tests for assertion failures
-- 🎯 Creates edge-case tests for comprehensive coverage
-- 🎨 Produces clean, readable, and idiomatic test code
+-  Parses sCrypt-ts contracts
+-  Generates ready-to-run Mocha test files
+-  Includes happy-path tests for all public methods
+-  Creates edge-case tests for comprehensive coverage
+-  Produces clean and readable test code
 
 ## Installation
 
 ```bash
-npm install -g scrypt-testgen
+npm install -g scrypt-testgen
+
+
+## Usage
+```bash
+scrypt-testgen path/to/contract.ts --minimal or -- coverage

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "scrypt-testgen",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Automatic test generator for sCrypt-ts smart contracts",
   "main": "dist/cli.js",
   "bin": {
-    "scrypt-testgen": "./bin/scrypt-testgen.js"
+    "scrypt-testgen": "bin/scrypt-testgen.js"
   },
   "scripts": {
     "build": "tsc",
@@ -12,8 +12,14 @@
     "dev": "ts-node src/cli.ts",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["scrypt", "bitcoin", "smart-contract", "test", "mocha"],
-  "author": "",
+  "keywords": [
+    "scrypt",
+    "bitcoin",
+    "smart-contract",
+    "test",
+    "mocha"
+  ],
+  "author": "Yusuf Idi Maina",
   "license": "MIT",
   "dependencies": {
     "@types/node": "^20.0.0",
@@ -26,5 +32,10 @@
     "@types/mocha": "^10.0.0",
     "ts-node": "^10.9.0",
     "prettier": "^3.0.0"
-  }
-}
+  },
+  "files": [
+    "dist",
+    "bin",
+    "README.md"
+  ]
+}

package/.prettierrc

@@ -1,7 +0,0 @@
-{
-  "semi": true,
-  "trailingComma": "es5",
-  "singleQuote": true,
-  "printWidth": 100,
-  "tabWidth": 2
-}

package/src/cli.ts

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { generateTests } from './generator';
-import { resolve, dirname, basename, join } from 'path';
-import { mkdirSync, existsSync } from 'fs';
-import chalk from 'chalk';
-
-const program = new Command();
-
-program
-  .name('scrypt-testgen')
-  .description('Generate Mocha tests for sCrypt-ts smart contracts')
-  .version('1.0.0');
-
-program
-  .argument('<contract-path>', 'Path to the sCrypt contract TypeScript file')
-  .option('-m, --minimal', 'Generate only happy-path tests', false)
-  .option('-c, --coverage', 'Include revert and edge-case tests', false)
-  .option('-o, --overwrite', 'Replace existing test file', false)
-  .option('-o, --output <path>', 'Custom output path for test file')
-  .action(async (contractPath, options) => {
-    try {
-      const resolvedPath = resolve(process.cwd(), contractPath);
-      
-      if (!existsSync(resolvedPath)) {
-        console.error(chalk.red(`Error: Contract file not found: ${resolvedPath}`));
-        process.exit(1);
-      }
-
-      const outputPath = options.output 
-        ? resolve(process.cwd(), options.output)
-        : join(dirname(resolvedPath), '..', 'test', basename(resolvedPath).replace('.ts', '.test.ts'));
-
-      // Ensure test directory exists
-      mkdirSync(dirname(outputPath), { recursive: true });
-
-      await generateTests(resolvedPath, outputPath, {
-        minimal: options.minimal,
-        coverage: options.coverage,
-        overwrite: options.overwrite
-      });
-
-      console.log(chalk.green(`✓ Tests generated: ${outputPath}`));
-    } catch (error) {
-      console.error(chalk.red(`Error: ${error}`));
-      process.exit(1);
-    }
-  });
-
-program.parse();

package/src/generator/index.ts

@@ -1,45 +0,0 @@
-import { ContractParser } from '../parser';
-import { TestGenerator } from './test-generator';
-import { existsSync, writeFileSync, readFileSync } from 'fs';
-import * as path from 'path';
-
-export async function generateTests(
-  contractPath: string,
-  outputPath: string,
-  options: {
-    minimal: boolean;
-    coverage: boolean;
-    overwrite: boolean;
-  }
-): Promise<void> {
-  
-  // Check if output file exists
-  if (existsSync(outputPath) && !options.overwrite) {
-    throw new Error(`Test file already exists: ${outputPath}. Use --overwrite to replace.`);
-  }
-
-  // Parse the contract
-  const parser = new ContractParser(contractPath);
-  const model = parser.parse();
-
-  // Generate tests
-  const generator = new TestGenerator();
-  const testCode = generator.generateTestFile(model, {
-    minimal: options.minimal,
-    coverage: options.coverage
-  });
-
-  // Format the output (simplified - in production, use prettier API)
-const formattedCode = formatCode(testCode);
-
-  // Write to file
-  writeFileSync(outputPath, formattedCode, 'utf-8');
-}
-
-function formatCode(code: string): string {
-  // Simple formatting - in production, integrate with Prettier
-  return code
-    .replace(/\n\s*\n\s*\n/g, '\n\n')
-    .replace(/\s+$/gm, '')
-    .trim() + '\n';
-}

package/src/generator/test-generator.ts

@@ -1,216 +0,0 @@
-import { ContractModel, MethodCategory } from '../model/contract-model';
-import { ValueGenerator } from './value-generator';
-
-export class TestGenerator {
-  private valueGenerator: ValueGenerator;
-
-  constructor() {
-    this.valueGenerator = new ValueGenerator();
-  }
-
-  generateTestFile(model: ContractModel, options: {
-    minimal: boolean;
-    coverage: boolean;
-  }): string {
-    this.valueGenerator.reset();
-
-    const imports = this.generateImports(model);
-    const testSuite = this.generateTestSuite(model, options);
-    
-    return `${imports}\n\n${testSuite}`;
-  }
-
-  private generateImports(model: ContractModel): string {
-    const contractName = model.name;
-    const contractPath = this.getRelativeTestPath(model.filePath);
-    
-    return `import { expect } from 'chai';
-import { ${contractName} } from '${contractPath.replace('.ts', '')}';
-import { 
-  bsv, 
-  TestWallet, 
-  DefaultProvider, 
-  sha256,
-  toByteString,
-  PubKey,
-  Sig,
-  findSig,
-  MethodCallOptions,
-  ContractTransaction,
-  getDefaultSigner
-} from 'scrypt-ts';
-
-describe('${contractName}', () => {
-  let signer: TestWallet;
-  let instance: ${contractName};`;
-  }
-
-  private getRelativeTestPath(contractPath: string): string {
-    // Convert absolute path to relative from test directory
-    const pathParts = contractPath.split('/');
-    const srcIndex = pathParts.lastIndexOf('src');
-    
-    if (srcIndex !== -1) {
-      const relativeParts = pathParts.slice(srcIndex);
-      return `../${relativeParts.join('/')}`;
-    }
-    
-    return contractPath;
-  }
-
-  private generateTestSuite(model: ContractModel, options: {
-    minimal: boolean;
-    coverage: boolean;
-  }): string {
-    let output = `
-  before(async () => {
-    await ${model.name}.loadArtifact();
-    
-    signer = await getDefaultSigner();
-  });
-
-  beforeEach(async () => {
-    instance = new ${model.name}(${this.valueGenerator.generateConstructorArgs(model.constructorArgs)});
-    await instance.connect(signer);
-  });
-`;
-
-    // Generate tests for each method
-    for (const method of model.methods) {
-      output += this.generateMethodTests(method, model, options);
-    }
-
-    output += `});`;
-    return output;
-  }
-
-  private generateMethodTests(method: ContractModel['methods'][0], model: ContractModel, options: {
-    minimal: boolean;
-    coverage: boolean;
-  }): string {
-    let output = `\n\n  describe('#${method.name}', () => {`;
-
-    // Happy path test
-    output += this.generateHappyPathTest(method, model);
-
-    // Revert test (unless minimal mode)
-    if (!options.minimal) {
-      output += this.generateRevertTest(method, model);
-    }
-
-    // Edge case tests (if coverage mode)
-    if (options.coverage) {
-      output += this.generateEdgeCaseTests(method, model);
-    }
-
-    output += `\n  });`;
-    return output;
-  }
-
-  private generateHappyPathTest(method: ContractModel['methods'][0], model: ContractModel): string {
-    const args = this.valueGenerator.generateMethodArgs(method.parameters, method.name);
-    const methodCall = `instance.methods.${method.name}(${args})`;
-    
-    let test = `
-    it('should succeed with valid parameters', async () => {
-   const deployTx = await instance.deploy(1)
-      const callTx = await ${methodCall};
-      
-      console.log('Deploy TX:', deployTx.id);
-      console.log('Call TX:', callTx.tx.id);
-    });
-`;
-
-    // Add assertions for state transitions
-    if (method.mutatesState) {
-      test = `
-    it('should succeed with valid parameters', async () => {
-    const deployTx = await instance.deploy(1)
-      const oldInstance = instance;
-      const callTx = await ${methodCall};
-      
-      console.log('Deploy TX:', deployTx.id);
-        console.log('Call TX:', callTx.tx.id);
-      
-      // Verify state transition if applicable
-      const result = await callTx.tx.id;
-      if (result.nexts && result.nexts.length > 0) {
-        const nextInstance = result.nexts[0].instance;
-        // Add state assertions here based on method logic
-      }
-    });
-`;
-    }
-
-    return test;
-  }
-
-  private generateRevertTest(method: ContractModel['methods'][0], model: ContractModel): string {
-    const args = this.valueGenerator.generateInvalidMethodArgs(method.parameters, method.name);
-    const methodCall = `instance.methods.${method.name}(${args})`;
-    
-    let test = `
-    it('should revert with invalid parameters', async () => {
-      try {
-      const deployTx = await instance.deploy(1)
-        const callTx = await ${methodCall};
-        console.error('Expected method to revert, but it succeeded:', callTx.tx.id);
-        
-      } catch (error) {
-        // Expected to throw an error
-        expect(error).to.be.an('error');
-      }
-    });
-`;
-
-    // Special handling for assert statements
-    if (method.hasAssert) {
-      test = `
-    it('should revert when assertion fails', async () => {
-      // Use parameters that will cause assert() to fail
-      const deployTx = await instance.deploy(1)
-      const callTx = await ${methodCall};
-
-      console.log('Deploy TX:', deployTx.id);
-      console.log('Call TX:', callTx.tx.id);
-      
-    
-    });
-`;
-    }
-
-    return test;
-  }
-
-  private generateEdgeCaseTests(method: ContractModel['methods'][0], model: ContractModel): string {
-    let tests = '';
-    
-    // Generate edge case for each parameter
-    method.parameters.forEach((param, index) => {
-      const edgeCaseValue = this.valueGenerator.getEdgeCaseValue(param.type);
-      const modifiedParams = method.parameters.map((p, i) => 
-        i === index ? { ...p, type: param.type } : p
-      );
-      const args = this.valueGenerator.generateMethodArgs(modifiedParams, method.name).replace(this.valueGenerator.generateMethodArgs(method.parameters, method.name), '').trim() || edgeCaseValue;
-      
-      const methodCall = `instance.methods.${method.name}(${args})`;
-      
-      tests += `
-    it('should handle edge case for ${param.name} (${edgeCaseValue})', async () => {
-      try {
-      const deployTx = await instance.deploy(1)
-        const callTx = await ${methodCall};
-        // Edge case might succeed or fail depending on contract logic
-        console.log('Deploy TX:', deployTx.id);
-        console.log('Call TX:', callTx.tx.id);
-      } catch (error) {
-        // Handle expected errors gracefully
-        expect(error).to.be.an('error');
-      }
-    });
-`;
-    });
-
-    return tests;
-  }
-}

package/src/generator/value-generator.ts

@@ -1,138 +0,0 @@
-import { ConstructorArg, MethodParameter } from '../model/contract-model';
-import { ContractModel } from '../model/contract-model';
-
-export class ValueGenerator {
-  private usedVariableNames = new Set<string>();
-  private testKeyPairs = new Map<string, { pubKey: string; privKey: string }>();
-
-  constructor() {
-    // Initialize with some test key pairs
-    this.testKeyPairs.set('default', {
-      pubKey: 'myPublicKey',
-      privKey: 'myPrivateKey'
-    });
-    this.testKeyPairs.set('alice', {
-      pubKey: 'alicePublicKey',
-      privKey: 'alicePrivateKey'
-    });
-    this.testKeyPairs.set('bob', {
-      pubKey: 'bobPublicKey',
-      privKey: 'bobPrivateKey'
-    });
-  }
-
-  generateConstructorArgs(args: ConstructorArg[]): string {
-    if (args.length === 0) return '';
-    
-    return args.map(arg => {
-      if (arg.defaultValue) {
-        return arg.defaultValue;
-      }
-      return this.generateValueForType(arg.type, arg.name);
-    }).join(', ');
-  }
-
-  generateMethodArgs(parameters: MethodParameter[], methodName: string): string {
-    return parameters.map(param => {
-      return this.generateValueForType(param.type, `${methodName}_${param.name}`);
-    }).join(', ');
-  }
-
-  generateInvalidMethodArgs(parameters: MethodParameter[], methodName: string): string {
-    return parameters.map(param => {
-      return this.generateInvalidValueForType(param.type, `${methodName}_${param.name}`);
-    }).join(', ');
-  }
-
-  private generateValueForType(type: string, variableName: string, model?: ContractModel): string {
-    // Ensure unique variable names
-    let uniqueName = variableName;
-    let counter = 1;
-    while (this.usedVariableNames.has(uniqueName)) {
-      uniqueName = `${variableName}${counter}`;
-      counter++;
-    }
-    this.usedVariableNames.add(uniqueName);
-
-    switch (type) {
-      case 'bigint':
-        return '1n';
-      case 'boolean':
-        return 'true';
-      case 'ByteString':
-        return `toByteString('00', false)`;
-      case 'PubKey':
-        return this.getTestKey('default').pubKey;
-      case 'Sig':
-        return ` (sigResps) => findSig(sigResps, myPublicKey)),
-                {
-                    pubKeyOrAddrToSign: myPublicKey,
-                } as MethodCallOptions<${model?.name}>`;
-      case 'number':
-        return '42';
-      case 'string':
-        return `'test'`;
-      default:
-        if (type.includes('bigint[]')) {
-          return '[1n, 2n, 3n]';
-        }
-        if (type.includes('[]')) {
-          return `[]`;
-        }
-        return 'undefined';
-    }
-  }
-
-  private generateInvalidValueForType(type: string, variableName: string): string {
-    switch (type) {
-      case 'bigint':
-        return '0n'; // Often invalid for amounts
-      case 'boolean':
-        return 'false';
-      case 'ByteString':
-        return `toByteString('', false)`; // Empty byte string
-      case 'PubKey':
-        return `PubKey(toByteString('00', false))`; // Invalid pubkey
-      case 'Sig':
-        return `Sig(toByteString('00', false))`; // Invalid signature
-      case 'number':
-        return '-1';
-      case 'string':
-        return `''`;
-      default:
-        return this.generateValueForType(type, variableName);
-    }
-  }
-
-  getTestKey(name: string = 'default'): { pubKey: string; privKey: string } {
-    const keyPair = this.testKeyPairs.get(name);
-    if (!keyPair) {
-      throw new Error(`Test key pair '${name}' not found`);
-    }
-    return keyPair;
-  }
-
-  getEdgeCaseValue(type: string, model?: ContractModel): string {
-    switch (type) {
-      case 'bigint':
-        return '0n';
-      case 'boolean':
-        return 'false';
-      case 'ByteString':
-        return `toByteString('ff', false)`;
-      case 'PubKey':
-        return `PubKey(toByteString('00'.repeat(33), false))`;
-      case 'Sig':
-        return ` (sigResps) => findSig(sigResps, myPublickey)),
-                {
-                    pubKeyOrAddrToSign: myPublicKey,
-                } as MethodCallOptions<${model?.name}>`;
-      default:
-        return this.generateValueForType(type, 'edgeCase');
-    }
-  }
-
-  reset(): void {
-    this.usedVariableNames.clear();
-  }
-}

package/src/model/contract-model.ts

@@ -1,46 +0,0 @@
-export interface ConstructorArg {
-  name: string;
-  type: string;
-  defaultValue?: string;
-}
-
-export interface ContractProp {
-  name: string;
-  type: string;
-  isMutable: boolean;
-  decoratorText: string;
-}
-
-export interface MethodParameter {
-  name: string;
-  type: string;
-  isOptional: boolean;
-}
-
-export enum MethodCategory {
-  PURE_VALIDATION = 'pure-validation',
-  STATE_TRANSITION = 'state-transition',
-  SPENDING_CONSTRAINT = 'spending-constraint'
-}
-
-export interface ContractMethod {
-  name: string;
-  parameters: MethodParameter[];
-  returnType: string;
-  category: MethodCategory;
-  isPublic: boolean;
-  mutatesState: boolean;
-  usesHashOutputs: boolean;
-  hasAssert: boolean;
-  decoratorText: string;
-}
-
-export interface ContractModel {
-  name: string;
-  filePath: string;
-  constructorArgs: ConstructorArg[];
-  props: ContractProp[];
-  methods: ContractMethod[];
-  imports: string[];
-  extendsClass: string;
-}

package/src/parser/ast-utils.ts

@@ -1,75 +0,0 @@
-import * as ts from 'typescript';
-
-export function getDecoratorText(decorator: ts.Decorator): string {
-  const decoratorText = decorator.getText();
-  if (decoratorText.includes('@prop')) {
-    return '@prop';
-  } else if (decoratorText.includes('@method')) {
-    return '@method';
-  }
-  return decoratorText;
-}
-
-export function getTypeText(type: ts.TypeNode | undefined, checker: ts.TypeChecker): string {
-  if (!type) return 'any';
-  
-  const typeText = type.getText();
-  
-  // Handle sCrypt specific types
-  if (typeText.includes('bigint')) return 'bigint';
-  if (typeText.includes('ByteString')) return 'ByteString';
-  if (typeText.includes('PubKey')) return 'PubKey';
-  if (typeText.includes('Sig')) return 'Sig';
-  if (typeText.includes('boolean')) return 'boolean';
-  if (typeText.includes('number')) return 'number';
-  
-  return typeText;
-}
-
-export function getDefaultValueForType(type: string): string {
-  switch (type) {
-    case 'bigint':
-      return '1n';
-    case 'boolean':
-      return 'true';
-    case 'ByteString':
-      return `toByteString('00', false)`;
-    case 'PubKey':
-      return `myPublicKey`;
-    case 'Sig':
-      return `mySignature`;
-    case 'number':
-      return '0';
-    case 'string':
-      return "''";
-    default:
-      if (type.includes('[]')) return '[]';
-      return 'undefined';
-  }
-}
-
-export function isSmartContractClass(node: ts.Node): boolean {
-  if (!ts.isClassDeclaration(node)) return false;
-  
-  // Check if extends SmartContract
-  if (node.heritageClauses) {
-    for (const heritage of node.heritageClauses) {
-      for (const type of heritage.types) {
-        if (type.getText().includes('SmartContract')) {
-          return true;
-        }
-      }
-    }
-  }
-  
-  return false;
-}
-
-export function findDecorator(node: ts.Node, decoratorName: string): ts.Decorator | undefined {
-  if (!ts.canHaveDecorators(node)) return undefined;
-  
-  const decorators = ts.getDecorators(node);
-  return decorators?.find((decorator: ts.Decorator) => 
-    decorator.getText().includes(decoratorName)
-  );
-}

package/src/parser/contract-parser.ts

@@ -1,246 +0,0 @@
-import * as ts from 'typescript';
-import * as path from 'path';
-import {
-  ConstructorArg,
-  ContractProp,
-  ContractMethod,
-  MethodParameter,
-  MethodCategory,
-  ContractModel
-} from '../model/contract-model';
-import {
-  getDecoratorText,
-  getTypeText,
-  getDefaultValueForType,
-  isSmartContractClass,
-  findDecorator
-} from './ast-utils';
-
-export class ContractParser {
-  private program: ts.Program;
-  private checker: ts.TypeChecker;
-  private sourceFile: ts.SourceFile;
-
-  constructor(filePath: string) {
-    this.program = ts.createProgram([filePath], {
-      target: ts.ScriptTarget.ES2020,
-      module: ts.ModuleKind.CommonJS,
-      experimentalDecorators: true,
-      emitDecoratorMetadata: true
-    });
-    
-    this.checker = this.program.getTypeChecker();
-    this.sourceFile = this.program.getSourceFile(filePath)!;
-    
-    if (!this.sourceFile) {
-      throw new Error(`Cannot read source file: ${filePath}`);
-    }
-  }
-
-  parse(): ContractModel {
-    const contractClass = this.findContractClass();
-    if (!contractClass) {
-      throw new Error('No SmartContract class found in file');
-    }
-
-    const className = contractClass.name?.text || 'UnknownContract';
-    
-    return {
-      name: className,
-      filePath: this.sourceFile.fileName,
-      constructorArgs: this.parseConstructor(contractClass),
-      props: this.parseProperties(contractClass),
-      methods: this.parseMethods(contractClass),
-      imports: this.parseImports(),
-      extendsClass: this.getExtendedClass(contractClass)
-    };
-  }
-
-  private findContractClass(): ts.ClassDeclaration | undefined {
-    let contractClass: ts.ClassDeclaration | undefined;
-
-    const visit = (node: ts.Node) => {
-      if (isSmartContractClass(node)) {
-        if (contractClass) {
-          throw new Error('Multiple SmartContract classes found. Only one per file is supported.');
-        }
-        contractClass = node as ts.ClassDeclaration;
-      }
-      ts.forEachChild(node, visit);
-    };
-
-    visit(this.sourceFile);
-    return contractClass;
-  }
-
-  private parseConstructor(classNode: ts.ClassDeclaration): ConstructorArg[] {
-    const constructor = classNode.members.find(
-      member => ts.isConstructorDeclaration(member)
-    ) as ts.ConstructorDeclaration;
-
-    if (!constructor || !constructor.parameters) {
-      return [];
-    }
-
-    return constructor.parameters.map(param => {
-      const paramName = param.name.getText();
-      const type = getTypeText(param.type, this.checker);
-      
-      return {
-        name: paramName,
-        type: type,
-        defaultValue: param.initializer ? param.initializer.getText() : undefined
-      };
-    });
-  }
-
-  private parseProperties(classNode: ts.ClassDeclaration): ContractProp[] {
-    const properties: ContractProp[] = [];
-
-    for (const member of classNode.members) {
-      if (ts.isPropertyDeclaration(member)) {
-        const decorators = ts.getDecorators(member);
-        if (decorators && decorators.length > 0) {
-          const propDecorator = findDecorator(member, '@prop');
-          if (propDecorator) {
-            const propName = member.name.getText();
-            const type = getTypeText(member.type, this.checker);
-            const decoratorText = decorators[0].getText();
-            const isMutable = decoratorText.includes('true');
-
-            properties.push({
-              name: propName,
-              type: type,
-              isMutable: isMutable,
-              decoratorText: decoratorText
-            });
-          }
-        }
-      }
-    }
-
-    return properties;
-  }
-
-  private parseMethods(classNode: ts.ClassDeclaration): ContractMethod[] {
-    const methods: ContractMethod[] = [];
-
-    for (const member of classNode.members) {
-      if (ts.isMethodDeclaration(member)) {
-        const decorators = ts.getDecorators(member);
-        if (decorators && decorators.length > 0) {
-          const methodDecorator = findDecorator(member, '@method');
-          if (methodDecorator) {
-            const methodName = member.name.getText();
-            
-            // Skip private methods
-            if (!member.modifiers?.some(m => m.kind === ts.SyntaxKind.PublicKeyword)) {
-              continue;
-            }
-
-            const parameters = this.parseMethodParameters(member);
-            const returnType = getTypeText(member.type, this.checker);
-            
-            const methodText = member.getText();
-            const usesHashOutputs = methodText.includes('this.ctx.hashOutputs');
-            const hasAssert = methodText.includes('assert(');
-            
-            // Classify method
-            const category = this.classifyMethod(member, methodText);
-            
-            // Determine if method mutates state
-            const mutatesState = this.doesMethodMutateState(member, methodText);
-
-            methods.push({
-              name: methodName,
-              parameters: parameters,
-              returnType: returnType,
-              category: category,
-              isPublic: true,
-              mutatesState: mutatesState,
-              usesHashOutputs: usesHashOutputs,
-              hasAssert: hasAssert,
-              decoratorText: getDecoratorText(methodDecorator)
-            });
-          }
-        }
-      }
-    }
-
-    return methods;
-  }
-
-  private parseMethodParameters(method: ts.MethodDeclaration): MethodParameter[] {
-    if (!method.parameters) {
-      return [];
-    }
-
-    return method.parameters.map(param => {
-      const paramName = param.name.getText();
-      const type = getTypeText(param.type, this.checker);
-      const isOptional = !!param.questionToken || !!param.initializer;
-
-      return {
-        name: paramName,
-        type: type,
-        isOptional: isOptional
-      };
-    });
-  }
-
-  private classifyMethod(method: ts.MethodDeclaration, methodText: string): MethodCategory {
-    const returnType = method.type?.getText() || 'void';
-    
-    // Methods that return boolean are often validation methods
-    if (returnType === 'boolean') {
-      return MethodCategory.PURE_VALIDATION;
-    }
-    
-    // Methods that modify @prop(true) properties
-    if (this.doesMethodMutateState(method, methodText)) {
-      return MethodCategory.STATE_TRANSITION;
-    }
-    
-    // Methods that check spending conditions
-    if (methodText.includes('this.ctx') || methodText.includes('hashOutputs')) {
-      return MethodCategory.SPENDING_CONSTRAINT;
-    }
-    
-    return MethodCategory.PURE_VALIDATION;
-  }
-
-  private doesMethodMutateState(method: ts.MethodDeclaration, methodText: string): boolean {
-    // Check for assignment to this.props (especially mutable ones)
-    const assignmentRegex = /this\.\w+\s*=/;
-    return assignmentRegex.test(methodText);
-  }
-
-  private parseImports(): string[] {
-    const imports: string[] = [];
-    
-    const visit = (node: ts.Node) => {
-      if (ts.isImportDeclaration(node)) {
-        imports.push(node.getText());
-      }
-      ts.forEachChild(node, visit);
-    };
-    
-    visit(this.sourceFile);
-    return imports;
-  }
-
-  private getExtendedClass(classNode: ts.ClassDeclaration): string {
-    if (!classNode.heritageClauses) return '';
-    
-    for (const heritage of classNode.heritageClauses) {
-      for (const type of heritage.types) {
-        const typeText = type.getText();
-        if (typeText.includes('SmartContract')) {
-          return typeText;
-        }
-      }
-    }
-    
-    return '';
-  }
-}

package/src/parser/index.ts

@@ -1,2 +0,0 @@
-export { ContractParser } from './contract-parser';
-export type { ContractModel } from '../model/contract-model';

package/src/utils/file-utils.ts

@@ -1,22 +0,0 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
-import { dirname } from 'path';
-
-export function ensureDirectoryExists(filePath: string): void {
-  const dir = dirname(filePath);
-  if (!existsSync(dir)) {
-    mkdirSync(dir, { recursive: true });
-  }
-}
-
-export function readContractFile(filePath: string): string {
-  try {
-    return readFileSync(filePath, 'utf-8');
-  } catch (error) {
-    throw new Error(`Cannot read contract file: ${filePath}. ${error}`);
-  }
-}
-
-export function writeTestFile(filePath: string, content: string): void {
-  ensureDirectoryExists(filePath);
-  writeFileSync(filePath, content, 'utf-8');
-}

package/test/integration/demo.ts

@@ -1,16 +0,0 @@
-import { SmartContract, prop, method, assert, PubKey, Sig } from 'scrypt-ts';
-
-export class SimpleLock extends SmartContract {
-    @prop()
-    readonly owner: PubKey;
-
-    constructor(owner: PubKey) {
-        super();
-        this.owner = owner;
-    }
-
-    @method()
-    public unlock(sig: Sig) {
-        assert(this.checkSig(sig, this.owner), 'Signature check failed');
-    }
-}

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
-}