@alephium/web3 0.2.0-test.0 → 0.2.0

package/src/contract/contract.ts

@@ -17,250 +17,560 @@ 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 { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer'
+import {
+  fromApiArray,
+  fromApiNumber256,
+  toApiNumber256,
+  NamedVals,
+  node,
+  NodeProvider,
+  Number256,
+  toApiToken,
+  toApiVal,
+  Token,
+  Val,
+  fromApiTokens,
+  fromApiVals
+} from '../api'
+import {
+  SignDeployContractTxParams,
+  SignExecuteScriptTxParams,
+  SignerProvider,
+  SignExecuteScriptTxResult,
+  SignDeployContractTxResult
+} from '../signer'
 import * as ralph from './ralph'
 import { bs58, binToHex, contractIdFromAddress, assertType, Eq } from '../utils'
+import { getCurrentNodeProvider } from '../global'
+import { web3 } from '..'
+
+export type FieldsSig = node.FieldsSig
+export type EventSig = node.EventSig
+export type FunctionSig = node.FunctionSig
+export type Fields = NamedVals
+export type Arguments = NamedVals
+
+enum SourceType {
+  Contract = 0,
+  Script = 1,
+  AbstractContract = 2,
+  Interface = 3
+}
+
+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
+  }
+
+  match(str: string): number {
+    const results = str.match(this.matcher)
+    return results === null ? 0 : results.length
+  }
+}
 
 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'
-    }
+  type: SourceType
+  contractPath: string
+  sourceCode: string
+  sourceCodeHash: string
+
+  getArtifactPath(artifactsRootDir: string): string {
+    return artifactsRootDir + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json'
+  }
+
+  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)
   }
 }
 
-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)
+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
+  }
+}
+
+type CodeInfo = { sourceCodeHash: string; bytecodeDebugPatch: string; codeHashDebug: string; warnings: string[] }
+
+class ProjectArtifact {
+  static readonly artifactFileName = '.project.json'
+
+  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(sourceCodeSha256: string, functions: node.FunctionSig[]) {
-    this.sourceCodeSha256 = sourceCodeSha256
-    this.functions = functions
+  constructor(compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>) {
+    ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed)
+    this.compilerOptionsUsed = compilerOptionsUsed
+    this.infos = infos
   }
 
-  protected static _artifactsFolder(): string {
-    return './artifacts/'
+  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)
   }
 
-  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)
+  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
     }
