@alephium/web3 0.2.0-rc.10 → 0.2.0-rc.11

package/src/api/types.ts

@@ -0,0 +1,233 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { assertType, bs58, Eq } from '../utils'
+import * as node from './api-alephium'
+
+export type Number256 = number | bigint | string
+export type Val = Number256 | boolean | string | Val[]
+export type NamedVals = Record<string, Val>
+
+export interface Token {
+  id: string
+  amount: Number256
+}
+assertType<Eq<keyof Token, keyof node.Token>>
+
+export function toApiToken(token: Token): node.Token {
+  return { id: token.id, amount: toApiNumber256(token.amount) }
+}
+
+export function toApiTokens(tokens?: Token[]): node.Token[] | undefined {
+  return tokens?.map(toApiToken)
+}
+
+export function fromApiToken(token: node.Token): Token {
+  return { id: token.id, amount: fromApiNumber256(token.amount) }
+}
+
+export function fromApiTokens(tokens?: node.Token[]): Token[] | undefined {
+  return tokens?.map(fromApiToken)
+}
+
+export function toApiBoolean(v: Val): boolean {
+  if (typeof v === 'boolean') {
+    return v
+  } else {
+    throw new Error(`Invalid boolean value: ${v}`)
+  }
+}
+
+// TODO: check integer bounds
+export function toApiNumber256(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}`)
+  }
+}
+
+export function toApiNumber256Optional(v?: Val): string | undefined {
+  return v === undefined ? undefined : toApiNumber256(v)
+}
+
+export function fromApiNumber256(n: string): Number256 {
+  if (Number.isSafeInteger(Number.parseInt(n))) {
+    return Number(n)
+  } else {
+    return BigInt(n)
+  }
+}
+
+// TODO: check hex string
+export function toApiByteVec(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}`)
+  }
+}
+
+export function toApiAddress(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}`)
+  }
+}
+
+export function toApiArray(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: toApiBoolean(v), type: tpe }
+  } else if (tpe === 'U256' || tpe === 'I256') {
+    return { value: toApiNumber256(v), type: tpe }
+  } else if (tpe === 'ByteVec') {
+    return { value: toApiByteVec(v), type: tpe }
+  } else if (tpe === 'Address') {
+    return { value: toApiAddress(v), type: tpe }
+  } else {
+    return toApiArray(tpe, v)
+  }
+}
+
+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 [fromApiNumber256(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}`)
+    }
+  }
+}
+
+export function fromApiVals(vals: node.Val[], names: string[], types: string[]): NamedVals {
+  let valIndex = 0
+  const result: NamedVals = {}
+  types.forEach((currentType, index) => {
+    const currentName = names[`${index}`]
+    const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType)
+    valIndex = nextIndex
+    result[`${currentName}`] = val
+  })
+  return result
+}
+
+export 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
+}
+
+export 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 fromApiNumber256(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}`)
+  }
+}
+
+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
+  }
+}

package/src/contract/contract.ts

@@ -20,16 +20,32 @@ import { Buffer } from 'buffer/'
 import { webcrypto as crypto } from 'crypto'
 import fs from 'fs'
 import { promises as fsPromises } from 'fs'
-import { node, NodeProvider } from '../api'
+import {
+  fromApiArray,
+  fromApiNumber256,
+  toApiNumber256,
+  NamedVals,
+  node,
+  NodeProvider,
+  Number256,
+  toApiToken,
+  toApiVal,
+  Token,
+  Val,
+  toApiTokens,
+  fromApiTokens,
+  fromApiVals
+} from '../api'
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer'
 import * as ralph from './ralph'
 import { bs58, binToHex, contractIdFromAddress, assertType, Eq } from '../utils'
-import { CompileContractResult, CompileScriptResult } from '../api/api-alephium'
 import { getCurrentNodeProvider } from '../global'
 
-type FieldsSig = node.FieldsSig
-type EventSig = node.EventSig
-type FunctionSig = node.FunctionSig
+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,
@@ -275,20 +291,18 @@ export class Project {
     }
   }
 
-  static contract(path: string): 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`)
     }
     return contract.artifact
   }
 
