@alephium/web3 0.1.0 → 0.2.0-rc.10

package/src/contract/contract.ts

@@ -17,207 +17,517 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Buffer } from 'buffer/'
-import * as cryptojs from 'crypto-js'
-import * as crypto from 'crypto'
+import { webcrypto 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
+}
 
-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)
-      }
-      this._artifactCache.set(contract.codeHash, contract)
-    }
+export type CompilerOptions = node.CompilerOptions & {
+  errorOnWarnings: 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, ...DEFAULT_NODE_COMPILER_OPTIONS }
+
+class TypedMatcher<T extends SourceType> {
+  matcher: RegExp
+  type: T
+
+  constructor(pattern: string, type: T) {
+    this.matcher = new RegExp(pattern, 'mg')
+    this.type = type
   }
 
-  constructor(sourceCodeSha256: string, functions: node.FunctionSig[]) {
-    this.sourceCodeSha256 = sourceCodeSha256
-    this.functions = functions
+  match(str: string): number {
+    const results = str.match(this.matcher)
+    return results === null ? 0 : results.length
+  }
+}
+
+class SourceFile {
+  type: SourceType
+  contractPath: string
+  sourceCode: string
+  sourceCodeHash: string
+
+  getArtifactPath(artifactsRootPath: string): string {
+    return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json'
   }
 
-  protected static _contractPath(fileName: string): string {
-    if (fileName.endsWith('.json')) {
-      return `./contracts/${fileName.slice(0, -5)}`
-    } else {
-      return `./contracts/${fileName}`
+  constructor(type: SourceType, sourceCode: string, sourceCodeHash: string, contractPath: string) {
+    this.type = type
+    this.sourceCode = sourceCode
+    this.sourceCodeHash = sourceCodeHash
+    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> {
+  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'
+
+  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}`)
     }
   }
 
-  protected static _artifactPath(fileName: string): string {
-    if (fileName.endsWith('.json')) {
-      return `./artifacts/${fileName}`
-    } else {
-      return `./artifacts/${fileName}.json`
+  constructor(
+    compilerOptionsUsed: node.CompilerOptions,
+    infos: Map<string, { sourceCodeHash: string; warnings: string[] }>
+  ) {
+    ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed)
+    this.compilerOptionsUsed = compilerOptionsUsed
+    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)
+    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
+    }
+
+    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
+      }
+    }
+
+    return false
   }
 
-  protected static _artifactsFolder(): string {
-    return './artifacts/'
+  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 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)
   }
+}
 
-  protected static async _handleImports(contractStr: string, importsCache: string[]): Promise<string> {
-    const localImportsCache: string[] = []
-    let result = contractStr.replace(Common.importRegex, (match) => {
-      localImportsCache.push(match)
-      return ''
+export class Project {
+  sourceFiles: SourceFile[]
+  contracts: Compiled<Contract>[]
+  scripts: Compiled<Script>[]
+  projectArtifact: ProjectArtifact
+
+  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
+  ]
+
+  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
+      })
     })
-    for (const myImport of localImportsCache) {
-      const fileName = myImport.slice(8, -1)
-      if (!importsCache.includes(fileName)) {
-        importsCache.push(fileName)
-        const importContractStr = await Common._loadContractStr(fileName, importsCache, (code) =>
-          Contract.checkCodeType(fileName, code)
-        )
-        result = result.concat('\n', importContractStr)
+    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
+  ) {
+    this.nodeProvider = provider
+    this.contractsRootPath = contractsRootPath
+    this.artifactsRootPath = artifactsRootPath
+    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 {
+    return path.startsWith(`./${this.contractsRootPath}`)
+      ? path.slice(2)
+      : path.startsWith(this.contractsRootPath)
+      ? path
+      : this.contractsRootPath + '/' + path
+  }
+
+  static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void {
+    if (warnings.length !== 0) {
+      const prefixPerWarning = '  - '
+      const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning)
+      const output = `Compilation warnings:\n` + warningString + '\n'
+      if (errorOnWarnings) {
+        throw new Error(output)
+      } else {
+        console.log(output)
       }
     }
-    return result
   }
 
-  protected static async _loadContractStr(
-    fileName: string,
-    importsCache: string[],
-    validate: (fileName: string) => void
-  ): Promise<string> {
-    const contractPath = this._contractPath(fileName)
-    const contractBuffer = await fsPromises.readFile(contractPath)
-    const contractStr = contractBuffer.toString()
+  static contract(path: string): 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`)
+    }
+    return contract.artifact
+  }
+
+  static script(path: string): 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`)
+    }
+    return script.artifact
+  }
 
-    validate(contractStr)
-    return Common._handleImports(contractStr, importsCache)
+  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)
+    }
+    await this.projectArtifact.saveToFile(this.artifactsRootPath)
   }
 
-  static checkFileNameExtension(fileName: string): void {
-    if (!fileName.endsWith('.ral')) {
-      throw new Error('Smart contract file name should end with ".ral"')
+  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
   }
 
-  protected static async _from<T extends { sourceCodeSha256: string }>(
+  private static async compile(
     provider: NodeProvider,
-    fileName: string,
-    loadContractStr: (fileName: string, importsCache: string[]) => Promise<string>,
-    compile: (provider: NodeProvider, fileName: string, contractStr: string, contractHash: string) => Promise<T>
-  ): Promise<T> {
-    Common.checkFileNameExtension(fileName)
-
-    const contractStr = await loadContractStr(fileName, [])
-    const contractHash = cryptojs.SHA256(contractStr).toString()
-    const existingContract = this._getArtifactFromCache(contractHash)
-    if (typeof existingContract !== 'undefined') {
-      return existingContract as unknown as T
+    files: SourceFile[],
+    contractsRootPath: string,
+    artifactsRootPath: string,
+    errorOnWarnings: boolean,
+    compilerOptions: node.CompilerOptions
+  ): Promise<Project> {
+    const sourceStr = files.map((f) => f.sourceCode).join('\n')
+    const result = await provider.contracts.postContractsCompileProject({
+      code: sourceStr,
+      compilerOptions: compilerOptions
+    })
+    const contracts: Compiled<Contract>[] = []
+    const scripts: Compiled<Script>[] = []
+    result.contracts.forEach((contractResult, index) => {
+      const sourceFile = files[`${index}`]
+      const contract = Contract.fromCompileResult(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)
+      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
+    )
+    await project.saveArtifactsToFile()
+    return project
+  }
+
+  private static async loadArtifacts(
+    provider: NodeProvider,
+    files: SourceFile[],
+    projectArtifact: ProjectArtifact,
+    contractsRootPath: string,
+    artifactsRootPath: string,
+    errorOnWarnings: boolean,
+    compilerOptions: node.CompilerOptions
+  ): 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,
+        errorOnWarnings,
+        projectArtifact
+      )
+    } catch (error) {
+      console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`)
+      return Project.compile(provider, files, contractsRootPath, artifactsRootPath, errorOnWarnings, compilerOptions)
+    }
+  }
+
+  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 type = this.matchers[`${matcherIndex}`].type
+    return SourceFile.from(type, 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)
+  }
+
+  static async build(
+    compilerOptionsPartial: Partial<CompilerOptions> = {},
+    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
+      )
     } else {
-      return compile(provider, fileName, contractStr, contractHash)
+      console.log(`Load compiled contracts from folder "${artifactsRootPath}"`)
+      Project.currentProject = await Project.loadArtifacts(
+        provider,
+        sourceFiles,
+        projectArtifact,
+        contractsRootPath,
+        artifactsRootPath,
+        errorOnWarnings,
+        nodeCompilerOptions
+      )
     }
   }
