@alephium/web3 0.40.0 → 0.42.0

package/src/contract/contract.ts

@@ -17,7 +17,6 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import { Buffer } from 'buffer/'
-import fs from 'fs'
 import { promises as fsPromises } from 'fs'
 import {
   fromApiNumber256,
@@ -34,9 +33,9 @@ import {
   getDefaultPrimitiveValue,
   PrimitiveTypes,
   decodeArrayType,
-  fromApiPrimitiveVal
+  fromApiPrimitiveVal,
+  tryGetCallResult
 } from '../api'
-import { CompileProjectResult } from '../api/api-alephium'
 import {
   SignDeployContractTxParams,
   SignDeployContractTxResult,
@@ -62,11 +61,9 @@ import {
   HexString
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
-import * as path from 'path'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import * as blake from 'blakejs'
-import { parseError } from '../utils/error'
 import { isContractDebugMessageEnabled } from '../debug'
 import {
   contract,
@@ -87,7 +84,7 @@ const crypto = new WebCrypto()
 export type FieldsSig = node.FieldsSig
 export type MapsSig = node.MapsSig
 export type EventSig = node.EventSig
-export type FunctionSig = node.FunctionSig
+export type FunctionSig = Omit<node.FunctionSig, 'isPublic' | 'usePreapprovedAssets' | 'useAssetsInContract'>
 export type Fields = NamedVals
 export type Arguments = NamedVals
 export type Constant = node.Constant
@@ -95,14 +92,6 @@ export type Enum = node.Enum
 
 export const StdIdFieldName = '__stdInterfaceId'
 
-enum SourceKind {
-  Contract = 0,
-  Script = 1,
-  AbstractContract = 2,
-  Interface = 3,
-  Struct = 4
-}
-
 export type CompilerOptions = node.CompilerOptions & {
   errorOnWarnings: boolean
 }
@@ -118,231 +107,6 @@ export const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions = {
 
 export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = { errorOnWarnings: true, ...DEFAULT_NODE_COMPILER_OPTIONS }
 
-class TypedMatcher<T extends SourceKind> {
-  matcher: RegExp
-  type: T
-
-  constructor(pattern: string, type: T) {
-    this.matcher = new RegExp(pattern, 'mg')
-    this.type = type
-  }
-}
-
-function removeParentsPrefix(parts: string[]): string {
-  let index = 0
-  for (let i = 0; i < parts.length; i++) {
-    if (parts[`${i}`] === '..') {
-      index += 1
-    } else {
-      break
-    }
-  }
-  return path.join(...parts.slice(index))
-}
-
-class SourceInfo {
-  type: SourceKind
-  name: string
-  contractRelativePath: string
-  sourceCode: string
-  sourceCodeHash: string
-  isExternal: boolean
-
-  getArtifactPath(artifactsRootDir: string): string {
-    let fullPath: string
-    if (this.isExternal) {
-      const relativePath = removeParentsPrefix(this.contractRelativePath.split(path.sep))
-      const externalPath = path.join('.external', relativePath)
-      fullPath = path.join(artifactsRootDir, externalPath)
-    } else {
-      fullPath = path.join(artifactsRootDir, this.contractRelativePath)
-    }
-    return path.join(path.dirname(fullPath), `${this.name}.ral.json`)
-  }
-
-  constructor(
-    type: SourceKind,
-    name: string,
-    sourceCode: string,
-    sourceCodeHash: string,
-    contractRelativePath: string,
-    isExternal: boolean
-  ) {
-    this.type = type
-    this.name = name
-    this.sourceCode = sourceCode
-    this.sourceCodeHash = sourceCodeHash
-    this.contractRelativePath = contractRelativePath
-    this.isExternal = isExternal
-  }
-
-  static async from(
-    type: SourceKind,
-    name: string,
-    sourceCode: string,
-    contractRelativePath: string,
-    isExternal: boolean
-  ): Promise<SourceInfo> {
-    const sourceCodeHash = await crypto.subtle.digest('SHA-256', Buffer.from(sourceCode))
-    const sourceCodeHashHex = Buffer.from(sourceCodeHash).toString('hex')
-    return new SourceInfo(type, name, sourceCode, sourceCodeHashHex, contractRelativePath, isExternal)
-  }
-}
-
-class Compiled<T extends Artifact> {
-  sourceInfo: SourceInfo
-  artifact: T
-  warnings: string[]
-
-  constructor(sourceInfo: SourceInfo, artifact: T, warnings: string[]) {
-    this.sourceInfo = sourceInfo
-    this.artifact = artifact
-    this.warnings = warnings
-  }
-}
-
-type CodeInfo = {
-  sourceFile: string
-  sourceCodeHash: string
-  bytecodeDebugPatch: string
-  codeHashDebug: string
-  warnings: string[]
-}
-
-type SourceInfoIndexes = {
-  sourceInfo: SourceInfo
-  startIndex: number
-  endIndex: number
-}
-
-function findSourceInfoAtLineNumber(sources: SourceInfo[], line: number): SourceInfoIndexes | undefined {
-  let currentLine = 0
-  const sourceInfosWithLine: SourceInfoIndexes[] = sources.map((source) => {
-    const startIndex = currentLine + 1
-    currentLine += source.sourceCode.split('\n').length
-    const endIndex = currentLine
-    return { sourceInfo: source, startIndex: startIndex, endIndex: endIndex }
-  })
-
-  const sourceInfo = sourceInfosWithLine.find((sourceInfoWithLine) => {
-    return line >= sourceInfoWithLine.startIndex && line <= sourceInfoWithLine.endIndex
-  })
-
-  return sourceInfo
-}
-
-export class ProjectArtifact {
-  static readonly artifactFileName = '.project.json'
-
-  fullNodeVersion: string
-  compilerOptionsUsed: node.CompilerOptions
-  infos: Map<string, CodeInfo>
-
-  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(fullNodeVersion: string, compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>) {
-    ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed)
-    this.fullNodeVersion = fullNodeVersion
-    this.compilerOptionsUsed = compilerOptionsUsed
-    this.infos = infos
-  }
-
-  static isCodeChanged(current: ProjectArtifact, previous: ProjectArtifact): boolean {
-    if (current.infos.size !== previous.infos.size) {
-      return true
-    }
-    for (const [name, codeInfo] of current.infos) {
-      const prevCodeInfo = previous.infos.get(name)
-      if (prevCodeInfo?.codeHashDebug !== codeInfo.codeHashDebug) {
-        return true
-      }
-    }
-    return false
-  }
-
-  async saveToFile(rootPath: string): Promise<void> {
-    const filepath = path.join(rootPath, ProjectArtifact.artifactFileName)
-    const artifact = {
-      fullNodeVersion: this.fullNodeVersion,
-      compilerOptionsUsed: this.compilerOptionsUsed,
-      infos: Object.fromEntries(new Map([...this.infos].sort()))
-    }
-    const content = JSON.stringify(artifact, null, 2)
-    return fsPromises.writeFile(filepath, content)
-  }
-
-  needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean {
-    ProjectArtifact.checkCompilerOptionsParameter(compilerOptions)
-    if (this.fullNodeVersion !== fullNodeVersion) {
-      return true
-    }
-
-    const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
-      const usedOption = this.compilerOptionsUsed[`${key}`]
-      return usedOption === inputOption
-    })
-    if (!optionsMatched) {
-      return true
-    }
-
-    if (sourceInfos.length !== this.infos.size) {
-      return true
-    }
-    for (const sourceInfo of sourceInfos) {
-      const info = this.infos.get(sourceInfo.name)
-      if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
-        return true
-      }
-    }
-
-    return false
-  }
-
-  static async from(rootPath: string): Promise<ProjectArtifact | undefined> {
-    const filepath = path.join(rootPath, ProjectArtifact.artifactFileName)
-    if (!fs.existsSync(filepath)) {
-      return undefined
-    }
-    try {
-      const content = await fsPromises.readFile(filepath)
-      const json = JSON.parse(content.toString())
-      const fullNodeVersion = json.fullNodeVersion as string
-      const compilerOptionsUsed = json.compilerOptionsUsed as node.CompilerOptions
-      const files = new Map(Object.entries<CodeInfo>(json.infos))
-      return new ProjectArtifact(fullNodeVersion, compilerOptionsUsed, files)
-    } catch (error) {
-      console.error(`Failed to load project artifact, error: ${error}`)
-      return undefined
-    }
-  }
-}
-
-function removeOldArtifacts(dir: string) {
-  const files = fs.readdirSync(dir)
-  files.forEach((file) => {
-    const filePath = path.join(dir, file)
-    const stat = fs.statSync(filePath)
-    if (stat.isDirectory()) {
-      removeOldArtifacts(filePath)
-    } else if (filePath.endsWith('.ral.json') || filePath.endsWith('.ral')) {
-      fs.unlinkSync(filePath)
-    }
-  })
-
-  if (fs.readdirSync(dir).length === 0) {
-    fs.rmdirSync(dir)
-  }
-}
-
 export class Struct {
   name: string
   fieldNames: string[]
@@ -377,491 +141,6 @@ export class Struct {
   }
 }
 
-export class Project {
-  sourceInfos: SourceInfo[]
-  contracts: Map<string, Compiled<Contract>>
-  scripts: Map<string, Compiled<Script>>
-  structs: Struct[]
-  projectArtifact: ProjectArtifact
-
-  readonly contractsRootDir: string
-  readonly artifactsRootDir: string
-
-  static currentProject: Project
-
-  static readonly importRegex = new RegExp('^import "[^"./]+/[^"]*[a-z][a-z_0-9]*(.ral)?"', 'mg')
-  static readonly abstractContractMatcher = new TypedMatcher<SourceKind>(
-    '^Abstract Contract ([A-Z][a-zA-Z0-9]*)',
-    SourceKind.AbstractContract
-  )
-  static readonly contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)', SourceKind.Contract)
-  static readonly interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*)', SourceKind.Interface)
-  static readonly scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)', SourceKind.Script)
-  static readonly structMatcher = new TypedMatcher('struct ([A-Z][a-zA-Z0-9]*)', SourceKind.Struct)
-  static readonly matchers = [
-    Project.abstractContractMatcher,
-    Project.contractMatcher,
-    Project.interfaceMatcher,
-    Project.scriptMatcher,
-    Project.structMatcher
-  ]
-
-  static buildProjectArtifact(
-    fullNodeVersion: string,
-    sourceInfos: SourceInfo[],
-    contracts: Map<string, Compiled<Contract>>,
-    scripts: Map<string, Compiled<Script>>,
-    compilerOptions: node.CompilerOptions
-  ): ProjectArtifact {
-    const files: Map<string, CodeInfo> = new Map()
-    contracts.forEach((c) => {
-      files.set(c.artifact.name, {
-        sourceFile: c.sourceInfo.contractRelativePath,
-        sourceCodeHash: c.sourceInfo.sourceCodeHash,
-        bytecodeDebugPatch: c.artifact.bytecodeDebugPatch,
-        codeHashDebug: c.artifact.codeHashDebug,
-        warnings: c.warnings
-      })
-    })
-    scripts.forEach((s) => {
-      files.set(s.artifact.name, {
-        sourceFile: s.sourceInfo.contractRelativePath,
-        sourceCodeHash: s.sourceInfo.sourceCodeHash,
-        bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
-        codeHashDebug: '',
-        warnings: s.warnings
-      })
-    })
-    const compiledSize = contracts.size + scripts.size
-    sourceInfos.slice(compiledSize).forEach((c) => {
-      files.set(c.name, {
-        sourceFile: c.contractRelativePath,
-        sourceCodeHash: c.sourceCodeHash,
-        bytecodeDebugPatch: '',
-        codeHashDebug: '',
-        warnings: []
-      })
-    })
-    return new ProjectArtifact(fullNodeVersion, compilerOptions, files)
-  }
-
-  private constructor(
-    contractsRootDir: string,
-    artifactsRootDir: string,
-    sourceInfos: SourceInfo[],
-    contracts: Map<string, Compiled<Contract>>,
-    scripts: Map<string, Compiled<Script>>,
-    structs: Struct[],
-    errorOnWarnings: boolean,
-    projectArtifact: ProjectArtifact
-  ) {
-    this.contractsRootDir = contractsRootDir
-    this.artifactsRootDir = artifactsRootDir
-    this.sourceInfos = sourceInfos
-    this.contracts = contracts
-    this.scripts = scripts
-    this.structs = structs
-    this.projectArtifact = projectArtifact
-
-    if (errorOnWarnings) {
-      Project.checkCompilerWarnings(
-        [
-          ...[...contracts.entries()].map((c) => c[1].warnings).flat(),
-          ...[...scripts.entries()].map((s) => s[1].warnings).flat()
-        ],
-        errorOnWarnings
-      )
-    }
-  }
-
-  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)
-      }
-    }
-  }
-
-  static contract(name: string): Contract {
-    const contract = Project.currentProject.contracts.get(name)
-    if (typeof contract === 'undefined') {
-      throw new Error(`Contract "${name}" does not exist`)
-    }
-    return contract.artifact
-  }
-
-  static script(name: string): Script {
-    const script = Project.currentProject.scripts.get(name)
-    if (typeof script === 'undefined') {
-      throw new Error(`Script "${name}" does not exist`)
-    }
-    return script.artifact
-  }
-
-  private static async loadStructs(artifactsRootDir: string): Promise<Struct[]> {
-    const filePath = path.join(artifactsRootDir, 'structs.ral.json')
-    if (!fs.existsSync(filePath)) return []
-    const content = await fsPromises.readFile(filePath)
-    const json = JSON.parse(content.toString())
-    if (!Array.isArray(json)) {
-      throw Error(`Invalid structs JSON: ${content}`)
-    }
-    return Array.from(json).map((item) => Struct.fromJson(item))
-  }
-
-  private async saveStructsToFile(): Promise<void> {
-    if (this.structs.length === 0) return
-    const structs = this.structs.map((s) => s.toJson())
-    const filePath = path.join(this.artifactsRootDir, 'structs.ral.json')
-    return fsPromises.writeFile(filePath, JSON.stringify(structs, null, 2))
-  }
-
-  private async saveArtifactsToFile(projectRootDir: string): Promise<void> {
-    const artifactsRootDir = this.artifactsRootDir
-    const saveToFile = async function (compiled: Compiled<Artifact>): Promise<void> {
-      const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir)
-      const dirname = path.dirname(artifactPath)
-      if (!fs.existsSync(dirname)) {
-        fs.mkdirSync(dirname, { recursive: true })
-      }
-      return fsPromises.writeFile(artifactPath, compiled.artifact.toString())
-    }
-    this.contracts.forEach((contract) => saveToFile(contract))
-    this.scripts.forEach((script) => saveToFile(script))
-    this.saveStructsToFile()
-    await this.projectArtifact.saveToFile(projectRootDir)
-  }
-
-  contractByCodeHash(codeHash: string): Contract {
-    const contract = [...this.contracts.values()].find(
-      (c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash
-    )
-    if (typeof contract === 'undefined') {
-      throw new Error(`Unknown code with code hash: ${codeHash}`)
-    }
-    return contract.artifact
-  }
-
-  private static async getCompileResult(
-    provider: NodeProvider,
-    compilerOptions: node.CompilerOptions,
-    sources: SourceInfo[]
-  ): Promise<CompileProjectResult> {
-    try {
-      const sourceStr = sources.map((f) => f.sourceCode).join('\n')
-      return await provider.contracts.postContractsCompileProject({
-        code: sourceStr,
-        compilerOptions: compilerOptions
-      })
-    } catch (error) {
-      if (!(error instanceof Error)) {
-        throw error
-      }
-
-      const parsed = parseError(error.message)
-      if (!parsed) {
-        throw error
-      }
-
-      const sourceInfo = findSourceInfoAtLineNumber(sources, parsed.lineStart)
-      if (!sourceInfo) {
-        throw error
-      }
-
-      const shiftIndex = parsed.lineStart - sourceInfo.startIndex + 1
-      const newError = parsed.reformat(shiftIndex, sourceInfo.sourceInfo.contractRelativePath)
-      throw new Error(newError)
-    }
-  }
-
-  private static async compile(
-    fullNodeVersion: string,
-    provider: NodeProvider,
-    sourceInfos: SourceInfo[],
-    projectRootDir: string,
-    contractsRootDir: string,
-    artifactsRootDir: string,
-    errorOnWarnings: boolean,
-    compilerOptions: node.CompilerOptions
-  ): Promise<Project> {
-    const removeDuplicates = sourceInfos.reduce((acc: SourceInfo[], sourceInfo: SourceInfo) => {
-      if (acc.find((info) => info.sourceCodeHash === sourceInfo.sourceCodeHash) === undefined) {
-        acc.push(sourceInfo)
-      }
-      return acc
-    }, [])
-
-    const result = await Project.getCompileResult(provider, compilerOptions, removeDuplicates)
-    const contracts = new Map<string, Compiled<Contract>>()
-    const scripts = new Map<string, Compiled<Script>>()
-    const structs = result.structs === undefined ? [] : result.structs.map((item) => Struct.fromStructSig(item))
-    result.contracts.forEach((contractResult) => {
-      const sourceInfo = sourceInfos.find(
-        (sourceInfo) => sourceInfo.type === SourceKind.Contract && sourceInfo.name === contractResult.name
-      )
-      if (sourceInfo === undefined) {
-        // this should never happen
-        throw new Error(`SourceInfo does not exist for contract ${contractResult.name}`)
-      }
-      const contract = Contract.fromCompileResult(contractResult, structs)
-      contracts.set(contract.name, new Compiled(sourceInfo, contract, contractResult.warnings))
-    })
-    result.scripts.forEach((scriptResult) => {
-      const sourceInfo = sourceInfos.find(
-        (sourceInfo) => sourceInfo.type === SourceKind.Script && sourceInfo.name === scriptResult.name
-      )
-      if (sourceInfo === undefined) {
-        // this should never happen
-        throw new Error(`SourceInfo does not exist for script ${scriptResult.name}`)
-      }
-      const script = Script.fromCompileResult(scriptResult, structs)
-      scripts.set(script.name, new Compiled(sourceInfo, script, scriptResult.warnings))
-    })
-    const projectArtifact = Project.buildProjectArtifact(
-      fullNodeVersion,
-      sourceInfos,
-      contracts,
-      scripts,
-      compilerOptions
-    )
-    const project = new Project(
-      contractsRootDir,
-      artifactsRootDir,
-      sourceInfos,
-      contracts,
-      scripts,
-      structs,
-      errorOnWarnings,
-      projectArtifact
-    )
-    await project.saveArtifactsToFile(projectRootDir)
-    return project
-  }
-
-  private static async loadArtifacts(
-    provider: NodeProvider,
-    sourceInfos: SourceInfo[],
-    projectArtifact: ProjectArtifact,
-    projectRootDir: string,
-    contractsRootDir: string,
-    artifactsRootDir: string,
-    errorOnWarnings: boolean,
-    compilerOptions: node.CompilerOptions
-  ): Promise<Project> {
-    try {
-      const contracts = new Map<string, Compiled<Contract>>()
-      const scripts = new Map<string, Compiled<Script>>()
-      const structs = await Project.loadStructs(artifactsRootDir)
-      for (const sourceInfo of sourceInfos) {
-        const info = projectArtifact.infos.get(sourceInfo.name)
-        if (typeof info === 'undefined') {
-          throw Error(`Unable to find project info for ${sourceInfo.name}, please rebuild the project`)
-        }
-        const warnings = info.warnings
-        const artifactDir = sourceInfo.getArtifactPath(artifactsRootDir)
-        if (sourceInfo.type === SourceKind.Contract) {
-          const artifact = await Contract.fromArtifactFile(
-            artifactDir,
-            info.bytecodeDebugPatch,
-            info.codeHashDebug,
-            structs
-          )
-          contracts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings))
-        } else if (sourceInfo.type === SourceKind.Script) {
-          const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, structs)
-          scripts.set(artifact.name, new Compiled(sourceInfo, artifact, warnings))
-        }
-      }
-
-      return new Project(
-        contractsRootDir,
-        artifactsRootDir,
-        sourceInfos,
-        contracts,
-        scripts,
-        structs,
-        errorOnWarnings,
-        projectArtifact
-      )
-    } catch (error) {
-      console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`)
-      return Project.compile(
-        projectArtifact.fullNodeVersion,
-        provider,
-        sourceInfos,
-        projectRootDir,
-        contractsRootDir,
-        artifactsRootDir,
-        errorOnWarnings,
-        compilerOptions
-      )
-    }
-  }
-
-  private static getImportSourcePath(projectRootDir: string, importPath: string): string {
-    const parts = importPath.split('/')
-    if (parts.length > 1 && parts[0] === 'std') {
-      const currentDir = path.dirname(__filename)
-      return path.join(...[currentDir, '..', '..', '..', importPath])
-    }
-    let moduleDir = projectRootDir
-    while (true) {
-      const expectedPath = path.join(...[moduleDir, 'node_modules', importPath])
-      if (fs.existsSync(expectedPath)) {
-        return expectedPath
-      }
-      const oldModuleDir = moduleDir
-      moduleDir = path.join(moduleDir, '..')
-      if (oldModuleDir === moduleDir) {
-        throw new Error(`Specified import file does not exist: ${importPath}`)
-      }
-    }
-  }
-
-  private static async handleImports(
-    projectRootDir: string,
-    contractRootDir: string,
-    sourceStr: string,
-    importsCache: string[]
-  ): Promise<[string, SourceInfo[]]> {
-    const localImportsCache: string[] = []
-    const result = sourceStr.replace(Project.importRegex, (match) => {
-      localImportsCache.push(match)
-      return ''
-    })
-    const externalSourceInfos: SourceInfo[] = []
-    for (const myImport of localImportsCache) {
-      const originImportPath = myImport.slice(8, -1)
-      const importPath = originImportPath.endsWith('.ral') ? originImportPath : originImportPath + '.ral'
-      if (!importsCache.includes(importPath)) {
-        importsCache.push(importPath)
-        const sourcePath = Project.getImportSourcePath(projectRootDir, importPath)
-        const sourceInfos = await Project.loadSourceFile(
-          projectRootDir,
-          contractRootDir,
-          sourcePath,
-          importsCache,
-          true
-        )
-        externalSourceInfos.push(...sourceInfos)
-      }
-    }
-    return [result, externalSourceInfos]
-  }
-
-  private static async loadSourceFile(
-    projectRootDir: string,
-    contractsRootDir: string,
-    sourcePath: string,
-    importsCache: string[],
-    isExternal: boolean
-  ): Promise<SourceInfo[]> {
-    const contractRelativePath = path.relative(contractsRootDir, sourcePath)
-    if (!sourcePath.endsWith('.ral')) {
-      throw new Error(`Invalid filename: ${sourcePath}, smart contract file name should end with ".ral"`)
-    }
-
-    const sourceBuffer = await fsPromises.readFile(sourcePath)
-    const [sourceStr, externalSourceInfos] = await Project.handleImports(
-      projectRootDir,
-      contractsRootDir,
-      sourceBuffer.toString(),
-      importsCache
-    )
-    if (sourceStr.match(new RegExp('^import "', 'mg')) !== null) {
-      throw new Error(`Invalid import statements, source: ${sourcePath}`)
-    }
-    const sourceInfos = externalSourceInfos
-    for (const matcher of this.matchers) {
-      const results = sourceStr.matchAll(matcher.matcher)
-      for (const result of results) {
-        const sourceInfo = await SourceInfo.from(matcher.type, result[1], sourceStr, contractRelativePath, isExternal)
-        sourceInfos.push(sourceInfo)
-      }
-    }
-    return sourceInfos
-  }
-
-  private static async loadSourceFiles(projectRootDir: string, contractsRootDir: string): Promise<SourceInfo[]> {
-    const importsCache: string[] = []
-    const sourceInfos: SourceInfo[] = []
-    const loadDir = async function (dirPath: string): Promise<void> {
-      const dirents = await fsPromises.readdir(dirPath, { withFileTypes: true })
-      for (const dirent of dirents) {
-        if (dirent.isFile()) {
-          const sourcePath = path.join(dirPath, dirent.name)
-          const infos = await Project.loadSourceFile(projectRootDir, contractsRootDir, sourcePath, importsCache, false)
-          sourceInfos.push(...infos)
-        } else {
-          const newPath = path.join(dirPath, dirent.name)
-          await loadDir(newPath)
-        }
-      }
-    }
-    await loadDir(contractsRootDir)
-    const contractAndScriptSize = sourceInfos.filter(
-      (f) => f.type === SourceKind.Contract || f.type === SourceKind.Script
-    ).length
-    if (sourceInfos.length === 0 || contractAndScriptSize === 0) {
-      throw new Error('Project have no source files')
-    }
-    return sourceInfos.sort((a, b) => a.type - b.type)
-  }
-
-  static readonly DEFAULT_CONTRACTS_DIR = 'contracts'
-  static readonly DEFAULT_ARTIFACTS_DIR = 'artifacts'
-
-  static async build(
-    compilerOptionsPartial: Partial<CompilerOptions> = {},
-    projectRootDir = '.',
-    contractsRootDir = Project.DEFAULT_CONTRACTS_DIR,
-    artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR,
-    defaultFullNodeVersion: string | undefined = undefined
-  ): Promise<void> {
-    const provider = getCurrentNodeProvider()
-    const fullNodeVersion = defaultFullNodeVersion ?? (await provider.infos.getInfosVersion()).version
-    const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir)
-    const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
-    const projectArtifact = await ProjectArtifact.from(projectRootDir)
-    if (
-      projectArtifact === undefined ||
-      projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles, fullNodeVersion)
-    ) {
-      if (fs.existsSync(artifactsRootDir)) {
-        removeOldArtifacts(artifactsRootDir)
-      }
-      console.log(`Compiling contracts in folder "${contractsRootDir}"`)
-      Project.currentProject = await Project.compile(
-        fullNodeVersion,
-        provider,
-        sourceFiles,
-        projectRootDir,
-        contractsRootDir,
-        artifactsRootDir,
-        errorOnWarnings,
-        nodeCompilerOptions
-      )
-    } else {
-      console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`)
-      Project.currentProject = await Project.loadArtifacts(
-        provider,
-        sourceFiles,
-        projectArtifact,
-        projectRootDir,
-        contractsRootDir,
-        artifactsRootDir,
-        errorOnWarnings,
-        nodeCompilerOptions
-      )
-    }
-  }
-}
-
 export abstract class Artifact {
   readonly version: string
   readonly name: string
@@ -875,18 +154,6 @@ export abstract class Artifact {
 
   abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): 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)