-  static script(path: string): Script {
-    const contractPath = Project.currentProject.getContractPath(path)
-    const script = Project.currentProject.scripts.find((c) => c.sourceFile.contractPath === contractPath)
+  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`)
     }
     return script.artifact
   }
@@ -484,9 +498,11 @@ export class Project {
 }
 
 export abstract class Artifact {
+  readonly name: string
   readonly functions: FunctionSig[]
 
-  constructor(functions: FunctionSig[]) {
+  constructor(name: string, functions: FunctionSig[]) {
+    this.name = name
     this.functions = functions
   }
 
@@ -512,13 +528,14 @@ export class Contract extends Artifact {
   readonly eventsSig: EventSig[]
 
   constructor(
+    name: string,
     bytecode: string,
     codeHash: string,
     fieldsSig: FieldsSig,
     eventsSig: EventSig[],
     functions: FunctionSig[]
   ) {
-    super(functions)
+    super(name, functions)
     this.bytecode = bytecode
     this.codeHash = codeHash
     this.fieldsSig = fieldsSig
@@ -528,6 +545,7 @@ export class Contract extends Artifact {
   // TODO: safely parse json
   static fromJson(artifact: any): Contract {
     if (
+      artifact.name == null ||
       artifact.bytecode == null ||
       artifact.codeHash == null ||
       artifact.fieldsSig == null ||
@@ -537,6 +555,7 @@ export class Contract extends Artifact {
       throw Error('The artifact JSON for contract is incomplete')
     }
     const contract = new Contract(
+      artifact.name,
       artifact.bytecode,
       artifact.codeHash,
       artifact.fieldsSig,
@@ -546,8 +565,8 @@ export class Contract extends Artifact {
     return contract
   }
 
-  static fromCompileResult(result: CompileContractResult): Contract {
-    return new Contract(result.bytecode, result.codeHash, result.fields, result.events, result.functions)
+  static fromCompileResult(result: node.CompileContractResult): Contract {
+    return new Contract(result.name, result.bytecode, result.codeHash, result.fields, result.events, result.functions)
   }
 
   // support both 'code.ral' and 'code.ral.json'
@@ -566,6 +585,7 @@ export class Contract extends Artifact {
 
   override toString(): string {
     const object = {
+      name: this.name,
       bytecode: this.bytecode,
       codeHash: this.codeHash,
       fieldsSig: this.fieldsSig,
@@ -748,7 +768,7 @@ export class Contract extends Artifact {
       bytecode: bytecode,
       initialAttoAlphAmount: extractOptionalNumber256(params.initialAttoAlphAmount),
       issueTokenAmount: extractOptionalNumber256(params.issueTokenAmount),
-      initialTokenAmounts: params.initialTokenAmounts?.map(toApiToken),
+      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
       gasAmount: params.gasAmount,
       gasPrice: extractOptionalNumber256(params.gasPrice)
     }
@@ -776,22 +796,27 @@ export class Script extends Artifact {
   readonly bytecodeTemplate: string
   readonly fieldsSig: FieldsSig
 
-  constructor(bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
-    super(functions)
+  constructor(name: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]) {
+    super(name, functions)
     this.bytecodeTemplate = bytecodeTemplate
     this.fieldsSig = fieldsSig
   }
 
-  static fromCompileResult(result: CompileScriptResult): Script {
-    return new Script(result.bytecodeTemplate, result.fields, result.functions)
+  static fromCompileResult(result: node.CompileScriptResult): Script {
+    return new Script(result.name, result.bytecodeTemplate, result.fields, result.functions)
   }
 
   // TODO: safely parse json
   static fromJson(artifact: any): Script {
-    if (artifact.bytecodeTemplate == null || artifact.fieldsSig == null || artifact.functions == null) {
+    if (
+      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.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
+    return new Script(artifact.name, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions)
   }
 
   static async fromArtifactFile(path: string): Promise<Script> {
@@ -802,6 +827,7 @@ export class Script extends Artifact {
 
   override toString(): string {
     const object = {
+      name: this.name,
       bytecodeTemplate: this.bytecodeTemplate,
       fieldsSig: this.fieldsSig,
       functions: this.functions
@@ -814,7 +840,7 @@ export class Script extends Artifact {
       signerAddress: params.signerAddress,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
       attoAlphAmount: extractOptionalNumber256(params.attoAlphAmount),
-      tokens: typeof params.tokens !== 'undefined' ? params.tokens.map(toApiToken) : undefined,
+      tokens: toApiTokens(params.tokens),
       gasAmount: params.gasAmount,
       gasPrice: extractOptionalNumber256(params.gasPrice)
     }
@@ -837,162 +863,8 @@ 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}`)
-    }
-  }
+  return typeof v !== 'undefined' ? toApiNumber256(v) : undefined
 }
 
 function fromApiFields(vals: node.Val[], fieldsSig: node.FieldsSig): Fields {
@@ -1003,70 +875,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)
   }
 }
 
@@ -1174,7 +998,7 @@ export interface ContractOutput {
   type: string
   address: string
   alphAmount: Number256
-  tokens: Token[]
+  tokens?: Token[]
 }
 
 function fromApiOutput(output: node.Output): Output {
@@ -1183,8 +1007,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
     }
@@ -1193,8 +1017,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}`)