+}
 
-  protected _saveToFile(fileName: string): Promise<void> {
-    const artifactPath = Common._artifactPath(fileName)
-    return fsPromises.writeFile(artifactPath, this.toString())
+export abstract class Artifact {
+  readonly functions: FunctionSig[]
+
+  constructor(functions: FunctionSig[]) {
+    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,
     bytecode: string,
     codeHash: string,
-    fieldsSig: node.FieldsSig,
-    eventsSig: node.EventSig[],
-    functions: node.FunctionSig[]
+    fieldsSig: FieldsSig,
+    eventsSig: EventSig[],
+    functions: FunctionSig[]
   ) {
-    super(sourceCodeSha256, functions)
+    super(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)
-    if (interfaceMatches) {
-      return
-    }
-
-    const contractMatches = contractStr.match(Contract.contractRegex)
-    if (contractMatches === null) {
-      throw new Error(`No contract found in: ${fileName}`)
-    } else if (contractMatches.length > 1) {
-      throw new Error(`Multiple contracts in: ${fileName}`)
-    } else {
-      return
-    }
-  }
-
-  private static async loadContractStr(fileName: string, importsCache: string[]): Promise<string> {
-    return Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code))
-  }
-
-  static async fromSource(provider: NodeProvider, fileName: string): Promise<Contract> {
-    if (!fs.existsSync(Common._artifactsFolder())) {
-      fs.mkdirSync(Common._artifactsFolder(), { recursive: true })
-    }
-    const contract = await Common._from(
-      provider,
-      fileName,
-      (fileName, importCaches) => Contract.loadContractStr(fileName, importCaches),
-      Contract.compile
-    )
-    this._putArtifactToCache(contract)
-    return contract
-  }
-
-  private static async compile(
-    provider: NodeProvider,
-    fileName: string,
-    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(fileName)
-    return artifact
-  }
-
   // TODO: safely parse json
   static fromJson(artifact: any): Contract {
     if (
-      artifact.sourceCodeSha256 == null ||
       artifact.bytecode == null ||
       artifact.codeHash == null ||
       artifact.fieldsSig == null ||
@@ -227,38 +537,42 @@ export class Contract extends Common {
       throw Error('The artifact JSON for contract is incomplete')
     }
     const contract = new Contract(
-      artifact.sourceCodeSha256,
       artifact.bytecode,
       artifact.codeHash,
       artifact.fieldsSig,
       artifact.eventsSig,
       artifact.functions
     )
-    this._putArtifactToCache(contract)
     return contract
   }
 
+  static fromCompileResult(result: CompileContractResult): Contract {
+    return new Contract(result.bytecode, result.codeHash, result.fields, result.events, result.functions)
+  }
+
   // support both 'code.ral' and 'code.ral.json'
-  static async fromArtifactFile(fileName: string): Promise<Contract> {
-    const artifactPath = Contract._artifactPath(fileName)
-    const content = await fsPromises.readFile(artifactPath)
+  static async fromArtifactFile(path: string): Promise<Contract> {
+    const content = await fsPromises.readFile(path)
     const artifact = JSON.parse(content.toString())
     return Contract.fromJson(artifact)
   }
 
+  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 = {
+      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 {
@@ -274,25 +588,26 @@ export class Contract extends Common {
     }
   }
 
+  // no need to be cryptographically strong random
   static randomAddress(): string {
-    const bytes = crypto.randomBytes(33)
+    const bytes = new Uint8Array(33)
+    crypto.getRandomValues(bytes)
     bytes[0] = 3
     return bs58.encode(bytes)
   }
 
   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
@@ -301,20 +616,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[] {
@@ -360,33 +667,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)),
@@ -394,21 +676,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']
   }
@@ -417,14 +697,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]
     }
 