-  }
-
   async isDevnet(signer: SignerProvider): Promise<boolean> {
     if (!signer.nodeProvider) {
       return false
@@ -896,6 +163,16 @@ export abstract class Artifact {
   }
 }
 
+function fromFunctionSig(sig: node.FunctionSig): FunctionSig {
+  return {
+    name: sig.name,
+    paramNames: sig.paramNames,
+    paramTypes: sig.paramTypes,
+    paramIsMutable: sig.paramIsMutable,
+    returnTypes: sig.returnTypes
+  }
+}
+
 export class Contract extends Artifact {
   readonly bytecode: string
   readonly bytecodeDebugPatch: string
@@ -910,6 +187,7 @@ export class Contract extends Artifact {
 
   readonly bytecodeDebug: string
   readonly codeHashDebug: string
+  readonly decodedMethods: Method[]
 
   constructor(
     version: string,
@@ -941,6 +219,20 @@ export class Contract extends Artifact {
 
     this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
     this.codeHashDebug = codeHashDebug
+
+    this.decodedMethods = contract.contractCodec.decodeContract(Buffer.from(bytecode, 'hex')).methods
+  }
+
+  publicFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].isPublic)
+  }
+
+  usingPreapprovedAssetsFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].usePreapprovedAssets)
+  }
+
+  usingAssetsInContractFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].useContractAssets)
   }
 
   // TODO: safely parse json