-    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)
-        }
+
+    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
+  }
+
+  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<CodeInfo>(json.infos))
+    return new ProjectArtifact(compilerOptionsUsed, files)
+  }
+}
+
+export class Project {
+  sourceFiles: SourceFile[]
+  contracts: Compiled<Contract>[]
+  scripts: Compiled<Script>[]
+  projectArtifact: ProjectArtifact
+
+  readonly contractsRootDir: string
+  readonly artifactsRootDir: string
+
+  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, CodeInfo> = new Map()
+    contracts.forEach((c) => {
+      files.set(c.sourceFile.contractPath, {
+        sourceCodeHash: c.sourceFile.sourceCodeHash,
+        bytecodeDebugPatch: c.artifact.bytecodeDebugPatch,
+        codeHashDebug: c.artifact.codeHashDebug,
+        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 ''
+    scripts.forEach((s) => {
+      files.set(s.sourceFile.contractPath, {
+        sourceCodeHash: s.sourceFile.sourceCodeHash,
+        bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
+        codeHashDebug: '',
+        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)
+    const compiledSize = contracts.length + scripts.length
+    sourceFiles.slice(compiledSize).forEach((c) => {
+      files.set(c.contractPath, {
+        sourceCodeHash: c.sourceCodeHash,
+        bytecodeDebugPatch: '',
+        codeHashDebug: '',
+        warnings: []
+      })
+    })
+    return new ProjectArtifact(compilerOptions, files)
+  }
+
+  private constructor(
+    contractsRootDir: string,
+    artifactsRootDir: string,
+    sourceFiles: SourceFile[],
+    contracts: Compiled<Contract>[],
+    scripts: Compiled<Script>[],
+    errorOnWarnings: boolean,
+    projectArtifact: ProjectArtifact
+  ) {
+    this.contractsRootDir = contractsRootDir
+    this.artifactsRootDir = artifactsRootDir
+    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.contractsRootDir}`)
+      ? path.slice(2)
+      : path.startsWith(this.contractsRootDir)
+      ? path
+      : this.contractsRootDir + '/' + 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(
-    sourceFile: SourceFile,
-    importsCache: string[],
-    validate: (code: string) => void
-  ): Promise<string> {
-    const contractPath = sourceFile.contractPath
-    const contractBuffer = await fsPromises.readFile(contractPath)
-    const contractStr = contractBuffer.toString()
+  static contract(name: string): Contract {
+    const contract = Project.currentProject.contracts.find((c) => c.artifact.name === 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.find((c) => c.artifact.name === name)
+    if (typeof script === 'undefined') {
+      throw new Error(`Script "${name}" does not exist`)
+    }
+    return script.artifact
+  }
 
-    validate(contractStr)
-    return Common._handleImports(sourceFile.dirs, contractStr, importsCache)
+  private async saveArtifactsToFile(): Promise<void> {
+    const artifactsRootDir = this.artifactsRootDir
+    const saveToFile = async function (compiled: Compiled<Artifact>): Promise<void> {
+      const artifactDir = compiled.sourceFile.getArtifactPath(artifactsRootDir)
+      const folder = artifactDir.slice(0, artifactDir.lastIndexOf('/'))
+      if (!fs.existsSync(folder)) {
+        fs.mkdirSync(folder, { recursive: true })
+      }
+      return fsPromises.writeFile(artifactDir, compiled.artifact.toString())
+    }
+    for (const contract of this.contracts) {
+      saveToFile(contract)
+    }
+    for (const script of this.scripts) {
+      await saveToFile(script)
+    }
+    await this.projectArtifact.saveToFile(this.artifactsRootDir)
   }
 
-  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 || c.artifact.codeHashDebug == 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,
-    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
-    } else {
-      return compile(provider, sourceFile, contractStr, contractHash)
+    files: SourceFile[],
+    contractsRootDir: string,
+    artifactsRootDir: 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(
+      contractsRootDir,
+      artifactsRootDir,
+      files,
+      contracts,
+      scripts,
+      errorOnWarnings,
+      projectArtifact
+    )
+    await project.saveArtifactsToFile()
+    return project
+  }
+
+  private static async loadArtifacts(
+    provider: NodeProvider,
+    files: SourceFile[],
+    projectArtifact: ProjectArtifact,
+    contractsRootDir: string,
+    artifactsRootDir: 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 artifactDir = file.getArtifactPath(artifactsRootDir)
+        if (file.type === SourceType.Contract) {
+          const artifact = await Contract.fromArtifactFile(artifactDir, info.bytecodeDebugPatch, info.codeHashDebug)
+          contracts.push(new Compiled(file, artifact, warnings))
+        } else if (file.type === SourceType.Script) {
+          const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch)
+          scripts.push(new Compiled(file, artifact, warnings))
+        }
+      }
+
+      return new Project(
+        contractsRootDir,
+        artifactsRootDir,
+        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, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions)
     }
   }
 
-  protected _saveToFile(sourceFile: SourceFile): Promise<void> {
-    const folder = Common._artifactsFolder() + sourceFile.dirPath
-    if (!fs.existsSync(folder)) {
-      fs.mkdirSync(folder, { recursive: true })
+  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(contractsRootDir: 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(contractsRootDir, 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 readonly DEFAULT_CONTRACTS_DIR = 'contracts'
+  static readonly DEFAULT_ARTIFACTS_DIR = 'artifacts'
+
+  static async build(
+    compilerOptionsPartial: Partial<CompilerOptions> = {},
+    contractsRootDir = Project.DEFAULT_CONTRACTS_DIR,
+    artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR
+  ): Promise<void> {
+    const provider = getCurrentNodeProvider()
+    const sourceFiles = await Project.loadSourceFiles(contractsRootDir)
+    const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
+    const projectArtifact = await ProjectArtifact.from(artifactsRootDir)
+    if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
+      console.log(`Compiling contracts in folder "${contractsRootDir}"`)
+      Project.currentProject = await Project.compile(
+        provider,
+        sourceFiles,
+        contractsRootDir,
+        artifactsRootDir,
+        errorOnWarnings,
+        nodeCompilerOptions
+      )
+    } else {
+      console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`)
+      Project.currentProject = await Project.loadArtifacts(
+        provider,
+        sourceFiles,
+        projectArtifact,
+        contractsRootDir,
+        artifactsRootDir,
+        errorOnWarnings,
+        nodeCompilerOptions
+      )
     }
-    return fsPromises.writeFile(sourceFile.artifactPath, this.toString())
+  }
+}
+
+export abstract class Artifact {
+  readonly version: string
+  readonly name: string
+  readonly functions: FunctionSig[]
+
+  constructor(version: string, name: string, functions: FunctionSig[]) {
+    this.version = version
+    this.name = name
+    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 bytecodeDebugPatch: string
   readonly codeHash: string
-  readonly fieldsSig: node.FieldsSig
-  readonly eventsSig: node.EventSig[]
+  readonly fieldsSig: FieldsSig
+  readonly eventsSig: EventSig[]
+
+  readonly bytecodeDebug: string
+  readonly codeHashDebug: string
 
   constructor(
-    sourceCodeSha256: string,
+    version: string,
+    name: string,
     bytecode: string,
+    bytecodeDebugPatch: string,
     codeHash: string,
-    fieldsSig: node.FieldsSig,
-    eventsSig: node.EventSig[],
-    functions: node.FunctionSig[]
+    codeHashDebug: string,
+    fieldsSig: FieldsSig,
+    eventsSig: EventSig[],
+    functions: FunctionSig[]
   ) {
-    super(sourceCodeSha256, functions)
+    super(version, name, functions)
     this.bytecode = bytecode
+    this.bytecodeDebugPatch = bytecodeDebugPatch
     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
+    this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
+    this.codeHashDebug = codeHashDebug
   }
 
   // TODO: safely parse json
-  static fromJson(artifact: any): Contract {
+  static fromJson(artifact: any, bytecodeDebugPatch = '', codeHashDebug = ''): Contract {
     if (
-      artifact.sourceCodeSha256 == null ||
+      artifact.version == null ||
+      artifact.name == null ||
       artifact.bytecode == null ||
       artifact.codeHash == null ||
       artifact.fieldsSig == null ||
@@ -270,44 +580,58 @@ export class Contract extends Common {
       throw Error('The artifact JSON for contract is incomplete')
     }
     const contract = new Contract(
-      artifact.sourceCodeSha256,
+      artifact.version,
+      artifact.name,
       artifact.bytecode,
+      bytecodeDebugPatch,
       artifact.codeHash,
+      codeHashDebug ? codeHashDebug : artifact.codeHash,
       artifact.fieldsSig,
       artifact.eventsSig,
       artifact.functions
     )
-    this._putArtifactToCache(contract)
     return contract
   }
 
+  static fromCompileResult(result: node.CompileContractResult): Contract {
+    return new Contract(
+      result.version,
+      result.name,
+      result.bytecode,
+      result.bytecodeDebugPatch,
+      result.codeHash,
+      result.codeHashDebug,
+      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)
+  static async fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string): Promise<Contract> {
+    const content = await fsPromises.readFile(path)
     const artifact = JSON.parse(content.toString())
-    return Contract.fromJson(artifact)
+    return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug)
   }
 
-  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 web3.getCurrentNodeProvider().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 = {
+      version: this.version,
+      name: this.name,
+      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 {
@@ -323,25 +647,37 @@ 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 _printDebugMessages(funcName: string, messages: DebugMessage[]) {
+    if (messages.length != 0) {
+      console.log(`Testing ${this.name}.${funcName}:`)
+      messages.forEach((m) => console.log(`Debug - ${m.contractAddress} - ${m.message}`))
+    }
+  }
+
   private async _test(
-    provider: NodeProvider,
     funcName: string,
     params: TestContractParams,
     expectPublic: boolean,
-    accessType: string
+    accessType: string,
+    printDebugMessages: boolean
   ): Promise<TestContractResult> {
     const apiParams: node.TestContract = this.toTestContract(funcName, params)
-    const apiResult = await provider.contracts.postContractsTestContract(apiParams)
+    const apiResult = await web3.getCurrentNodeProvider().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 (printDebugMessages) {
+      this._printDebugMessages(funcName, apiResult.debugMessages)
+    }
     if (isPublic === expectPublic) {
       const result = await this.fromTestContractResult(methodIndex, apiResult)
       return result
@@ -351,19 +687,19 @@ export class Contract extends Common {
   }
 
   async testPublicMethod(
-    provider: NodeProvider,
     funcName: string,
-    params: TestContractParams
+    params: TestContractParams,
+    printDebugMessages = true
   ): Promise<TestContractResult> {
-    return this._test(provider, funcName, params, true, 'public')
+    return this._test(funcName, params, true, 'public', printDebugMessages)
   }
 
   async testPrivateMethod(
-    provider: NodeProvider,
     funcName: string,
-    params: TestContractParams
+    params: TestContractParams,
+    printDebugMessages = true
   ): Promise<TestContractResult> {
-    return this._test(provider, funcName, params, false, 'private')
+    return this._test(funcName, params, false, 'private', printDebugMessages)
   }
 
   toApiFields(fields?: Fields): node.Val[] {
@@ -399,7 +735,7 @@ export class Contract extends Common {
     return {
       group: params.group,
       address: params.address,
-      bytecode: this.bytecode,
+      bytecode: this.bytecodeDebug,
       initialFields: this.toApiFields(params.initialFields),
       initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
       methodIndex: this.getMethodIndex(funcName),
@@ -409,33 +745,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)
+  fromApiContractState(state: node.ContractState): ContractState {
+    const contract = Project.currentProject.contractByCodeHash(state.codeHash)
     return {
       address: state.address,
       contractId: binToHex(contractIdFromAddress(state.address)),
@@ -443,37 +754,32 @@ 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']
   }
 
-  static async fromApiEvent(
-    event: node.ContractEventByTxId,
-    codeHash: string | undefined
-  ): Promise<ContractEventByTxId> {
-    let eventSig: node.EventSig
+  static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): ContractEventByTxId {
+    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]
     }
 
@@ -485,55 +791,53 @@ export class Contract extends Common {
     }
   }
 
-  async fromTestContractResult(methodIndex: number, result: node.TestContractResult): Promise<TestContractResult> {
+  fromTestContractResult(methodIndex: number, result: node.TestContractResult): TestContractResult {
     const addressToCodeHash = new Map<string, string>()
     addressToCodeHash.set(result.address, result.codeHash)
     result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash))
     return {
-      address: result.address,
       contractId: binToHex(contractIdFromAddress(result.address)),
+      contractAddress: result.address,
       returns: fromApiArray(result.returns, this.functions[`${methodIndex}`].returnTypes),
       gasUsed: result.gasUsed,
-      contracts: await Promise.all(result.contracts.map((contract) => this.fromApiContractState(contract))),
+      contracts: result.contracts.map((contract) => this.fromApiContractState(contract)),
       txOutputs: result.txOutputs.map(fromApiOutput),
-      events: await Promise.all(
-        result.events.map((event) => {
-          const contractAddress = event.contractAddress
-          const codeHash = addressToCodeHash.get(contractAddress)
-          if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
-            return Contract.fromApiEvent(event, codeHash)
-          } else {
-            throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`)
-          }
-        })
-      )
+      events: result.events.map((event) => {
+        const contractAddress = event.contractAddress
+        const codeHash = addressToCodeHash.get(contractAddress)
+        if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
+          return Contract.fromApiEvent(event, codeHash)
+        } else {
+          throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`)
+        }
+      }),
+      debugMessages: result.debugMessages
     }
   }
 
-  async paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams> {
+  async txParamsForDeployment(
+    signer: SignerProvider,
+    params: Omit<BuildDeployContractTx, 'signerAddress'>
+  ): Promise<SignDeployContractTxParams> {
     const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {})
     const signerParams: SignDeployContractTxParams = {
-      signerAddress: params.signerAddress,
+      signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: bytecode,
-      initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
-      issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
-      initialTokenAmounts: params.initialTokenAmounts?.map(toApiToken),
+      initialAttoAlphAmount: params.initialAttoAlphAmount,
+      issueTokenAmount: params.issueTokenAmount,
+      initialTokenAmounts: params.initialTokenAmounts,
       gasAmount: params.gasAmount,
-      gasPrice: extractOptionalNumber256(params.gasPrice)
+      gasPrice: params.gasPrice
     }
     return signerParams
   }
 
-  async transactionForDeployment(
-    signer: SignerWithNodeProvider,
+  async deploy(
+    signer: SignerProvider,
     params: Omit<BuildDeployContractTx, 'signerAddress'>
-  ): Promise<DeployContractTransaction> {
-    const signerParams = await this.paramsForDeployment({
-      ...params,
-      signerAddress: (await signer.getAccounts())[0].address
-    })
-    const response = await signer.buildContractCreationTx(signerParams)
-    return fromApiDeployContractUnsignedTx(response)
+  ): Promise<SignDeployContractTxResult> {
+    const signerParams = await this.txParamsForDeployment(signer, params)
+    return signer.signAndSubmitDeployContractTx(signerParams)
   }
 
   buildByteCodeToDeploy(initialFields: Fields): string {
@@ -541,108 +845,95 @@ export class Contract extends Common {
   }
 }
 
-export class Script extends Common {
+export class Script extends Artifact {
   readonly bytecodeTemplate: string
-  readonly fieldsSig: node.FieldsSig
+  readonly bytecodeDebugPatch: string
+  readonly fieldsSig: FieldsSig
 
   constructor(
-    sourceCodeSha256: string,
+    version: string,
+    name: string,
     bytecodeTemplate: string,
-    fieldsSig: node.FieldsSig,
-    functions: node.FunctionSig[]
+    bytecodeDebugPatch: string,
+    fieldsSig: FieldsSig,
+    functions: FunctionSig[]
   ) {
-    super(sourceCodeSha256, functions)
+    super(version, name, functions)
     this.bytecodeTemplate = bytecodeTemplate
+    this.bytecodeDebugPatch = bytecodeDebugPatch
     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(result: node.CompileScriptResult): Script {
+    return new Script(
+      result.version,
+      result.name,
+      result.bytecodeTemplate,
+      result.bytecodeDebugPatch,
+      result.fields,
+      result.functions
+    )
   }
 
   // TODO: safely parse json
-  static fromJson(artifact: any): Script {
+  static fromJson(artifact: any, bytecodeDebugPatch = ''): Script {
     if (
-      artifact.sourceCodeSha256 == null ||
+      artifact.version == null ||
+      artifact.name == null ||
       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.version,
+      artifact.name,
+      artifact.bytecodeTemplate,
+      bytecodeDebugPatch,
+      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)
+  static async fromArtifactFile(path: string, bytecodeDebugPatch: string): Promise<Script> {
+    const content = await fsPromises.readFile(path)
     const artifact = JSON.parse(content.toString())
-    return this.fromJson(artifact)
+    return this.fromJson(artifact, bytecodeDebugPatch)
   }
 
   override toString(): string {
-    return JSON.stringify(
-      {
-        sourceCodeSha256: this.sourceCodeSha256,
-        bytecodeTemplate: this.bytecodeTemplate,
-        fieldsSig: this.fieldsSig,
-        functions: this.functions
-      },
-      null,
-      2
-    )
+    const object = {
+      version: this.version,
+      name: this.name,
+      bytecodeTemplate: this.bytecodeTemplate,
+      fieldsSig: this.fieldsSig,
+      functions: this.functions
+    }
+    return JSON.stringify(object, null, 2)
   }
 
-  async paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams> {
+  async txParamsForExecution(
+    signer: SignerProvider,
+    params: Omit<BuildExecuteScriptTx, 'signerAddress'>
+  ): Promise<SignExecuteScriptTxParams> {
     const signerParams: SignExecuteScriptTxParams = {
-      signerAddress: params.signerAddress,
+      signerAddress: (await signer.getSelectedAccount()).address,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
-      attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
-      tokens: typeof params.tokens !== 'undefined' ? params.tokens.map(toApiToken) : undefined,
+      attoAlphAmount: params.attoAlphAmount,
+      tokens: params.tokens,
       gasAmount: params.gasAmount,
-      gasPrice: extractOptionalNumber256(params.gasPrice)
+      gasPrice: params.gasPrice
     }
     return signerParams
   }
 
-  async transactionForDeployment(
-    signer: SignerWithNodeProvider,
+  async execute(
+    signer: SignerProvider,
     params: Omit<BuildExecuteScriptTx, 'signerAddress'>
-  ): Promise<BuildScriptTxResult> {
-    const signerParams = await this.paramsForDeployment({
-      ...params,
-      signerAddress: (await signer.getAccounts())[0].address
-    })
-    return await signer.buildScriptTx(signerParams)
+  ): Promise<SignExecuteScriptTxResult> {
+    const signerParams = await this.txParamsForExecution(signer, params)
+    return await signer.signAndSubmitExecuteScriptTx(signerParams)
   }
 
   buildByteCodeToDeploy(initialFields: Fields): string {
@@ -650,164 +941,6 @@ export class Script extends Common {
   }
 }
 
-export type Number256 = number | bigint | string
-export type Val = Number256 | boolean | string | Val[]
-export type NamedVals = Record<string, Val>
-export type Fields = NamedVals
-export type Arguments = NamedVals
-
-function extractBoolean(v: Val): boolean {
-  if (typeof v === 'boolean') {
-    return v
-  } else {
-    throw new Error(`Invalid boolean value: ${v}`)
-  }
-}
-
-// TODO: check integer bounds
-function extractNumber256(v: Val): string {
-  if ((typeof v === 'number' && Number.isInteger(v)) || typeof v === 'bigint') {
-    return v.toString()
-  } else if (typeof v === 'string') {
-    return v
-  } else {
-    throw new Error(`Invalid 256 bit number: ${v}`)
-  }
-}
-
-function extractOptionalNumber256(v?: Val): string | undefined {
-  return typeof v !== 'undefined' ? extractNumber256(v) : undefined
-}
-
-// TODO: check hex string
-function extractByteVec(v: Val): string {
-  if (typeof v === 'string') {
-    // try to convert from address to contract id
-    try {
-      const address = bs58.decode(v)
-      if (address.length == 33 && address[0] == 3) {
-        return Buffer.from(address.slice(1)).toString('hex')
-      }
-    } catch (_) {
-      return v as string
-    }
-    return v as string
-  } else {
-    throw new Error(`Invalid string: ${v}`)
-  }
-}
-
-function extractBs58(v: Val): string {
-  if (typeof v === 'string') {
-    try {
-      bs58.decode(v)
-      return v as string
-    } catch (error) {
-      throw new Error(`Invalid base58 string: ${v}`)
-    }
-  } else {
-    throw new Error(`Invalid string: ${v}`)
-  }
-}
-
-function decodeNumber256(n: string): Number256 {
-  if (Number.isSafeInteger(Number.parseInt(n))) {
-    return Number(n)
-  } else {
-    return BigInt(n)
-  }
-}
-
-export function extractArray(tpe: string, v: Val): node.Val {
-  if (!Array.isArray(v)) {
-    throw new Error(`Expected array, got ${v}`)
-  }
-
-  const semiColonIndex = tpe.lastIndexOf(';')
-  if (semiColonIndex == -1) {
-    throw new Error(`Invalid Val type: ${tpe}`)
-  }
-
-  const subType = tpe.slice(1, semiColonIndex)
-  const dim = parseInt(tpe.slice(semiColonIndex + 1, -1))
-  if ((v as Val[]).length != dim) {
-    throw new Error(`Invalid val dimension: ${v}`)
-  } else {
-    return { value: (v as Val[]).map((v) => toApiVal(v, subType)), type: 'Array' }
-  }
-}
-
-export function toApiVal(v: Val, tpe: string): node.Val {
-  if (tpe === 'Bool') {
-    return { value: extractBoolean(v), type: tpe }
-  } else if (tpe === 'U256' || tpe === 'I256') {
-    return { value: extractNumber256(v), type: tpe }
-  } else if (tpe === 'ByteVec') {
-    return { value: extractByteVec(v), type: tpe }
-  } else if (tpe === 'Address') {
-    return { value: extractBs58(v), type: tpe }
-  } else {
-    return extractArray(tpe, v)
-  }
-}
-
-function decodeArrayType(tpe: string): [baseType: string, dims: number[]] {
-  const semiColonIndex = tpe.lastIndexOf(';')
-  if (semiColonIndex === -1) {
-    throw new Error(`Invalid Val type: ${tpe}`)
-  }
-
-  const subType = tpe.slice(1, semiColonIndex)
-  const dim = parseInt(tpe.slice(semiColonIndex + 1, -1))
-  if (subType[0] == '[') {
-    const [baseType, subDim] = decodeArrayType(subType)
-    return [baseType, (subDim.unshift(dim), subDim)]
-  } else {
-    return [subType, [dim]]
-  }
-}
-
-function foldVals(vals: Val[], dims: number[]): Val {
-  if (dims.length == 1) {
-    return vals
-  } else {
-    const result: Val[] = []
-    const chunkSize = vals.length / dims[0]
-    const chunkDims = dims.slice(1)
-    for (let i = 0; i < vals.length; i += chunkSize) {
-      const chunk = vals.slice(i, i + chunkSize)
-      result.push(foldVals(chunk, chunkDims))
-    }
-    return result
-  }
-}
-
-function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result: Val, nextIndex: number] {
-  if (vals.length === 0) {
-    throw new Error('Not enough Vals')
-  }
-
-  const firstVal = vals[`${valIndex}`]
-  if (tpe === 'Bool' && firstVal.type === tpe) {
-    return [firstVal.value as boolean, valIndex + 1]
-  } else if ((tpe === 'U256' || tpe === 'I256') && firstVal.type === tpe) {
-    return [decodeNumber256(firstVal.value as string), valIndex + 1]
-  } else if ((tpe === 'ByteVec' || tpe === 'Address') && firstVal.type === tpe) {
-    return [firstVal.value as string, valIndex + 1]
-  } else {
-    const [baseType, dims] = decodeArrayType(tpe)
-    const arraySize = dims.reduce((a, b) => a * b)
-    const nextIndex = valIndex + arraySize
-    const valsToUse = vals.slice(valIndex, nextIndex)
-    if (valsToUse.length == arraySize && valsToUse.every((val) => val.type === baseType)) {
-      const localVals = valsToUse.map((val) => fromApiVal(val, baseType))
-      return [foldVals(localVals, dims), nextIndex]
-    } else {
-      throw new Error(`Invalid array Val type: ${valsToUse}, ${tpe}`)
-    }
-  }
-}
-
 function fromApiFields(vals: node.Val[], fieldsSig: node.FieldsSig): Fields {
   return fromApiVals(vals, fieldsSig.names, fieldsSig.types)
 }
@@ -816,70 +949,22 @@ function fromApiEventFields(vals: node.Val[], eventSig: node.EventSig): Fields {
   return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes)
 }
 
-function fromApiVals(vals: node.Val[], names: string[], types: string[]): Fields {
-  let valIndex = 0
-  const result: Fields = {}
-  types.forEach((currentType, index) => {
-    const currentName = names[`${index}`]
-    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
-    valIndex = nextIndex
-    result[`${currentName}`] = val
-  })
-  return result
-}
-
-function fromApiArray(vals: node.Val[], types: string[]): Val[] {
-  let valIndex = 0
-  const result: Val[] = []
-  for (const currentType of types) {
-    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
-    result.push(val)
-    valIndex = nextIndex
-  }
-  return result
-}
-
-function fromApiVal(v: node.Val, tpe: string): Val {
-  if (v.type === 'Bool' && v.type === tpe) {
-    return v.value as boolean
-  } else if ((v.type === 'U256' || v.type === 'I256') && v.type === tpe) {
-    return decodeNumber256(v.value as string)
-  } else if ((v.type === 'ByteVec' || v.type === 'Address') && v.type === tpe) {
-    return v.value as string
-  } else {
-    throw new Error(`Invalid node.Val type: ${v}`)
-  }
-}
-
 export interface Asset {
   alphAmount: Number256
   tokens?: Token[]
 }
 
-export interface Token {
-  id: string
-  amount: Number256
-}
-
-function toApiToken(token: Token): node.Token {
-  return { id: token.id, amount: extractNumber256(token.amount) }
-}
-
-function fromApiToken(token: node.Token): Token {
-  return { id: token.id, amount: decodeNumber256(token.amount) }
-}
-
 function toApiAsset(asset: Asset): node.AssetState {
   return {
-    attoAlphAmount: extractNumber256(asset.alphAmount),
+    attoAlphAmount: toApiNumber256(asset.alphAmount),
     tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(toApiToken) : []
   }
 }
 
 function fromApiAsset(asset: node.AssetState): Asset {
   return {
-    alphAmount: decodeNumber256(asset.attoAlphAmount),
-    tokens: typeof asset.tokens !== 'undefined' ? asset.tokens.map(fromApiToken) : undefined
+    alphAmount: fromApiNumber256(asset.attoAlphAmount),
+    tokens: fromApiTokens(asset.tokens)
   }
 }
 
@@ -895,7 +980,7 @@ export interface ContractState {
   initialStateHash?: string
   codeHash: string
   fields: Fields
-  fieldsSig: node.FieldsSig
+  fieldsSig: FieldsSig
   asset: Asset
 }
 
@@ -918,12 +1003,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[] {
@@ -967,14 +1052,17 @@ export interface ContractEventByTxId {
   fields: Fields
 }
 
+export type DebugMessage = node.DebugMessage
+
 export interface TestContractResult {
-  address: string
   contractId: string
+  contractAddress: string
   returns: Val[]
   gasUsed: number
   contracts: ContractState[]
   txOutputs: Output[]
   events: ContractEventByTxId[]
+  debugMessages: DebugMessage[]
 }
 export declare type Output = AssetOutput | ContractOutput
 export interface AssetOutput extends Asset {
@@ -987,7 +1075,7 @@ export interface ContractOutput {
   type: string
   address: string
   alphAmount: Number256
-  tokens: Token[]
+  tokens?: Token[]
 }
 
 function fromApiOutput(output: node.Output): Output {
@@ -996,8 +1084,8 @@ function fromApiOutput(output: node.Output): Output {
     return {
       type: 'AssetOutput',
       address: asset.address,
-      alphAmount: decodeNumber256(asset.attoAlphAmount),
-      tokens: asset.tokens.map(fromApiToken),
+      alphAmount: fromApiNumber256(asset.attoAlphAmount),
+      tokens: fromApiTokens(asset.tokens),
       lockTime: asset.lockTime,
       message: asset.message
     }
@@ -1006,8 +1094,8 @@ function fromApiOutput(output: node.Output): Output {
     return {
       type: 'ContractOutput',
       address: asset.address,
-      alphAmount: decodeNumber256(asset.attoAlphAmount),
-      tokens: asset.tokens.map(fromApiToken)
+      alphAmount: fromApiNumber256(asset.attoAlphAmount),
+      tokens: fromApiTokens(asset.tokens)
     }
   } else {
     throw new Error(`Unknown output type: ${output}`)
@@ -1023,21 +1111,16 @@ export interface DeployContractTransaction {
   contractId: string
 }
 
-function fromApiDeployContractUnsignedTx(result: node.BuildDeployContractTxResult): DeployContractTransaction {
-  return { ...result, contractId: binToHex(contractIdFromAddress(result.contractAddress)) }
-}
-
 type BuildTxParams<T> = Omit<T, 'bytecode'> & { initialFields?: Val[] }
 
 export interface BuildDeployContractTx {
   signerAddress: string
   initialFields?: Fields
-  initialAttoAlphAmount?: string
+  initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
   issueTokenAmount?: Number256
   gasAmount?: number
   gasPrice?: Number256
-  submitTx?: boolean
 }
 assertType<Eq<keyof BuildDeployContractTx, keyof BuildTxParams<SignDeployContractTxParams>>>()
 
@@ -1048,7 +1131,6 @@ export interface BuildExecuteScriptTx {
   tokens?: Token[]
   gasAmount?: number
   gasPrice?: Number256
-  submitTx?: boolean
 }
 assertType<Eq<keyof BuildExecuteScriptTx, keyof BuildTxParams<SignExecuteScriptTxParams>>>()