@alephium/web3 0.2.0-rc.8 → 0.2.0-test.1

package/src/contract/contract.ts

@@ -17,7 +17,8 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Buffer } from 'buffer/'
-import { webcrypto as crypto } from 'crypto'
+import * as cryptojs from 'crypto-js'
+import * as crypto from 'crypto'
 import fs from 'fs'
 import { promises as fsPromises } from 'fs'
 import { node, NodeProvider } from '../api'
@@ -38,38 +39,39 @@ enum SourceType {
   Interface = 3
 }
 
-export type CompilerOptions = node.CompilerOptions & {
+export type CompilerOptions = {
   errorOnWarnings: boolean
+  ignoreUnusedConstantsWarnings: boolean
 }
 
-export const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions = {
-  ignoreUnusedConstantsWarnings: false,
-  ignoreUnusedVariablesWarnings: false,
-  ignoreUnusedFieldsWarnings: false,
-  ignoreUnusedPrivateFunctionsWarnings: false,
-  ignoreReadonlyCheckWarnings: false,
-  ignoreExternalCallCheckWarnings: false
+export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = {
+  errorOnWarnings: true,
+  ignoreUnusedConstantsWarnings: true
 }
 
-export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = { errorOnWarnings: true, ...DEFAULT_NODE_COMPILER_OPTIONS }
-
 class TypedMatcher<T extends SourceType> {
   matcher: RegExp
   type: T
+  name: string | undefined
 
   constructor(pattern: string, type: T) {
     this.matcher = new RegExp(pattern, 'mg')
     this.type = type
+    this.name = undefined
   }
 
   match(str: string): number {
-    const results = str.match(this.matcher)
-    return results === null ? 0 : results.length
+    const results = [...str.matchAll(this.matcher)]
+    if (results.length > 0) {
+      this.name = results[0][1]
+    }
+    return results.length
   }
 }
 
 class SourceFile {
   type: SourceType
+  typeId: string
   contractPath: string
   sourceCode: string
   sourceCodeHash: string
@@ -78,17 +80,13 @@ class SourceFile {
     return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json'
   }
 
-  constructor(type: SourceType, sourceCode: string, sourceCodeHash: string, contractPath: string) {
+  constructor(type: SourceType, typeId: string, sourceCode: string, contractPath: string) {
     this.type = type
+    this.typeId = typeId
     this.sourceCode = sourceCode
-    this.sourceCodeHash = sourceCodeHash
+    this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString()
     this.contractPath = contractPath
   }
-
-  static async from(type: SourceType, sourceCode: string, contractPath: string): Promise<SourceFile> {
-    const sourceCodeHash = await crypto.subtle.digest('SHA-256', Buffer.from(sourceCode))
-    return new SourceFile(type, sourceCode, Buffer.from(sourceCodeHash).toString('hex'), contractPath)
-  }
 }
 
 class Compiled<T extends Artifact> {
@@ -106,47 +104,19 @@ class Compiled<T extends Artifact> {
 class ProjectArtifact {
   static readonly artifactFileName = '.project.json'
 
-  compilerOptionsUsed: node.CompilerOptions
   infos: Map<string, { sourceCodeHash: string; warnings: string[] }>
 
-  static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void {
-    if (Object.keys(compilerOptions).length != Object.keys(DEFAULT_NODE_COMPILER_OPTIONS).length) {
-      throw Error(`Not all compiler options are set: ${compilerOptions}`)
-    }
-
-    const combined = { ...compilerOptions, ...DEFAULT_NODE_COMPILER_OPTIONS }
-    if (Object.keys(combined).length !== Object.keys(DEFAULT_NODE_COMPILER_OPTIONS).length) {
-      throw Error(`There are unknown compiler options: ${compilerOptions}`)
-    }
-  }
-
-  constructor(
-    compilerOptionsUsed: node.CompilerOptions,
-    infos: Map<string, { sourceCodeHash: string; warnings: string[] }>
-  ) {
-    ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed)
-    this.compilerOptionsUsed = compilerOptionsUsed
+  constructor(infos: Map<string, { sourceCodeHash: string; warnings: string[] }>) {
     this.infos = infos
   }
 
   async saveToFile(rootPath: string): Promise<void> {
     const filepath = rootPath + '/' + ProjectArtifact.artifactFileName
-    const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) }
-    const content = JSON.stringify(artifact, null, 2)
+    const content = JSON.stringify(Object.fromEntries(this.infos), null, 2)
     return fsPromises.writeFile(filepath, content)
   }
 
-  needToReCompile(compilerOptions: node.CompilerOptions, files: SourceFile[]): boolean {
-    ProjectArtifact.checkCompilerOptionsParameter(compilerOptions)
-
-    const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
-      const usedOption = this.compilerOptionsUsed[`${key}`]
-      return usedOption === inputOption
-    })
-    if (!optionsMatched) {
-      return true
-    }
-
+  sourceHasChanged(files: SourceFile[]): boolean {
     if (files.length !== this.infos.size) {
       return true
     }
@@ -156,7 +126,6 @@ class ProjectArtifact {
         return true
       }
     }
-
     return false
   }
 
@@ -166,10 +135,10 @@ class ProjectArtifact {
       return undefined
     }
     const content = await fsPromises.readFile(filepath)
-    const json = JSON.parse(content.toString())
-    const compilerOptionsUsed = json.compilerOptionsUsed as node.CompilerOptions
-    const files = new Map(Object.entries<{ sourceCodeHash: string; warnings: string[] }>(json.infos))
-    return new ProjectArtifact(compilerOptionsUsed, files)
+    const files = new Map(
+      Object.entries<{ sourceCodeHash: string; warnings: string[] }>(JSON.parse(content.toString()))
+    )
+    return new ProjectArtifact(files)
   }
 }
 
