@alephium/web3 0.2.0-test.0 → 0.2.0-test.1

package/src/contract/contract.ts

@@ -21,246 +21,438 @@ import * as cryptojs from 'crypto-js'
 import * as crypto from 'crypto'
 import fs from 'fs'
 import { promises as fsPromises } from 'fs'
-import { NodeProvider } from '../api'
-import { node } from '../api'
+import { node, NodeProvider } from '../api'
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer'
 import * as ralph from './ralph'
 import { bs58, binToHex, contractIdFromAddress, assertType, Eq } from '../utils'
+import { CompileContractResult, CompileScriptResult } from '../api/api-alephium'
+import { getCurrentNodeProvider } from '../global'
+
+type FieldsSig = node.FieldsSig
+type EventSig = node.EventSig
+type FunctionSig = node.FunctionSig
+
+enum SourceType {
+  Contract = 0,
+  Script = 1,
+  AbstractContract = 2,
+  Interface = 3
+}
 
-class SourceFile {
-  readonly dirs: string[]
-  readonly dirPath: string
-  readonly contractPath: string
-  readonly artifactPath: string
-
-  constructor(dirs: string[], fileName: string) {
-    this.dirs = dirs
-    this.dirPath = dirs.length === 0 ? '' : dirs.join('/') + '/'
-    if (fileName.endsWith('.json')) {
-      this.contractPath = './contracts/' + this.dirPath + fileName.slice(0, -5)
-      this.artifactPath = './artifacts/' + this.dirPath + fileName
-    } else {
-      this.contractPath = './contracts/' + this.dirPath + fileName
-      this.artifactPath = './artifacts/' + this.dirPath + fileName + '.json'
+export type CompilerOptions = {
+  errorOnWarnings: boolean
+  ignoreUnusedConstantsWarnings: boolean
+}
+
+export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = {
+  errorOnWarnings: true,
+  ignoreUnusedConstantsWarnings: true
+}
+
+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.matchAll(this.matcher)]
+    if (results.length > 0) {
+      this.name = results[0][1]
     }
+    return results.length
   }
 }
 
