@alephium/web3 0.2.0-test.1 → 0.2.0

package/src/contract/contract.ts

@@ -17,20 +17,41 @@ 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 { node, NodeProvider } 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 { CompileContractResult, CompileScriptResult } from '../api/api-alephium'
 import { getCurrentNodeProvider } from '../global'
+import { web3 } from '..'
 
-type FieldsSig = node.FieldsSig
-type EventSig = node.EventSig
-type FunctionSig = node.FunctionSig
+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,
@@ -39,54 +60,57 @@ enum SourceType {
   Interface = 3
 }
 
-export type CompilerOptions = {
+export type CompilerOptions = node.CompilerOptions & {
   errorOnWarnings: boolean
-  ignoreUnusedConstantsWarnings: boolean
 }
 
-export const DEFAULT_COMPILER_OPTIONS: CompilerOptions = {
-  errorOnWarnings: true,
-  ignoreUnusedConstantsWarnings: true
+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
-  name: string | undefined
 
   constructor(pattern: string, type: T) {
     this.matcher = new RegExp(pattern, 'mg')
     this.type = type
-    this.name = undefined
   }
 
   match(str: string): number {
-    const results = [...str.matchAll(this.matcher)]
-    if (results.length > 0) {
-      this.name = results[0][1]
-    }
-    return results.length
+    const results = str.match(this.matcher)
+    return results === null ? 0 : results.length
   }
 }
 
 class SourceFile {
   type: SourceType
-  typeId: string
   contractPath: string
   sourceCode: string
   sourceCodeHash: string
 
-  getArtifactPath(artifactsRootPath: string): string {
-    return artifactsRootPath + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json'
+  getArtifactPath(artifactsRootDir: string): string {
+    return artifactsRootDir + this.contractPath.slice(this.contractPath.indexOf('/')) + '.json'
   }
 
-  constructor(type: SourceType, typeId: string, sourceCode: string, contractPath: string) {
+  constructor(type: SourceType, sourceCode: string, sourceCodeHash: string, contractPath: string) {
     this.type = type
-    this.typeId = typeId
     this.sourceCode = sourceCode
-    this.sourceCodeHash = cryptojs.SHA256(sourceCode).toString()
+    this.sourceCodeHash = sourceCodeHash
     this.contractPath = contractPath
   }
+
+  static async from(type: SourceType, sourceCode: string, contractPath: string): Promise<SourceFile> {
+    const sourceCodeHash = await crypto.subtle.digest('SHA-256', Buffer.from(sourceCode))
+    return new SourceFile(type, sourceCode, Buffer.from(sourceCodeHash).toString('hex'), contractPath)
+  }
 }
 
 class Compiled<T extends Artifact> {
@@ -101,22 +125,49 @@ class Compiled<T extends Artifact> {
   }
 }
 
+type CodeInfo = { sourceCodeHash: string; bytecodeDebugPatch: string; codeHashDebug: string; warnings: string[] }
+
 class ProjectArtifact {
   static readonly artifactFileName = '.project.json'
 
-  infos: Map<string, { sourceCodeHash: string; warnings: 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(infos: Map<string, { sourceCodeHash: string; warnings: string[] }>) {
+  constructor(compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>) {
+    ProjectArtifact.checkCompilerOptionsParameter(compilerOptionsUsed)
+    this.compilerOptionsUsed = compilerOptionsUsed
     this.infos = infos
   }
 
   async saveToFile(rootPath: string): Promise<void> {
     const filepath = rootPath + '/' + ProjectArtifact.artifactFileName
-    const content = JSON.stringify(Object.fromEntries(this.infos), null, 2)
+    const artifact = { compilerOptionsUsed: this.compilerOptionsUsed, infos: Object.fromEntries(this.infos) }
+    const content = JSON.stringify(artifact, null, 2)
     return fsPromises.writeFile(filepath, content)
   }
 
-  sourceHasChanged(files: SourceFile[]): boolean {
+  needToReCompile(compilerOptions: node.CompilerOptions, files: SourceFile[]): boolean {
+    ProjectArtifact.checkCompilerOptionsParameter(compilerOptions)
+
+    const optionsMatched = Object.entries(compilerOptions).every(([key, inputOption]) => {
+      const usedOption = this.compilerOptionsUsed[`${key}`]
+      return usedOption === inputOption
+    })
+    if (!optionsMatched) {
+      return true
+    }
+
     if (files.length !== this.infos.size) {
       return true
     }
@@ -126,6 +177,7 @@ class ProjectArtifact {
         return true
       }
     }
+
     return false
   }
 
@@ -135,10 +187,10 @@ class ProjectArtifact {
       return undefined
     }
     const content = await fsPromises.readFile(filepath)
-    const files = new Map(
-      Object.entries<{ sourceCodeHash: string; warnings: string[] }>(JSON.parse(content.toString()))
-    )
-    return new ProjectArtifact(files)
+    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)
   }
 }
 
@@ -146,20 +198,20 @@ export class Project {
   sourceFiles: SourceFile[]
   contracts: Compiled<Contract>[]
   scripts: Compiled<Script>[]
+  projectArtifact: ProjectArtifact
 
-  readonly contractsRootPath: string
-  readonly artifactsRootPath: string
-  readonly nodeProvider: NodeProvider
+  readonly contractsRootDir: string
+  readonly artifactsRootDir: string
 
   static currentProject: Project
 
   static readonly abstractContractMatcher = new TypedMatcher<SourceType>(
-    '^Abstract Contract ([A-Z][a-zA-Z0-9]*)\\(*',
+    '^Abstract Contract [A-Z][a-zA-Z0-9]*',
     SourceType.AbstractContract
   )
-  static readonly contractMatcher = new TypedMatcher('^Contract ([A-Z][a-zA-Z0-9]*)\\(*', SourceType.Contract)
-  static readonly interfaceMatcher = new TypedMatcher('^Interface ([A-Z][a-zA-Z0-9]*) \\{', SourceType.Interface)
-  static readonly scriptMatcher = new TypedMatcher('^TxScript ([A-Z][a-zA-Z0-9]*)( \\{*|\\(*)', SourceType.Script)
+  static readonly contractMatcher = new TypedMatcher('^Contract [A-Z][a-zA-Z0-9]*', SourceType.Contract)
+  static readonly interfaceMatcher = new TypedMatcher('^Interface [A-Z][a-zA-Z0-9]* \\{', SourceType.Interface)
+  static readonly scriptMatcher = new TypedMatcher('^TxScript [A-Z][a-zA-Z0-9]*', SourceType.Script)
   static readonly matchers = [
     Project.abstractContractMatcher,
     Project.contractMatcher,
@@ -167,39 +219,79 @@ export class Project {
     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
+      })
+    })
+    scripts.forEach((s) => {
+      files.set(s.sourceFile.contractPath, {
+        sourceCodeHash: s.sourceFile.sourceCodeHash,
+        bytecodeDebugPatch: s.artifact.bytecodeDebugPatch,
+        codeHashDebug: '',
+        warnings: s.warnings
+      })
+    })
+    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(
-    provider: NodeProvider,
-    contractsRootPath: string,
-    artifactsRootPath: string,
+    contractsRootDir: string,
+    artifactsRootDir: string,
     sourceFiles: SourceFile[],
     contracts: Compiled<Contract>[],
-    scripts: Compiled<Script>[]
+    scripts: Compiled<Script>[],
+    errorOnWarnings: boolean,
+    projectArtifact: ProjectArtifact
   ) {
-    this.nodeProvider = provider
-    this.contractsRootPath = contractsRootPath
-    this.artifactsRootPath = artifactsRootPath
+    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.contractsRootPath}`)
+    return path.startsWith(`./${this.contractsRootDir}`)
       ? path.slice(2)
-      : path.startsWith(this.contractsRootPath)
+      : path.startsWith(this.contractsRootDir)
       ? path
-      : this.contractsRootPath + '/' + path
+      : this.contractsRootDir + '/' + path
   }
 
-  private static checkCompilerWarnings(warnings: string[], compilerOptions: CompilerOptions): void {
-    const remains = compilerOptions.ignoreUnusedConstantsWarnings
-      ? warnings.filter((s) => !s.includes('unused constants'))
-      : warnings
-    if (remains.length !== 0) {
+  static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void {
+    if (warnings.length !== 0) {
       const prefixPerWarning = '  - '
-      const warningString = prefixPerWarning + remains.join('\n' + prefixPerWarning)
-      const output = 'Compilation warnings:\n' + warningString + '\n'
-      if (compilerOptions.errorOnWarnings) {
+      const warningString = prefixPerWarning + warnings.join('\n' + prefixPerWarning)
+      const output = `Compilation warnings:\n` + warningString + '\n'
+      if (errorOnWarnings) {
         throw new Error(output)
       } else {
         console.log(output)
@@ -207,102 +299,87 @@ export class Project {
     }
   }
 
-  static contract(path: string, compilerOptions?: Partial<CompilerOptions>): Contract {
-    const contractPath = Project.currentProject.getContractPath(path)
-    const contract = Project.currentProject.contracts.find((c) => c.sourceFile.contractPath === contractPath)
+  static contract(name: string): Contract {
+    const contract = Project.currentProject.contracts.find((c) => c.artifact.name === name)
     if (typeof contract === 'undefined') {
-      throw new Error(`Contract ${contractPath} does not exist`)
+      throw new Error(`Contract "${name}" does not exist`)
     }
-    Project.checkCompilerWarnings(contract.warnings, { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions })
     return contract.artifact
   }
 
-  static script(path: string, compilerOptions?: Partial<CompilerOptions>): Script {
-    const contractPath = Project.currentProject.getContractPath(path)
-    const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath)
+  static script(name: string): Script {
+    const script = Project.currentProject.scripts.find((c) => c.artifact.name === name)
     if (typeof script === 'undefined') {
-      throw new Error(`Script ${contractPath} does not exist`)
+      throw new Error(`Script "${name}" does not exist`)
     }
-    Project.checkCompilerWarnings(script.warnings, { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptions })
     return script.artifact
   }
 
   private async saveArtifactsToFile(): Promise<void> {
-    const artifactsRootPath = this.artifactsRootPath
+    const artifactsRootDir = this.artifactsRootDir
     const saveToFile = async function (compiled: Compiled<Artifact>): Promise<void> {
-      const artifactPath = compiled.sourceFile.getArtifactPath(artifactsRootPath)
-      const folder = artifactPath.slice(0, artifactPath.lastIndexOf('/'))
+      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(artifactPath, compiled.artifact.toString())
+      return fsPromises.writeFile(artifactDir, compiled.artifact.toString())
     }
     for (const contract of this.contracts) {
-      await saveToFile(contract)
+      saveToFile(contract)
     }
     for (const script of this.scripts) {
       await saveToFile(script)
     }
+    await this.projectArtifact.saveToFile(this.artifactsRootDir)
   }
 
   contractByCodeHash(codeHash: string): Contract {
-    const contract = this.contracts.find((c) => c.artifact.codeHash === codeHash)
+    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
   }
 
-  private async saveProjectArtifactToFile(): Promise<void> {
-    const files: Map<string, { sourceCodeHash: string; warnings: string[] }> = new Map()
-    this.contracts.forEach((c) => {
-      files.set(c.sourceFile.contractPath, {
-        sourceCodeHash: c.sourceFile.sourceCodeHash,
-        warnings: c.warnings
-      })
-    })
-    this.scripts.forEach((s) => {
-      files.set(s.sourceFile.contractPath, {
-        sourceCodeHash: s.sourceFile.sourceCodeHash,
-        warnings: s.warnings
-      })
-    })
-    const compiledSize = this.contracts.length + this.scripts.length
-    this.sourceFiles.slice(compiledSize).forEach((c) => {
-      files.set(c.contractPath, {
-        sourceCodeHash: c.sourceCodeHash,
-        warnings: []
-      })
-    })
-    const projectArtifact = new ProjectArtifact(files)
-    await projectArtifact.saveToFile(this.artifactsRootPath)
-  }
-
   private static async compile(
     provider: NodeProvider,
     files: SourceFile[],
-    contractsRootPath: string,
-    artifactsRootPath: string
+    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
+      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(sourceFile.typeId, contractResult)
+      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(sourceFile.typeId, scriptResult)
+      const script = Script.fromCompileResult(scriptResult)
       scripts.push(new Compiled(sourceFile, script, scriptResult.warnings))
     })
-    const project = new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts)
+    const projectArtifact = Project.buildProjectArtifact(files, contracts, scripts, compilerOptions)
+    const project = new Project(
+      contractsRootDir,
+      artifactsRootDir,
+      files,
+      contracts,
+      scripts,
+      errorOnWarnings,
+      projectArtifact
+    )
     await project.saveArtifactsToFile()
-    await project.saveProjectArtifactToFile()
     return project
   }
 
@@ -310,8 +387,10 @@ export class Project {
     provider: NodeProvider,
     files: SourceFile[],
     projectArtifact: ProjectArtifact,
-    contractsRootPath: string,
-    artifactsRootPath: string
+    contractsRootDir: string,
+    artifactsRootDir: string,
+    errorOnWarnings: boolean,
+    compilerOptions: node.CompilerOptions
   ): Promise<Project> {
     try {
       const contracts: Compiled<Contract>[] = []
@@ -322,19 +401,28 @@ export class Project {
           throw Error(`Unable to find project info for ${file.contractPath}, please rebuild the project`)
         }
         const warnings = info.warnings
-        const artifactPath = file.getArtifactPath(artifactsRootPath)
+        const artifactDir = file.getArtifactPath(artifactsRootDir)
         if (file.type === SourceType.Contract) {
-          const artifact = await Contract.fromArtifactFile(artifactPath)
+          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(artifactPath)
+          const artifact = await Script.fromArtifactFile(artifactDir, info.bytecodeDebugPatch)
           scripts.push(new Compiled(file, artifact, warnings))
         }
       }
-      return new Project(provider, contractsRootPath, artifactsRootPath, files, contracts, scripts)
+
+      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, contractsRootPath, artifactsRootPath)
+      return Project.compile(provider, files, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions)
     }
   }
 
@@ -355,15 +443,11 @@ export class Project {
       throw new Error(`Multiple definitions in file: ${contractPath}`)
     }
     const matcherIndex = results.indexOf(1)
-    const matcher = this.matchers[`${matcherIndex}`]
-    const type = matcher.type
-    if (matcher.name === undefined) {
-      throw new Error(`Invalid definition in file: ${contractPath}`)
-    }
-    return new SourceFile(type, matcher.name, sourceStr, contractPath)
+    const type = this.matchers[`${matcherIndex}`].type
+    return SourceFile.from(type, sourceStr, contractPath)
   }
 
-  private static async loadSourceFiles(contractsRootPath: string): Promise<SourceFile[]> {
+  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) {
@@ -377,7 +461,7 @@ export class Project {
       }
     }
     const sourceFiles: SourceFile[] = []
-    await loadDir(contractsRootPath, sourceFiles)
+    await loadDir(contractsRootDir, sourceFiles)
     const contractAndScriptSize = sourceFiles.filter(
       (f) => f.type === SourceType.Contract || f.type === SourceType.Script
     ).length
@@ -387,30 +471,51 @@ export class Project {
     return sourceFiles.sort((a, b) => a.type - b.type)
   }
 
-  static async build(contractsRootPath = 'contracts', artifactsRootPath = 'artifacts'): Promise<void> {
+  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(contractsRootPath)
-    const projectArtifact = await ProjectArtifact.from(artifactsRootPath)
-    if (typeof projectArtifact === 'undefined' || projectArtifact.sourceHasChanged(sourceFiles)) {
-      Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootPath, artifactsRootPath)
+    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,
-        contractsRootPath,
-        artifactsRootPath
+        contractsRootDir,
+        artifactsRootDir,
+        errorOnWarnings,
+        nodeCompilerOptions
       )
     }
   }
 }
 
 export abstract class Artifact {
-  readonly typeId: string
+  readonly version: string
+  readonly name: string
   readonly functions: FunctionSig[]
 
-  constructor(typeId: string, functions: FunctionSig[]) {
-    this.typeId = typeId
+  constructor(version: string, name: string, functions: FunctionSig[]) {
+    this.version = version
+    this.name = name
     this.functions = functions
   }
 
@@ -431,28 +536,41 @@ export abstract class Artifact {
 
 export class Contract extends Artifact {
   readonly bytecode: string
+  readonly bytecodeDebugPatch: string
   readonly codeHash: string
   readonly fieldsSig: FieldsSig
   readonly eventsSig: EventSig[]
 
+  readonly bytecodeDebug: string
+  readonly codeHashDebug: string
+
   constructor(
-    typeId: string,
+    version: string,
+    name: string,
     bytecode: string,
+    bytecodeDebugPatch: string,
     codeHash: string,
+    codeHashDebug: string,
     fieldsSig: FieldsSig,
     eventsSig: EventSig[],
     functions: FunctionSig[]
   ) {
-    super(typeId, functions)
+    super(version, name, functions)
     this.bytecode = bytecode
+    this.bytecodeDebugPatch = bytecodeDebugPatch
     this.codeHash = codeHash
     this.fieldsSig = fieldsSig
     this.eventsSig = eventsSig
+
+    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.version == null ||
+      artifact.name == null ||
       artifact.bytecode == null ||
       artifact.codeHash == null ||
       artifact.fieldsSig == null ||
@@ -462,9 +580,12 @@ export class Contract extends Artifact {
       throw Error('The artifact JSON for contract is incomplete')
     }
     const contract = new Contract(
-      artifact.typeId,
+      artifact.version,
+      artifact.name,
       artifact.bytecode,
+      bytecodeDebugPatch,
       artifact.codeHash,
+      codeHashDebug ? codeHashDebug : artifact.codeHash,
       artifact.fieldsSig,
       artifact.eventsSig,
       artifact.functions
@@ -472,19 +593,29 @@ export class Contract extends Artifact {
     return contract
   }
 
-  static fromCompileResult(typeId: string, result: CompileContractResult): Contract {
-    return new Contract(typeId, result.bytecode, result.codeHash, result.fields, result.events, result.functions)
+  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> {
+  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(address: string, group: number): Promise<ContractState> {
-    const state = await Project.currentProject.nodeProvider.contracts.getContractsAddressState(address, {
+    const state = await web3.getCurrentNodeProvider().contracts.getContractsAddressState(address, {
       group: group
     })
     return this.fromApiContractState(state)
@@ -492,7 +623,8 @@ export class Contract extends Artifact {
 
   override toString(): string {
     const object = {
-      typeId: this.typeId,
+      version: this.version,
+      name: this.name,
       bytecode: this.bytecode,
       codeHash: this.codeHash,
       fieldsSig: this.fieldsSig,
@@ -515,24 +647,37 @@ export class Contract extends Artifact {
     }
   }
 
+  // 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(
     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 Project.currentProject.nodeProvider.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}`].isPublic
+    if (printDebugMessages) {
+      this._printDebugMessages(funcName, apiResult.debugMessages)
+    }
     if (isPublic === expectPublic) {
       const result = await this.fromTestContractResult(methodIndex, apiResult)
       return result
@@ -541,12 +686,20 @@ export class Contract extends Artifact {
     }
   }
 
-  async testPublicMethod(funcName: string, params: TestContractParams): Promise<TestContractResult> {
-    return this._test(funcName, params, true, 'public')
+  async testPublicMethod(
+    funcName: string,
+    params: TestContractParams,
+    printDebugMessages = true
+  ): Promise<TestContractResult> {
+    return this._test(funcName, params, true, 'public', printDebugMessages)
   }
 
-  async testPrivateMethod(funcName: string, params: TestContractParams): Promise<TestContractResult> {
-    return this._test(funcName, params, false, 'private')
+  async testPrivateMethod(
+    funcName: string,
+    params: TestContractParams,
+    printDebugMessages = true
+  ): Promise<TestContractResult> {
+    return this._test(funcName, params, false, 'private', printDebugMessages)
   }
 
   toApiFields(fields?: Fields): node.Val[] {
@@ -582,7 +735,7 @@ export class Contract extends Artifact {
     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),
@@ -592,7 +745,7 @@ export class Contract extends Artifact {
     }
   }
 
-  async fromApiContractState(state: node.ContractState): Promise<ContractState> {
+  fromApiContractState(state: node.ContractState): ContractState {
     const contract = Project.currentProject.contractByCodeHash(state.codeHash)
     return {
       address: state.address,
@@ -618,10 +771,7 @@ export class Contract extends Artifact {
     fieldTypes: ['Address']
   }
 
-  static async fromApiEvent(
-    event: node.ContractEventByTxId,
-    codeHash: string | undefined
-  ): Promise<ContractEventByTxId> {
+  static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): ContractEventByTxId {
     let eventSig: EventSig
 
     if (event.eventIndex == -1) {
@@ -641,55 +791,53 @@ export class Contract extends Artifact {
     }
   }
 
-  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 {
@@ -699,35 +847,65 @@ export class Contract extends Artifact {
 
 export class Script extends Artifact {
   readonly bytecodeTemplate: string
+  readonly bytecodeDebugPatch: string
   readonly fieldsSig: FieldsSig
 
-  constructor(typeId: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
-    super(typeId, functions)
+  constructor(
+    version: string,
+    name: string,
+    bytecodeTemplate: string,
+    bytecodeDebugPatch: string,
+    fieldsSig: FieldsSig,
+    functions: FunctionSig[]
+  ) {
+    super(version, name, functions)
     this.bytecodeTemplate = bytecodeTemplate
+    this.bytecodeDebugPatch = bytecodeDebugPatch
     this.fieldsSig = fieldsSig
   }
 
-  static fromCompileResult(typeId: string, result: CompileScriptResult): Script {
-    return new Script(typeId, result.bytecodeTemplate, result.fields, result.functions)
+  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 {
-    if (artifact.bytecodeTemplate == null || artifact.fieldsSig == null || artifact.functions == null) {
+  static fromJson(artifact: any, bytecodeDebugPatch = ''): Script {
+    if (
+      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.typeId, 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> {
+  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 {
     const object = {
-      typeId: this.typeId,
+      version: this.version,
+      name: this.name,
       bytecodeTemplate: this.bytecodeTemplate,
       fieldsSig: this.fieldsSig,
       functions: this.functions
@@ -735,27 +913,27 @@ export class Script extends Artifact {
     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 {
@@ -763,164 +941,6 @@ export class Script extends Artifact {
   }
 }
 
-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)
 }
@@ -929,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)
   }
 }
 
@@ -1080,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 {
@@ -1100,7 +1075,7 @@ export interface ContractOutput {
   type: string
   address: string
   alphAmount: Number256
-  tokens: Token[]
+  tokens?: Token[]
 }
 
 function fromApiOutput(output: node.Output): Output {
@@ -1109,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
     }
@@ -1119,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}`)
@@ -1136,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>>>()
 
@@ -1161,7 +1131,6 @@ export interface BuildExecuteScriptTx {
   tokens?: Token[]
   gasAmount?: number
   gasPrice?: Number256
-  submitTx?: boolean
 }
 assertType<Eq<keyof BuildExecuteScriptTx, keyof BuildTxParams<SignExecuteScriptTxParams>>>()