@@ -177,7 +146,6 @@ export class Project {
   sourceFiles: SourceFile[]
   contracts: Compiled<Contract>[]
   scripts: Compiled<Script>[]
-  projectArtifact: ProjectArtifact
 
   readonly contractsRootPath: string
   readonly artifactsRootPath: string
@@ -186,12 +154,12 @@ export class Project {
   static currentProject: Project
 
   static readonly abstractContractMatcher = new TypedMatcher<SourceType>(
-    '^Abstract Contract [A-Z][a-zA-Z0-9]*',
+    '^Abstract Contract ([A-Z][a-zA-Z0-9]*)\\(*',
     SourceType.AbstractContract
   )
-  static readonly contractMatcher = new TypedMatcher('^Contract [A-Z][a-zA-Z0-9]*', SourceType.Contract)
-  static readonly interfaceMatcher = new TypedMatcher('^Interface [A-Z][a-zA-Z0-9]* \\{', SourceType.Interface)
-  static readonly scriptMatcher = new TypedMatcher('^TxScript [A-Z][a-zA-Z0-9]*', SourceType.Script)
+  static readonly contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)\\(*', SourceType.Contract)
+  static readonly interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceType.Interface)
+  static readonly scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)( \\{*|\\(*)', SourceType.Script)
   static readonly matchers = [
     Project.abstractContractMatcher,
     Project.contractMatcher,
@@ -199,44 +167,13 @@ export class Project {
     Project.scriptMatcher
   ]
 
-  static buildProjectArtifact(
-    sourceFiles: SourceFile[],
-    contracts: Compiled<Contract>[],
-    scripts: Compiled<Script>[],
-    compilerOptions: node.CompilerOptions
-  ): ProjectArtifact {
-    const files: Map<string, { sourceCodeHash: string; warnings: string[] }> = new Map()
-    contracts.forEach((c) => {
-      files.set(c.sourceFile.contractPath, {
-        sourceCodeHash: c.sourceFile.sourceCodeHash,
-        warnings: c.warnings
-      })
-    })
-    scripts.forEach((s) => {
-      files.set(s.sourceFile.contractPath, {
-        sourceCodeHash: s.sourceFile.sourceCodeHash,
-        warnings: s.warnings
-      })
-    })
-    const compiledSize = contracts.length + scripts.length
-    sourceFiles.slice(compiledSize).forEach((c) => {
-      files.set(c.contractPath, {
-        sourceCodeHash: c.sourceCodeHash,
-        warnings: []
-      })
-    })
-    return new ProjectArtifact(compilerOptions, files)
-  }
-
   private constructor(
     provider: NodeProvider,
     contractsRootPath: string,
     artifactsRootPath: string,
     sourceFiles: SourceFile[],
     contracts: Compiled<Contract>[],
-    scripts: Compiled<Script>[],
-    errorOnWarnings: boolean,
-    projectArtifact: ProjectArtifact
+    scripts: Compiled<Script>[]
   ) {
     this.nodeProvider = provider
     this.contractsRootPath = contractsRootPath
@@ -244,14 +181,6 @@ export class Project {
     this.sourceFiles = sourceFiles
     this.contracts = contracts
     this.scripts = scripts
-    this.projectArtifact = projectArtifact
-
-    if (errorOnWarnings) {
-      Project.checkCompilerWarnings(
-        [...contracts.map((c) => c.warnings).flat(), ...scripts.map((s) => s.warnings).flat()],
-        errorOnWarnings
-      )
-    }
   }
 
   private getContractPath(path: string): string {
@@ -262,12 +191,15 @@ export class Project {
       : this.contractsRootPath + '/' + path
   }
 
-  static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void {
-    if (warnings.length !== 0) {
+  private static checkCompilerWarnings(warnings: string[], compilerOptions: CompilerOptions): void {
+    const remains = compilerOptions.ignoreUnusedConstantsWarnings
+      ? warnings.filter((s) => !s.includes('unused constants'))
+      : warnings
+    if (remains.length !== 0) {
       const prefixPerWarning = '  - '
-      const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning)
-      const output = `Compilation warnings:\n` + warningString + '\n'
-      if (errorOnWarnings) {
+      const warningString = prefixPerWarning + remains.join('\n' + prefixPerWarning)
+      const output = 'Compilation warnings:\n' + warningString + '\n'
+      if (compilerOptions.errorOnWarnings) {
         throw new Error(output)
       } else {
         console.log(output)
@@ -275,21 +207,23 @@ export class Project {
     }
   }
 
-  static contract(path: string): Contract {
+  static contract(path: string, compilerOptions?: Partial<CompilerOptions>): Contract {
     const contractPath = Project.currentProject.getContractPath(path)
     const contract = Project.currentProject.contracts.find((c) => c.sourceFile.contractPath === contractPath)
     if (typeof contract === 'undefined') {
       throw new Error(`Contract ${contractPath} does not exist`)
     }
+    Project.checkCompilerWarnings(contract.warnings, { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions })
     return contract.artifact
   }
 
-  static script(path: string): Script {
+  static script(path: string, compilerOptions?: Partial<CompilerOptions>): Script {
     const contractPath = Project.currentProject.getContractPath(path)
     const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath)
     if (typeof script === 'undefined') {
       throw new Error(`Script ${contractPath} does not exist`)
     }
+    Project.checkCompilerWarnings(script.warnings, { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions })
     return script.artifact
   }
 
@@ -309,7 +243,6 @@ export class Project {
     for (const script of this.scripts) {
       await saveToFile(script)
     }
-    await this.projectArtifact.saveToFile(this.artifactsRootPath)
   }
 
   contractByCodeHash(codeHash: string): Contract {
@@ -320,43 +253,56 @@ export class Project {
     return contract.artifact
   }
 
+  private async saveProjectArtifactToFile(): Promise<void> {
+    const files: Map<string, { sourceCodeHash: string; warnings: string[] }> = new Map()
+    this.contracts.forEach((c) => {
+      files.set(c.sourceFile.contractPath, {
+        sourceCodeHash: c.sourceFile.sourceCodeHash,
+        warnings: c.warnings
+      })
+    })
+    this.scripts.forEach((s) => {
+      files.set(s.sourceFile.contractPath, {
+        sourceCodeHash: s.sourceFile.sourceCodeHash,
+        warnings: s.warnings
+      })
+    })
+    const compiledSize = this.contracts.length + this.scripts.length
+    this.sourceFiles.slice(compiledSize).forEach((c) => {
+      files.set(c.contractPath, {
+        sourceCodeHash: c.sourceCodeHash,
+        warnings: []
+      })
+    })
+    const projectArtifact = new ProjectArtifact(files)
+    await projectArtifact.saveToFile(this.artifactsRootPath)
+  }
+
   private static async compile(
     provider: NodeProvider,
     files: SourceFile[],
     contractsRootPath: string,
-    artifactsRootPath: string,
-    errorOnWarnings: boolean,
-    compilerOptions: node.CompilerOptions
+    artifactsRootPath: string
   ): Promise<Project> {
     const sourceStr = files.map((f) => f.sourceCode).join('\n')
     const result = await provider.contracts.postContractsCompileProject({
-      code: sourceStr,
-      compilerOptions: compilerOptions
+      code: sourceStr
     })
     const contracts: Compiled<Contract>[] = []
     const scripts: Compiled<Script>[] = []
     result.contracts.forEach((contractResult, index) => {
       const sourceFile = files[`${index}`]
-      const contract = Contract.fromCompileResult(contractResult)
+      const contract = Contract.fromCompileResult(sourceFile.typeId, contractResult)
       contracts.push(new Compiled(sourceFile, contract, contractResult.warnings))
     })
     result.scripts.forEach((scriptResult, index) => {
       const sourceFile = files[index + contracts.length]
-      const script = Script.fromCompileResult(scriptResult)
+      const script = Script.fromCompileResult(sourceFile.typeId, scriptResult)
       scripts.push(new Compiled(sourceFile, script, scriptResult.warnings))
     })
-    const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions)
-    const project = new Project(
-      provider,
-      contractsRootPath,
-      artifactsRootPath,
-      files,
-      contracts,
-      scripts,
-      errorOnWarnings,
-      projectArtifact
-    )
+    const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts)
     await project.saveArtifactsToFile()
+    await project.saveProjectArtifactToFile()
     return project
   }
 
@@ -365,9 +311,7 @@ export class Project {
     files: SourceFile[],
     projectArtifact: ProjectArtifact,
     contractsRootPath: string,
-    artifactsRootPath: string,
-    errorOnWarnings: boolean,
-    compilerOptions: node.CompilerOptions
+    artifactsRootPath: string
   ): Promise<Project> {
     try {
       const contracts: Compiled<Contract>[] = []
@@ -387,20 +331,10 @@ export class Project {
           scripts.push(new Compiled(file, artifact, warnings))
         }
       }
-
-      return new Project(
-        provider,
-        contractsRootPath,
-        artifactsRootPath,
-        files,
-        contracts,
-        scripts,
-        errorOnWarnings,
-        projectArtifact
-      )
+      return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts)
     } catch (error) {
       console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`)
-      return Project.compile(provider, files, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions)
+      return Project.compile(provider, files, contractsRootPath, artifactsRootPath)
     }
   }
 
@@ -421,8 +355,12 @@ export class Project {
       throw new Error(`Multiple definitions in file: ${contractPath}`)
     }
     const matcherIndex = results.indexOf(1)
-    const type = this.matchers[`${matcherIndex}`].type
-    return SourceFile.from(type, sourceStr, contractPath)
+    const matcher = this.matchers[`${matcherIndex}`]
+    const type = matcher.type
+    if (matcher.name === undefined) {
+      throw new Error(`Invalid definition in file: ${contractPath}`)
+    }
+    return new SourceFile(type, matcher.name, sourceStr, contractPath)
   }
 
   private static async loadSourceFiles(contractsRootPath: string): Promise<SourceFile[]> {
@@ -449,44 +387,30 @@ export class Project {
     return sourceFiles.sort((a, b) => a.type - b.type)
   }
 
-  static async build(
-    compilerOptionsPartial: Partial<CompilerOptions> = {},
-    contractsRootPath = 'contracts',
-    artifactsRootPath = 'artifacts'
-  ): Promise<void> {
+  static async build(contractsRootPath = 'contracts', artifactsRootPath = 'artifacts'): Promise<void> {
     const provider = getCurrentNodeProvider()
     const sourceFiles = await Project.loadSourceFiles(contractsRootPath)
-    const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
     const projectArtifact = await ProjectArtifact.from(artifactsRootPath)
-    if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
-      console.log(`Compile contracts in folder "${contractsRootPath}"`)
-      Project.currentProject = await Project.compile(
-        provider,
-        sourceFiles,
-        contractsRootPath,
-        artifactsRootPath,
-        errorOnWarnings,
-        nodeCompilerOptions
-      )
+    if (typeof projectArtifact === 'undefined' || projectArtifact.sourceHasChanged(sourceFiles)) {
+      Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath)
     } else {
-      console.log(`Load compiled contracts from folder "${artifactsRootPath}"`)
       Project.currentProject = await Project.loadArtifacts(
         provider,
         sourceFiles,
         projectArtifact,
         contractsRootPath,
-        artifactsRootPath,
-        errorOnWarnings,
-        nodeCompilerOptions
+        artifactsRootPath
       )
     }
   }
 }
 
 export abstract class Artifact {
+  readonly typeId: string
   readonly functions: FunctionSig[]
 
-  constructor(functions: FunctionSig[]) {
+  constructor(typeId: string, functions: FunctionSig[]) {
+    this.typeId = typeId
     this.functions = functions
   }
 
@@ -512,13 +436,14 @@ export class Contract extends Artifact {
   readonly eventsSig: EventSig[]
 
   constructor(
+    typeId: string,
     bytecode: string,
     codeHash: string,
     fieldsSig: FieldsSig,
     eventsSig: EventSig[],
     functions: FunctionSig[]
   ) {
-    super(functions)
+    super(typeId, functions)
     this.bytecode = bytecode
     this.codeHash = codeHash
     this.fieldsSig = fieldsSig
@@ -537,6 +462,7 @@ export class Contract extends Artifact {
       throw Error('The artifact JSON for contract is incomplete')
     }
     const contract = new Contract(
+      artifact.typeId,
       artifact.bytecode,
       artifact.codeHash,
       artifact.fieldsSig,
@@ -546,8 +472,8 @@ export class Contract extends Artifact {
     return contract
   }
 
-  static fromCompileResult(result: CompileContractResult): Contract {
-    return new Contract(result.bytecode, result.codeHash, result.fields, result.events, result.functions)
+  static fromCompileResult(typeId: string, result: CompileContractResult): Contract {
+    return new Contract(typeId, result.bytecode, result.codeHash, result.fields, result.events, result.functions)
   }
 
   // support both 'code.ral' and 'code.ral.json'
@@ -566,6 +492,7 @@ export class Contract extends Artifact {
 
   override toString(): string {
     const object = {
+      typeId: this.typeId,
       bytecode: this.bytecode,
       codeHash: this.codeHash,
       fieldsSig: this.fieldsSig,
@@ -588,10 +515,8 @@ export class Contract extends Artifact {
     }
   }
 
-  // no need to be cryptographically strong random
   static randomAddress(): string {
-    const bytes = new Uint8Array(33)
-    crypto.getRandomValues(bytes)
+    const bytes = crypto.randomBytes(33)
     bytes[0] = 3
     return bs58.encode(bytes)
   }
@@ -776,14 +701,14 @@ export class Script extends Artifact {
   readonly bytecodeTemplate: string
   readonly fieldsSig: FieldsSig
 
-  constructor(bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
-    super(functions)
+  constructor(typeId: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
+    super(typeId, functions)
     this.bytecodeTemplate = bytecodeTemplate
     this.fieldsSig = fieldsSig
   }
 
-  static fromCompileResult(result: CompileScriptResult): Script {
-    return new Script(result.bytecodeTemplate, result.fields, result.functions)
+  static fromCompileResult(typeId: string, result: CompileScriptResult): Script {
+    return new Script(typeId, result.bytecodeTemplate, result.fields, result.functions)
   }
 
   // TODO: safely parse json
@@ -791,7 +716,7 @@ export class Script extends Artifact {
     if (artifact.bytecodeTemplate == null || artifact.fieldsSig == null || artifact.functions == null) {
       throw Error('The artifact JSON for script is incomplete')
     }
-    return new Script(artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
+    return new Script(artifact.typeId, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
   }
 
   static async fromArtifactFile(path: string): Promise<Script> {
@@ -802,6 +727,7 @@ export class Script extends Artifact {
 
   override toString(): string {
     const object = {
+      typeId: this.typeId,
       bytecodeTemplate: this.bytecodeTemplate,
       fieldsSig: this.fieldsSig,
       functions: this.functions