-export abstract class Common {
-  readonly sourceCodeSha256: string
-  readonly functions: node.FunctionSig[]
-
-  static readonly importRegex = new RegExp('^import "([^"/]+/(([^"]+)/)?)?[a-z][a-z_0-9]*.ral"', 'mg')
-  static readonly contractRegex = new RegExp('^TxContract [A-Z][a-zA-Z0-9]*', 'mg')
-  static readonly interfaceRegex = new RegExp('^Interface [A-Z][a-zA-Z0-9]* \\{', 'mg')
-  static readonly scriptRegex = new RegExp('^TxScript [A-Z][a-zA-Z0-9]*', 'mg')
-
-  private static _artifactCache: Map<string, Contract | Script> = new Map<string, Contract | Script>()
-  static artifactCacheCapacity = 20
-  protected static _getArtifactFromCache(codeHash: string): Contract | Script | undefined {
-    return this._artifactCache.get(codeHash)
-  }
-  protected static _putArtifactToCache(contract: Contract): void {
-    if (!this._artifactCache.has(contract.codeHash)) {
-      if (this._artifactCache.size >= this.artifactCacheCapacity) {
-        const keyToDelete = this._artifactCache.keys().next().value
-        this._artifactCache.delete(keyToDelete)
+class SourceFile {
+  type: SourceType
+  typeId: string
+  contractPath: string
+  sourceCode: string
+  sourceCodeHash: string
+
+  getArtifactPath(artifactsRootPath: string): string {
+    return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json'
+  }
+
+  constructor(type: SourceType, typeId: string, sourceCode: string, contractPath: string) {
+    this.type = type
+    this.typeId = typeId
+    this.sourceCode = sourceCode
+    this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString()
+    this.contractPath = contractPath
+  }
+}
+
+class Compiled<T extends Artifact> {
+  sourceFile: SourceFile
+  artifact: T
+  warnings: string[]
+
+  constructor(sourceFile: SourceFile, artifact: T, warnings: string[]) {
+    this.sourceFile = sourceFile
+    this.artifact = artifact
+    this.warnings = warnings
+  }
+}
+
+class ProjectArtifact {
+  static readonly artifactFileName = '.project.json'
+
+  infos: Map<string, { sourceCodeHash: string; warnings: string[] }>
+
+  constructor(infos: Map<string, { sourceCodeHash: string; warnings: string[] }>) {
+    this.infos = infos
+  }
+
+  async saveToFile(rootPath: string): Promise<void> {
+    const filepath = rootPath + '/' + ProjectArtifact.artifactFileName
+    const content = JSON.stringify(Object.fromEntries(this.infos), null, 2)
+    return fsPromises.writeFile(filepath, content)
+  }
+
+  sourceHasChanged(files: SourceFile[]): boolean {
+    if (files.length !== this.infos.size) {
+      return true
+    }
+    for (const file of files) {
+      const info = this.infos.get(file.contractPath)
+      if (typeof info === 'undefined' || info.sourceCodeHash !== file.sourceCodeHash) {
+        return true
       }
-      this._artifactCache.set(contract.codeHash, contract)
     }
+    return false
   }
 
-  constructor(sourceCodeSha256: string, functions: node.FunctionSig[]) {
-    this.sourceCodeSha256 = sourceCodeSha256
-    this.functions = functions
+  static async from(rootPath: string): Promise<ProjectArtifact | undefined> {
+    const filepath = rootPath + '/' + ProjectArtifact.artifactFileName
+    if (!fs.existsSync(filepath)) {
+      return undefined
+    }
+    const content = await fsPromises.readFile(filepath)
+    const files = new Map(
+      Object.entries<{ sourceCodeHash: string; warnings: string[] }>(JSON.parse(content.toString()))
+    )
+    return new ProjectArtifact(files)
   }
+}
 
-  protected static _artifactsFolder(): string {
-    return './artifacts/'
+export class Project {
+  sourceFiles: SourceFile[]
+  contracts: Compiled<Contract>[]
+  scripts: Compiled<Script>[]
+
+  readonly contractsRootPath: string
+  readonly artifactsRootPath: string
+  readonly nodeProvider: NodeProvider
+
+  static currentProject: Project
+
+  static readonly abstractContractMatcher = new TypedMatcher<SourceType>(
+    '^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 matchers = [
+    Project.abstractContractMatcher,
+    Project.contractMatcher,
+    Project.interfaceMatcher,
+    Project.scriptMatcher
+  ]
+
+  private constructor(
+    provider: NodeProvider,
+    contractsRootPath: string,
+    artifactsRootPath: string,
+    sourceFiles: SourceFile[],
+    contracts: Compiled<Contract>[],
+    scripts: Compiled<Script>[]
+  ) {
+    this.nodeProvider = provider
+    this.contractsRootPath = contractsRootPath
+    this.artifactsRootPath = artifactsRootPath
+    this.sourceFiles = sourceFiles
+    this.contracts = contracts
+    this.scripts = scripts
+  }
+
+  private getContractPath(path: string): string {
+    return path.startsWith(`./${this.contractsRootPath}`)
+      ? path.slice(2)
+      : path.startsWith(this.contractsRootPath)
+      ? path
+      : this.contractsRootPath + '/' + path
+  }
+
+  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 + remains.join('\n' + prefixPerWarning)
+      const output = 'Compilation warnings:\n' + warningString + '\n'
+      if (compilerOptions.errorOnWarnings) {
+        throw new Error(output)
+      } else {
+        console.log(output)
+      }
+    }
   }
 
-  static getSourceFile(path: string, _dirs: string[]): SourceFile {
-    const parts = path.split('/')
-    const dirs = Array.from(_dirs)
-    if (parts.length === 1) {
-      return new SourceFile(dirs, path)
+  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`)
     }
-    parts.slice(0, parts.length - 1).forEach((part) => {
-      switch (part) {
-        case '.': {
-          break
-        }
-        case '..': {
-          if (dirs.length === 0) {
-            throw new Error('Invalid file path: ' + path)
-          }
-          dirs.pop()
-          break
-        }
-        default: {
-          dirs.push(part)
-        }
+    Project.checkCompilerWarnings(contract.warnings, { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions })
+    return contract.artifact
+  }
+
+  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
+  }
+
+  private async saveArtifactsToFile(): Promise<void> {
+    const artifactsRootPath = this.artifactsRootPath
+    const saveToFile = async function (compiled: Compiled<Artifact>): Promise<void> {
+      const artifactPath = compiled.sourceFile.getArtifactPath(artifactsRootPath)
+      const folder = artifactPath.slice(0, artifactPath.lastIndexOf('/'))
+      if (!fs.existsSync(folder)) {
+        fs.mkdirSync(folder, { recursive: true })
       }
+      return fsPromises.writeFile(artifactPath, compiled.artifact.toString())
+    }
+    for (const contract of this.contracts) {
+      await saveToFile(contract)
+    }
+    for (const script of this.scripts) {
+      await saveToFile(script)
+    }
+  }
+
+  contractByCodeHash(codeHash: string): Contract {
+    const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash)
+    if (typeof contract === 'undefined') {
+      throw new Error(`Unknown code with code hash: ${codeHash}`)
+    }
+    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
+      })
     })
-    return new SourceFile(dirs, parts[parts.length - 1])
-  }
-
-  protected static async _handleImports(
-    pathes: string[],
-    contractStr: string,
-    importsCache: string[]
-  ): Promise<string> {
-    const localImportsCache: string[] = []
-    let result = contractStr.replace(Common.importRegex, (match) => {
-      localImportsCache.push(match)
-      return ''
+    this.scripts.forEach((s) => {
+      files.set(s.sourceFile.contractPath, {
+        sourceCodeHash: s.sourceFile.sourceCodeHash,
+        warnings: s.warnings
+      })
     })
-    for (const myImport of localImportsCache) {
-      const relativePath = myImport.slice(8, -1)
-      const importSourceFile = this.getSourceFile(relativePath, pathes)
-      if (!importsCache.includes(importSourceFile.contractPath)) {
-        importsCache.push(importSourceFile.contractPath)
-        const importContractStr = await Common._loadContractStr(importSourceFile, importsCache, (code) =>
-          Contract.checkCodeType(importSourceFile.contractPath, code)
-        )
-        result = result.concat('\n', importContractStr)
-      }
-    }
-    return result
+    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)
   }
 
-  protected static async _loadContractStr(
-    sourceFile: SourceFile,
-    importsCache: string[],
-    validate: (code: string) => void
-  ): Promise<string> {
-    const contractPath = sourceFile.contractPath
-    const contractBuffer = await fsPromises.readFile(contractPath)
-    const contractStr = contractBuffer.toString()
+  private static async compile(
+    provider: NodeProvider,
+    files: SourceFile[],
+    contractsRootPath: string,
+    artifactsRootPath: string
+  ): Promise<Project> {
+    const sourceStr = files.map((f) => f.sourceCode).join('\n')
+    const result = await provider.contracts.postContractsCompileProject({
+      code: sourceStr
+    })
+    const contracts: Compiled<Contract>[] = []
+    const scripts: Compiled<Script>[] = []
+    result.contracts.forEach((contractResult, index) => {
+      const sourceFile = files[`${index}`]
+      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(sourceFile.typeId, scriptResult)
+      scripts.push(new Compiled(sourceFile, script, scriptResult.warnings))
+    })
+    const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts)
+    await project.saveArtifactsToFile()
+    await project.saveProjectArtifactToFile()
+    return project
+  }
 
-    validate(contractStr)
-    return Common._handleImports(sourceFile.dirs, contractStr, importsCache)
+  private static async loadArtifacts(
+    provider: NodeProvider,
+    files: SourceFile[],
+    projectArtifact: ProjectArtifact,
+    contractsRootPath: string,
+    artifactsRootPath: string
+  ): Promise<Project> {
+    try {
+      const contracts: Compiled<Contract>[] = []
+      const scripts: Compiled<Script>[] = []
+      for (const file of files) {
+        const info = projectArtifact.infos.get(file.contractPath)
+        if (typeof info === 'undefined') {
+          throw Error(`Unable to find project info for ${file.contractPath}, please rebuild the project`)
+        }
+        const warnings = info.warnings
+        const artifactPath = file.getArtifactPath(artifactsRootPath)
+        if (file.type === SourceType.Contract) {
+          const artifact = await Contract.fromArtifactFile(artifactPath)
+          contracts.push(new Compiled(file, artifact, warnings))
+        } else if (file.type === SourceType.Script) {
+          const artifact = await Script.fromArtifactFile(artifactPath)
+          scripts.push(new Compiled(file, artifact, warnings))
+        }
+      }
+      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)
+    }
   }
 
-  static checkFileNameExtension(fileName: string): void {
-    if (!fileName.endsWith('.ral')) {
-      throw new Error('Smart contract file name should end with ".ral"')
+  private static async loadSourceFile(dirPath: string, filename: string): Promise<SourceFile> {
+    const contractPath = dirPath + '/' + filename
+    if (!filename.endsWith('.ral')) {
+      throw new Error(`Invalid filename: ${contractPath}, smart contract file name should end with ".ral"`)
+    }
+
+    const sourceBuffer = await fsPromises.readFile(contractPath)
+    const sourceStr = sourceBuffer.toString()
+    const results = this.matchers.map((m) => m.match(sourceStr))
+    const matchNumber = results.reduce((a, b) => a + b, 0)
+    if (matchNumber === 0) {
+      throw new Error(`No contract defined in file: ${contractPath}`)
+    }
+    if (matchNumber > 1) {
+      throw new Error(`Multiple definitions in file: ${contractPath}`)
+    }
+    const matcherIndex = results.indexOf(1)
+    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[]> {
+    const loadDir = async function (dirPath: string, results: SourceFile[]): Promise<void> {
+      const dirents = await fsPromises.readdir(dirPath, { withFileTypes: true })
+      for (const dirent of dirents) {
+        if (dirent.isFile()) {
+          const file = await Project.loadSourceFile(dirPath, dirent.name)
+          results.push(file)
+        } else {
+          const newPath = dirPath + '/' + dirent.name
+          await loadDir(newPath, results)
+        }
+      }
     }
+    const sourceFiles: SourceFile[] = []
+    await loadDir(contractsRootPath, sourceFiles)
+    const contractAndScriptSize = sourceFiles.filter(
+      (f) => f.type === SourceType.Contract || f.type === SourceType.Script
+    ).length
+    if (sourceFiles.length === 0 || contractAndScriptSize === 0) {
+      throw new Error('Project have no source files')
+    }
+    return sourceFiles.sort((a, b) => a.type - b.type)
   }
 
-  protected static async _from<T extends { sourceCodeSha256: string }>(
-    provider: NodeProvider,
-    sourceFile: SourceFile,
-    loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>,
-    compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string) => Promise<T>
-  ): Promise<T> {
-    Common.checkFileNameExtension(sourceFile.contractPath)
-
-    const contractStr = await loadContractStr(sourceFile, [])
-    const contractHash = cryptojs.SHA256(contractStr).toString()
-    const existingContract = this._getArtifactFromCache(contractHash)
-    if (typeof existingContract !== 'undefined') {
-      return existingContract as unknown as T
+  static async build(contractsRootPath = 'contracts', artifactsRootPath = 'artifacts'): Promise<void> {
+    const provider = getCurrentNodeProvider()
+    const sourceFiles = await Project.loadSourceFiles(contractsRootPath)
+    const projectArtifact = await ProjectArtifact.from(artifactsRootPath)
+    if (typeof projectArtifact === 'undefined' || projectArtifact.sourceHasChanged(sourceFiles)) {
+      Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath)
     } else {
-      return compile(provider, sourceFile, contractStr, contractHash)
+      Project.currentProject = await Project.loadArtifacts(
+        provider,
+        sourceFiles,
+        projectArtifact,
+        contractsRootPath,
+        artifactsRootPath
+      )
     }
   }
+}
 
-  protected _saveToFile(sourceFile: SourceFile): Promise<void> {
-    const folder = Common._artifactsFolder() + sourceFile.dirPath
-    if (!fs.existsSync(folder)) {
-      fs.mkdirSync(folder, { recursive: true })
-    }
-    return fsPromises.writeFile(sourceFile.artifactPath, this.toString())
+export abstract class Artifact {
+  readonly typeId: string
+  readonly functions: FunctionSig[]
+
+  constructor(typeId: string, functions: FunctionSig[]) {
+    this.typeId = typeId
+    this.functions = functions
   }
 
   abstract buildByteCodeToDeploy(initialFields?: Fields): string
+
+  publicFunctions(): string[] {
+    return this.functions.filter((func) => func.isPublic).map((func) => func.name)
+  }
+
+  usingPreapprovedAssetsFunctions(): string[] {
+    return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name)
+  }
+
+  usingAssetsInContractFunctions(): string[] {
+    return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name)
+  }
 }
 
-export class Contract extends Common {
+export class Contract extends Artifact {
   readonly bytecode: string
   readonly codeHash: string
-  readonly fieldsSig: node.FieldsSig
-  readonly eventsSig: node.EventSig[]
+  readonly fieldsSig: FieldsSig
+  readonly eventsSig: EventSig[]
 
   constructor(
-    sourceCodeSha256: string,
+    typeId: string,
     bytecode: string,
     codeHash: string,
-    fieldsSig: node.FieldsSig,
-    eventsSig: node.EventSig[],
-    functions: node.FunctionSig[]
+    fieldsSig: FieldsSig,
+    eventsSig: EventSig[],
+    functions: FunctionSig[]
   ) {
-    super(sourceCodeSha256, functions)
+    super(typeId, functions)
     this.bytecode = bytecode
     this.codeHash = codeHash
     this.fieldsSig = fieldsSig
     this.eventsSig = eventsSig
   }
 
-  static checkCodeType(fileName: string, contractStr: string): void {
-    const interfaceMatches = contractStr.match(Contract.interfaceRegex)
-    const contractMatches = contractStr.match(Contract.contractRegex)
-    if (interfaceMatches === null && contractMatches === null) {
-      throw new Error(`No contract found in: ${fileName}`)
-    }
-    if (interfaceMatches && contractMatches) {
-      throw new Error(`Multiple contracts and interfaces in: ${fileName}`)
-    }
-    if (interfaceMatches === null) {
-      if (contractMatches !== null && contractMatches.length > 1) {
-        throw new Error(`Multiple contracts in: ${fileName}`)
-      }
-    }
-    if (contractMatches === null) {
-      if (interfaceMatches !== null && interfaceMatches.length > 1) {
-        throw new Error(`Multiple interfaces in: ${fileName}`)
-      }
-    }
-  }
-
-  private static async loadContractStr(sourceFile: SourceFile): Promise<string> {
-    return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code))
-  }
-
-  static async fromSource(provider: NodeProvider, path: string): Promise<Contract> {
-    if (!fs.existsSync(Common._artifactsFolder())) {
-      fs.mkdirSync(Common._artifactsFolder(), { recursive: true })
-    }
-    const sourceFile = this.getSourceFile(path, [])
-    const contract = await Common._from(
-      provider,
-      sourceFile,
-      (sourceFile) => Contract.loadContractStr(sourceFile),
-      Contract.compile
-    )
-    this._putArtifactToCache(contract)
-    return contract
-  }
-
-  private static async compile(
-    provider: NodeProvider,
-    sourceFile: SourceFile,
-    contractStr: string,
-    contractHash: string
-  ): Promise<Contract> {
-    const compiled = await provider.contracts.postContractsCompileContract({ code: contractStr })
-    const artifact = new Contract(
-      contractHash,
-      compiled.bytecode,
-      compiled.codeHash,
-      compiled.fields,
-      compiled.events,
-      compiled.functions
-    )
-    await artifact._saveToFile(sourceFile)
-    return artifact
-  }
-
   // TODO: safely parse json
   static fromJson(artifact: any): Contract {
     if (
-      artifact.sourceCodeSha256 == null ||
       artifact.bytecode == null ||
       artifact.codeHash == null ||
       artifact.fieldsSig == null ||
@@ -270,44 +462,44 @@ export class Contract extends Common {
       throw Error('The artifact JSON for contract is incomplete')
     }
     const contract = new Contract(
-      artifact.sourceCodeSha256,
+      artifact.typeId,
       artifact.bytecode,
       artifact.codeHash,
       artifact.fieldsSig,
       artifact.eventsSig,
       artifact.functions
     )
-    this._putArtifactToCache(contract)
     return contract
   }
 
+  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'
   static async fromArtifactFile(path: string): Promise<Contract> {
-    const sourceFile = this.getSourceFile(path, [])
-    const artifactPath = sourceFile.artifactPath
-    const content = await fsPromises.readFile(artifactPath)
+    const content = await fsPromises.readFile(path)
     const artifact = JSON.parse(content.toString())
     return Contract.fromJson(artifact)
   }
 
-  async fetchState(provider: NodeProvider, address: string, group: number): Promise<ContractState> {
-    const state = await provider.contracts.getContractsAddressState(address, { group: group })
+  async fetchState(address: string, group: number): Promise<ContractState> {
+    const state = await Project.currentProject.nodeProvider.contracts.getContractsAddressState(address, {
+      group: group
+    })
     return this.fromApiContractState(state)
   }
 
   override toString(): string {
-    return JSON.stringify(
-      {
-        sourceCodeSha256: this.sourceCodeSha256,
-        bytecode: this.bytecode,
-        codeHash: this.codeHash,
-        fieldsSig: this.fieldsSig,
-        eventsSig: this.eventsSig,
-        functions: this.functions
-      },
-      null,
-      2
-    )
+    const object = {
+      typeId: this.typeId,
+      bytecode: this.bytecode,
+      codeHash: this.codeHash,
+      fieldsSig: this.fieldsSig,
+      eventsSig: this.eventsSig,
+      functions: this.functions
+    }
+    return JSON.stringify(object, null, 2)
   }
 
   toState(fields: Fields, asset: Asset, address?: string): ContractState {
@@ -330,18 +522,17 @@ export class Contract extends Common {
   }
 
   private async _test(
-    provider: NodeProvider,
     funcName: string,
     params: TestContractParams,
     expectPublic: boolean,
     accessType: string
   ): Promise<TestContractResult> {
     const apiParams: node.TestContract = this.toTestContract(funcName, params)
-    const apiResult = await provider.contracts.postContractsTestContract(apiParams)
+    const apiResult = await Project.currentProject.nodeProvider.contracts.postContractsTestContract(apiParams)
 
     const methodIndex =
       typeof params.testMethodIndex !== 'undefined' ? params.testMethodIndex : this.getMethodIndex(funcName)
-    const isPublic = this.functions[`${methodIndex}`].signature.indexOf('pub ') !== -1
+    const isPublic = this.functions[`${methodIndex}`].isPublic
     if (isPublic === expectPublic) {
       const result = await this.fromTestContractResult(methodIndex, apiResult)
       return result
@@ -350,20 +541,12 @@ export class Contract extends Common {
     }
   }
 
-  async testPublicMethod(
-    provider: NodeProvider,
-    funcName: string,
-    params: TestContractParams
-  ): Promise<TestContractResult> {
-    return this._test(provider, funcName, params, true, 'public')
+  async testPublicMethod(funcName: string, params: TestContractParams): Promise<TestContractResult> {
+    return this._test(funcName, params, true, 'public')
   }
 
-  async testPrivateMethod(
-    provider: NodeProvider,
-    funcName: string,
-    params: TestContractParams
-  ): Promise<TestContractResult> {
-    return this._test(provider, funcName, params, false, 'private')
+  async testPrivateMethod(funcName: string, params: TestContractParams): Promise<TestContractResult> {
+    return this._test(funcName, params, false, 'private')
   }
 
   toApiFields(fields?: Fields): node.Val[] {
@@ -409,33 +592,8 @@ export class Contract extends Common {
     }
   }
 
-  static async fromCodeHash(codeHash: string): Promise<Contract> {
-    const cached = this._getArtifactFromCache(codeHash)
-    if (typeof cached !== 'undefined') {
-      return cached as Contract
-    }
-
-    const files = await fsPromises.readdir(Common._artifactsFolder())
-    for (const file of files) {
-      if (file.endsWith('.ral.json')) {
-        try {
-          const contract = await Contract.fromArtifactFile(file)
-          if (contract.codeHash === codeHash) {
-            return contract as Contract
-          }
-        } catch (_) {}
-      }
-    }
-
-    throw new Error(`Unknown code with code hash: ${codeHash}`)
-  }
-
-  static async getFieldsSig(state: node.ContractState): Promise<node.FieldsSig> {
-    return Contract.fromCodeHash(state.codeHash).then((contract) => contract.fieldsSig)
-  }
-
   async fromApiContractState(state: node.ContractState): Promise<ContractState> {
-    const contract = await Contract.fromCodeHash(state.codeHash)
+    const contract = Project.currentProject.contractByCodeHash(state.codeHash)
     return {
       address: state.address,
       contractId: binToHex(contractIdFromAddress(state.address)),
@@ -443,21 +601,19 @@ export class Contract extends Common {
       initialStateHash: state.initialStateHash,
       codeHash: state.codeHash,
       fields: fromApiFields(state.fields, contract.fieldsSig),
-      fieldsSig: await Contract.getFieldsSig(state),
+      fieldsSig: contract.fieldsSig,
       asset: fromApiAsset(state.asset)
     }
   }
 
-  static ContractCreatedEvent: node.EventSig = {
+  static ContractCreatedEvent: EventSig = {
     name: 'ContractCreated',
-    signature: 'event ContractCreated(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
 
-  static ContractDestroyedEvent: node.EventSig = {
+  static ContractDestroyedEvent: EventSig = {
     name: 'ContractDestroyed',
-    signature: 'event ContractDestroyed(address:Address)',
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
@@ -466,14 +622,14 @@ export class Contract extends Common {
     event: node.ContractEventByTxId,
     codeHash: string | undefined
   ): Promise<ContractEventByTxId> {
-    let eventSig: node.EventSig
+    let eventSig: EventSig
 
     if (event.eventIndex == -1) {
       eventSig = this.ContractCreatedEvent
     } else if (event.eventIndex == -2) {
       eventSig = this.ContractDestroyedEvent
     } else {
-      const contract = await Contract.fromCodeHash(codeHash!)
+      const contract = Project.currentProject.contractByCodeHash(codeHash!)
       eventSig = contract.eventsSig[event.eventIndex]
     }
 
@@ -541,85 +697,42 @@ export class Contract extends Common {
   }
 }
 
-export class Script extends Common {
+export class Script extends Artifact {
   readonly bytecodeTemplate: string
-  readonly fieldsSig: node.FieldsSig
+  readonly fieldsSig: FieldsSig
 
-  constructor(
-    sourceCodeSha256: string,
-    bytecodeTemplate: string,
-    fieldsSig: node.FieldsSig,
-    functions: node.FunctionSig[]
-  ) {
-    super(sourceCodeSha256, functions)
+  constructor(typeId: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
+    super(typeId, functions)
     this.bytecodeTemplate = bytecodeTemplate
     this.fieldsSig = fieldsSig
   }
 
-  static checkCodeType(fileName: string, contractStr: string): void {
-    const scriptMatches = contractStr.match(this.scriptRegex)
-    if (scriptMatches === null) {
-      throw new Error(`No script found in: ${fileName}`)
-    } else if (scriptMatches.length > 1) {
-      throw new Error(`Multiple scripts in: ${fileName}`)
-    } else {
-      return
-    }
-  }
-
-  private static async loadContractStr(sourceFile: SourceFile): Promise<string> {
-    return Common._loadContractStr(sourceFile, [], (code) => Script.checkCodeType(sourceFile.contractPath, code))
-  }
-
-  static async fromSource(provider: NodeProvider, path: string): Promise<Script> {
-    const sourceFile = this.getSourceFile(path, [])
-    return Common._from(provider, sourceFile, (sourceFile) => Script.loadContractStr(sourceFile), Script.compile)
-  }
-
-  private static async compile(
-    provider: NodeProvider,
-    sourceFile: SourceFile,
-    scriptStr: string,
-    contractHash: string
-  ): Promise<Script> {
-    const compiled = await provider.contracts.postContractsCompileScript({ code: scriptStr })
-    const artifact = new Script(contractHash, compiled.bytecodeTemplate, compiled.fields, compiled.functions)
-    await artifact._saveToFile(sourceFile)
-    return artifact
+  static fromCompileResult(typeId: string, result: CompileScriptResult): Script {
+    return new Script(typeId, result.bytecodeTemplate, result.fields, result.functions)
   }
 
   // TODO: safely parse json
   static fromJson(artifact: any): Script {
-    if (
-      artifact.sourceCodeSha256 == null ||
-      artifact.bytecodeTemplate == null ||
-      artifact.fieldsSig == null ||
-      artifact.functions == null
-    ) {
+    if (artifact.bytecodeTemplate == null || artifact.fieldsSig == null || artifact.functions == null) {
       throw Error('The artifact JSON for script is incomplete')
     }
-    return new Script(artifact.sourceCodeSha256, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
+    return new Script(artifact.typeId, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
   }
 
   static async fromArtifactFile(path: string): Promise<Script> {
-    const sourceFile = this.getSourceFile(path, [])
-    const artifactPath = sourceFile.artifactPath
-    const content = await fsPromises.readFile(artifactPath)
+    const content = await fsPromises.readFile(path)
     const artifact = JSON.parse(content.toString())
     return this.fromJson(artifact)
   }
 
   override toString(): string {
-    return JSON.stringify(
-      {
-        sourceCodeSha256: this.sourceCodeSha256,
-        bytecodeTemplate: this.bytecodeTemplate,
-        fieldsSig: this.fieldsSig,
-        functions: this.functions
-      },
-      null,
-      2
-    )
+    const object = {
+      typeId: this.typeId,
+      bytecodeTemplate: this.bytecodeTemplate,
+      fieldsSig: this.fieldsSig,
+      functions: this.functions
+    }
+    return JSON.stringify(object, null, 2)
   }
 
   async paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams> {
@@ -895,7 +1008,7 @@ export interface ContractState {
   initialStateHash?: string
   codeHash: string
   fields: Fields
-  fieldsSig: node.FieldsSig
+  fieldsSig: FieldsSig
   asset: Asset
 }
 
@@ -918,12 +1031,12 @@ function toApiContractState(state: ContractState): node.ContractState {
   }
 }
 
-function toApiFields(fields: Fields, fieldsSig: node.FieldsSig): node.Val[] {
+function toApiFields(fields: Fields, fieldsSig: FieldsSig): node.Val[] {
   return toApiVals(fields, fieldsSig.names, fieldsSig.types)
 }
 
-function toApiArgs(args: Arguments, funcSig: node.FunctionSig): node.Val[] {
-  return toApiVals(args, funcSig.argNames, funcSig.argTypes)
+function toApiArgs(args: Arguments, funcSig: FunctionSig): node.Val[] {
+  return toApiVals(args, funcSig.paramNames, funcSig.paramTypes)
 }
 
 function toApiVals(fields: Fields, names: string[], types: string[]): node.Val[] {