@@ -987,7 +279,7 @@ export class Contract extends Artifact {
       result.codeHashDebug,
       result.fields,
       result.events,
-      result.functions,
+      result.functions.map(fromFunctionSig),
       result.constants,
       result.enums,
       structs,
@@ -1144,11 +436,9 @@ export class Contract extends Artifact {
 
   static fromApiContractState(
     state: node.ContractState,
-    getContractByCodeHash?: (codeHash: string) => Contract
+    getContractByCodeHash: (codeHash: string) => Contract
   ): ContractState {
-    const contract = getContractByCodeHash
-      ? getContractByCodeHash(state.codeHash)
-      : Project.currentProject.contractByCodeHash(state.codeHash)
+    const contract = getContractByCodeHash(state.codeHash)
     return contract.fromApiContractState(state)
   }
 
@@ -1170,7 +460,7 @@ export class Contract extends Artifact {
     event: node.ContractEventByTxId,
     codeHash: string | undefined,
     txId: string,
-    getContractByCodeHash?: (codeHash: string) => Contract
+    getContractByCodeHash: (codeHash: string) => Contract
   ): ContractEvent {
     let fields: Fields
     let name: string
@@ -1182,9 +472,7 @@ export class Contract extends Artifact {
       fields = fromApiEventFields(event.fields, Contract.ContractDestroyedEvent, true)
       name = Contract.ContractDestroyedEvent.name
     } else {
-      const contract = getContractByCodeHash
-        ? getContractByCodeHash(codeHash!)
-        : Project.currentProject.contractByCodeHash(codeHash!)
+      const contract = getContractByCodeHash(codeHash!)
       const eventSig = contract.eventsSig[event.eventIndex]
       fields = fromApiEventFields(event.fields, eventSig)
       name = eventSig.name
@@ -1203,7 +491,8 @@ export class Contract extends Artifact {
   fromApiTestContractResult(
     methodName: string,
     result: node.TestContractResult,
-    txId: string
+    txId: string,
+    getContractByCodeHash: (codeHash: string) => Contract
   ): TestContractResult<unknown> {
     const methodIndex = this.functions.findIndex((sig) => sig.name === methodName)
     const returnTypes = this.functions[`${methodIndex}`].returnTypes
@@ -1218,9 +507,9 @@ export class Contract extends Artifact {
       contractAddress: result.address,
       returns: returns,
       gasUsed: result.gasUsed,
-      contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract)),
+      contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract, getContractByCodeHash)),
       txOutputs: result.txOutputs.map(fromApiOutput),
-      events: Contract.fromApiEvents(result.events, addressToCodeHash, txId),
+      events: Contract.fromApiEvents(result.events, addressToCodeHash, txId, getContractByCodeHash),
       debugMessages: result.debugMessages
     }
   }
@@ -1264,7 +553,7 @@ export class Contract extends Artifact {
     events: node.ContractEventByTxId[],
     addressToCodeHash: Map<string, string>,
     txId: string,
-    getContractByCodeHash?: (codeHash: string) => Contract
+    getContractByCodeHash: (codeHash: string) => Contract
   ): ContractEvent[] {
     return events.map((event) => {
       const contractAddress = event.contractAddress
@@ -1298,7 +587,7 @@ export class Contract extends Artifact {
     result: node.CallContractResult,
     txId: string,
     methodIndex: number,
-    getContractByCodeHash?: (codeHash: string) => Contract
+    getContractByCodeHash: (codeHash: string) => Contract
   ): CallContractResult<unknown> {
     const returnTypes = this.functions[`${methodIndex}`].returnTypes
     const callResult = tryGetCallResult(result)
@@ -1348,7 +637,7 @@ export class Script extends Artifact {
       result.bytecodeTemplate,
       result.bytecodeDebugPatch,
       result.fields,
-      result.functions,
+      result.functions.map(fromFunctionSig),
       structs
     )
   }
@@ -1831,14 +1120,14 @@ export function subscribeEventsFromContract<T extends Fields, M extends Contract
   decodeFunc: (event: node.ContractEvent) => M,
   fromCount?: number
 ): EventSubscription {
-  const messageCallback = (event: node.ContractEvent): Promise<void> => {
+  const messageCallback = (event: node.ContractEvent) => {
     if (event.eventIndex !== eventIndex) {
       return Promise.resolve()
     }
     return options.messageCallback(decodeFunc(event))
   }
 
-  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
+  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>) => {
     return options.errorCallback(err, subscription as unknown as Subscription<M>)
   }
   const opt: EventSubscribeOptions<node.ContractEvent> = {
@@ -1877,7 +1166,9 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
   const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs)
   const loadImmFieldByIndex: Method = {
     isPublic: true,
-    assetModifier: 0,
+    usePreapprovedAssets: false,
+    useContractAssets: false,
+    usePayToContractOnly: false,
     argsLength: 1,
     localsLength: 1,
     returnLength: 1,
@@ -1905,7 +1196,9 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
   }
   const destroy: Method = {
     isPublic: true,
-    assetModifier: 2,
+    usePreapprovedAssets: false,
+    useContractAssets: true,
+    usePayToContractOnly: false,
     argsLength: 1,
     localsLength: 1,
     returnLength: 0,
@@ -1980,7 +1273,8 @@ export async function testMethod<
 >(
   factory: ContractFactory<I, F>,
   methodName: string,
-  params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>
+  params: Optional<TestContractParams<F, A, M>, 'testArgs' | 'initialFields'>,
+  getContractByCodeHash: (codeHash: string) => Contract
 ): Promise<TestContractResult<R, M>> {
   const txId = params?.txId ?? randomTxId()
   const contract = factory.contract
@@ -1999,7 +1293,7 @@ export async function testMethod<
   })
   const apiResult = await getCurrentNodeProvider().contracts.postContractsTestContract(apiParams)
   const maps = existingContractsToMaps(contract, address, group, apiResult, initialMaps)
-  const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId)
+  const testResult = contract.fromApiTestContractResult(methodName, apiResult, txId, getContractByCodeHash)
   contract.printDebugMessages(methodName, testResult.debugMessages)
   return {
     ...testResult,
@@ -2008,24 +1302,36 @@ export async function testMethod<
 }
 
 export class RalphMap<K extends Val, V extends Val> {
+  private readonly groupIndex: number
   constructor(
     private readonly parentContract: Contract,
-    private readonly parentInstance: ContractInstance,
+    private readonly parentContractId: HexString,
     private readonly mapName: string
-  ) {}
+  ) {
+    this.groupIndex = groupOfAddress(addressFromContractId(parentContractId))
+  }
 
   async get(key: K): Promise<V | undefined> {
-    return getMapItem(this.parentContract, this.parentInstance, this.mapName, key)
+    return getMapItem(this.parentContract, this.parentContractId, this.groupIndex, this.mapName, key)
   }
 
   async contains(key: K): Promise<boolean> {
     return this.get(key).then((v) => v !== undefined)
   }
+
+  toJSON() {
+    return {
+      parentContractId: this.parentContractId,
+      mapName: this.mapName,
+      groupIndex: this.groupIndex
+    }
+  }
 }
 
 export async function getMapItem<R extends Val>(
   parentContract: Contract,
-  parentInstance: ContractInstance,
+  parentContractId: HexString,
+  groupIndex: number,
   mapName: string,
   key: Val
 ): Promise<R | undefined> {
@@ -2035,13 +1341,7 @@ export async function getMapItem<R extends Val>(
     throw new Error(`Map ${mapName} does not exist in contract ${parentContract.name}`)
   }
   const [keyType, valueType] = ralph.parseMapType(mapType)
-  const mapItemContractId = calcWrapperContractId(
-    parentInstance.contractId,
-    index!,
-    key,
-    keyType,
-    parentInstance.groupIndex
-  )
+  const mapItemContractId = calcWrapperContractId(parentContractId, index!, key, keyType, groupIndex)
   const mapItemAddress = addressFromContractId(mapItemContractId)
   try {
     const state = await getCurrentNodeProvider().contracts.getContractsAddressState(mapItemAddress)
@@ -2271,13 +1571,13 @@ export function subscribeContractEvents(
   options: EventSubscribeOptions<ContractEvent<any>>,
   fromCount?: number
 ): EventSubscription {
-  const messageCallback = (event: node.ContractEvent): Promise<void> => {
+  const messageCallback = (event: node.ContractEvent) => {
     return options.messageCallback({
       ...decodeEvent(contract, instance, event, event.eventIndex),
       contractAddress: instance.address
     })
   }
-  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
+  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>) => {
     return options.errorCallback(err, subscription as unknown as Subscription<ContractEvent<any>>)
   }
   const opt: EventSubscribeOptions<node.ContractEvent> = {
@@ -2294,7 +1594,7 @@ export async function callMethod<I extends ContractInstance, F extends Fields, A
   instance: ContractInstance,
   methodName: string,
   params: Optional<CallContractParams<A>, 'args'>,
-  getContractByCodeHash?: (codeHash: string) => Contract
+  getContractByCodeHash: (codeHash: string) => Contract
 ): Promise<CallContractResult<R>> {
   const methodIndex = contract.contract.getMethodIndex(methodName)
   const txId = params?.txId ?? randomTxId()
@@ -2314,7 +1614,7 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
   calls: Record<string, Optional<CallContractParams<any>, 'args'>>,
-  getContractByCodeHash?: (codeHash: string) => Contract
+  getContractByCodeHash: (codeHash: string) => Contract
 ): Promise<Record<string, CallContractResult<any>>> {
   const callEntries = Object.entries(calls)
   const callsParams = callEntries.map((entry) => {
@@ -2369,10 +1669,3 @@ export const getContractIdFromUnsignedTx = async (
 
 // This function only works in the simple case where a single non-subcontract is created in the tx
 export const getTokenIdFromUnsignedTx = getContractIdFromUnsignedTx
-
-export function tryGetCallResult(result: node.CallContractResult): node.CallContractSucceeded {
-  if (result.type === 'CallContractFailed') {
-    throw new Error(`Failed to call contract, error: ${(result as node.CallContractFailed).error}`)
-  }
-  return result as node.CallContractSucceeded
-}