@@ -492,88 +772,41 @@ 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(bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
+    super(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(fileName: string, importsCache: string[]): Promise<string> {
-    return Common._loadContractStr(fileName, importsCache, (code) => Script.checkCodeType(fileName, code))
-  }
-
-  static async fromSource(provider: NodeProvider, fileName: string): Promise<Script> {
-    return Common._from(
-      provider,
-      fileName,
-      (fileName, importsCache) => Script.loadContractStr(fileName, importsCache),
-      Script.compile
-    )
-  }
-
-  private static async compile(
-    provider: NodeProvider,
-    fileName: string,
-    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(fileName)
-    return artifact
+  static fromCompileResult(result: CompileScriptResult): Script {
+    return new Script(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.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
   }
 
-  static async fromArtifactFile(fileName: string): Promise<Script> {
-    const artifactPath = Common._artifactPath(fileName)
-    const content = await fsPromises.readFile(artifactPath)
+  static async fromArtifactFile(path: string): Promise<Script> {
+    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 = {
+      bytecodeTemplate: this.bytecodeTemplate,
+      fieldsSig: this.fieldsSig,
+      functions: this.functions
+    }
+    return JSON.stringify(object, null, 2)
   }
 
   async paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams> {
@@ -849,7 +1082,7 @@ export interface ContractState {
   initialStateHash?: string
   codeHash: string
   fields: Fields
-  fieldsSig: node.FieldsSig
+  fieldsSig: FieldsSig
   asset: Asset
 }
 
@@ -872,12 +1105,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[] {