scrypt-testgen 1.0.0

package/src/parser/contract-parser.ts

@@ -0,0 +1,246 @@
+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

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

package/src/utils/file-utils.ts

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,21 @@
+{
+  "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"]
+}