@alephium/web3 0.0.3 → 0.1.0-rc.2

package/src/contract/events.ts

@@ -0,0 +1,102 @@
+/*
+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 EventEmitter from 'eventemitter3'
+import { node } from '../api'
+import { NodeProvider } from '../api'
+
+type EventCallback = (event: node.ContractEvent) => Promise<void>
+type ErrorCallback = (error: any, subscription: Subscription) => Promise<void>
+
+export interface SubscribeOptions {
+  provider: NodeProvider
+  contractAddress: string
+  fromCount?: number
+  pollingInterval: number
+  eventCallback: EventCallback
+  errorCallback: ErrorCallback
+}
+
+export class Subscription {
+  provider: NodeProvider
+  readonly contractAddress: string
+  pollingInterval: number
+
+  private fromCount: number
+  private eventCallback: EventCallback
+  private errorCallback: ErrorCallback
+  private task: ReturnType<typeof setTimeout> | undefined
+  private cancelled: boolean
+  private eventEmitter: EventEmitter
+
+  constructor(options: SubscribeOptions) {
+    this.provider = options.provider
+    this.contractAddress = options.contractAddress
+    this.fromCount = typeof options.fromCount === 'undefined' ? 0 : options.fromCount
+    this.pollingInterval = options.pollingInterval
+    this.eventCallback = options.eventCallback
+    this.errorCallback = options.errorCallback
+    this.task = undefined
+    this.cancelled = false
+
+    this.eventEmitter = new EventEmitter()
+    this.eventEmitter.on('tick', async () => {
+      await this.fetchEvents()
+    })
+    this.eventEmitter.emit('tick')
+  }
+
+  unsubscribe(): void {
+    this.eventEmitter.removeAllListeners()
+    this.cancelled = true
+    if (typeof this.task !== 'undefined') {
+      clearTimeout(this.task)
+    }
+  }
+
+  currentEventCount(): number {
+    return this.fromCount
+  }
+
+  private async fetchEvents() {
+    try {
+      const events = await this.provider.events.getEventsContractContractaddress(this.contractAddress, {
+        start: this.fromCount
+      })
+      if (this.cancelled) {
+        return
+      }
+
+      if (this.fromCount === events.nextStart) {
+        this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval)
+        return
+      }
+
+      const promises = events.events.map((event) => this.eventCallback(event))
+      await Promise.all(promises)
+      this.fromCount = events.nextStart
+      await this.fetchEvents()
+    } catch (err) {
+      await this.errorCallback(err, this)
+    }
+  }
+}
+
+export function subscribe(options: SubscribeOptions): Subscription {
+  return new Subscription(options)
+}

package/src/contract/index.ts

@@ -0,0 +1,21 @@
+/*
+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/>.
+*/
+
+export * from './ralph'
+export * from './contract'
+export * from './events'

package/src/contract/ralph.test.ts

@@ -0,0 +1,178 @@
+/*
+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 { node } from '../api'
+import * as ralph from './ralph'
+import * as utils from '../utils'
+import { Fields } from './contract'
+
+describe('contract', function () {
+  it('should encode I256', async () => {
+    function test(i256: bigint, expected: string) {
+      expect(utils.binToHex(ralph.encodeI256(i256))).toEqual(expected)
+    }
+    test(BigInt('0'), '00')
+    test(BigInt('1'), '01')
+    test(BigInt('2'), '02')
+    test(BigInt('-1'), '3f')
+    test(BigInt('-2'), '3e')
+    test(BigInt('32'), '4020')
+    test(BigInt('33'), '4021')
+    test(BigInt('34'), '4022')
+    test(BigInt('31'), '1f')
+    test(BigInt('30'), '1e')
+    test(BigInt('8192'), '80002000')
+    test(BigInt('8193'), '80002001')
+    test(BigInt('8194'), '80002002')
+    test(BigInt('8191'), '5fff')
+    test(BigInt('8190'), '5ffe')
+    test(BigInt('536870912'), 'c020000000')
+    test(BigInt('536870913'), 'c020000001')
+    test(BigInt('536870914'), 'c020000002')
+    test(BigInt('536870911'), '9fffffff')
+    test(BigInt('536870910'), '9ffffffe')
+    test(
+      BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819967'),
+      'dc7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+    )
+    test(
+      BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819966'),
+      'dc7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe'
+    )
+    test(
+      BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819965'),
+      'dc7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd'
+    )
+    test(
+      BigInt('-57896044618658097711785492504343953926634992332820282019728792003956564819968'),
+      'dc8000000000000000000000000000000000000000000000000000000000000000'
+    )
+    test(
+      BigInt('-57896044618658097711785492504343953926634992332820282019728792003956564819967'),
+      'dc8000000000000000000000000000000000000000000000000000000000000001'
+    )
+    test(
+      BigInt('-57896044618658097711785492504343953926634992332820282019728792003956564819966'),
+      'dc8000000000000000000000000000000000000000000000000000000000000002'
+    )
+
+    function fail(n: bigint) {
+      expect(() => ralph.encodeI256(n)).toThrow()
+    }
+    fail(BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819968'))
+    fail(BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819969'))
+    fail(BigInt('-57896044618658097711785492504343953926634992332820282019728792003956564819969'))
+    fail(BigInt('-57896044618658097711785492504343953926634992332820282019728792003956564819970'))
+  })
+
+  it('should encode U256', async () => {
+    function test(u256: bigint, expected: string) {
+      expect(utils.binToHex(ralph.encodeU256(u256))).toEqual(expected)
+    }
+    test(BigInt('0'), '00')
+    test(BigInt('1'), '01')
+    test(BigInt('2'), '02')
+    fail(BigInt('-1'))
+    fail(BigInt('-2'))
+    test(BigInt('64'), '4040')
+    test(BigInt('65'), '4041')
+    test(BigInt('66'), '4042')
+    test(BigInt('63'), '3f')
+    test(BigInt('62'), '3e')
+    test(BigInt('16384'), '80004000')
+    test(BigInt('16385'), '80004001')
+    test(BigInt('16386'), '80004002')
+    test(BigInt('16383'), '7fff')
+    test(BigInt('16382'), '7ffe')
+    test(BigInt('1073741824'), 'c040000000')
+    test(BigInt('1073741825'), 'c040000001')
+    test(BigInt('1073741826'), 'c040000002')
+    test(BigInt('1073741823'), 'bfffffff')
+    test(BigInt('1073741822'), 'bffffffe')
+    test(
+      BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639935'),
+      'dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
+    )
+    test(
+      BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639934'),
+      'dcfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe'
+    )
+    test(
+      BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639933'),
+      'dcfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd'
+    )
+
+    function fail(n: bigint) {
+      expect(() => ralph.encodeU256(n)).toThrow()
+    }
+    fail(BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639936'))
+    fail(BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639937'))
+  })
+
+  it('should encode ByteVec', async () => {
+    const bytes = 'b382fc88aa31d63f4c2f3f8a03715ba2a629552e85431fb1c1d909bab46d1aae'
+    const bytecode = ralph.encodeScriptFieldAsString('ByteVec', bytes)
+    expect(bytecode).toEqual('144020b382fc88aa31d63f4c2f3f8a03715ba2a629552e85431fb1c1d909bab46d1aae')
+  })
+
+  it('should test buildScriptByteCode', async () => {
+    const variables = { x: true, y: 0x05, z: 'ff', a: '1C2RAVWSuaXw8xtUxqVERR7ChKBE1XgscNFw73NSHE1v3' }
+    const fieldsSig: node.FieldsSig = {
+      signature: 'Not really',
+      names: ['x', 'y', 'z', 'a'],
+      types: ['Bool', 'U256', 'ByteVec', 'Address']
+    }
+    const bytecode = ralph.buildScriptByteCode('-{0}-{1}-{2}-{3}-', variables, fieldsSig)
+    expect(bytecode).toEqual('-03-1305-1401ff-1500a3cd757be03c7dac8d48bf79e2a7d6e735e018a9c054b99138c7b29738c437ec-')
+  })
+
+  it('should test buildContractByteCode', async () => {
+    const fields: Fields = {
+      a: -1,
+      b: 1,
+      c: '23',
+      d: '1C2RAVWSuaXw8xtUxqVERR7ChKBE1XgscNFw73NSHE1v3',
+      e: [false, true]
+    }
+    const fieldsSig: node.FieldsSig = {
+      signature: 'Not really',
+      names: ['a', 'b', 'c', 'd', 'e'],
+      types: ['I256', 'U256', 'ByteVec', 'Address', '[Bool;2]']
+    }
+    const encoded = ralph.buildContractByteCode('ff', fields, fieldsSig)
+    expect(encoded).toEqual(
+      'ff06013f02010301230400a3cd757be03c7dac8d48bf79e2a7d6e735e018a9c054b99138c7b29738c437ec00000001'
+    )
+  })
+
+  // it('should test buildByteCode', async () => {
+  //   const compiled = {
+  //     type: 'TemplateContractByteCode',
+  //     filedLength: 1,
+  //     methodsByteCode: [
+  //       '01000203021205160016015f{subContractId:ByteVec}1702a00016002a16012aa100a000160016011602010002',
+  //       '00000202020416001601000002'
+  //     ]
+  //   }
+  //   const variables = { subContractId: '55834baf25f40fe5a8d6ac83c5f2b76a1677ed3ddbd6a79c4dea274992982e2b' }
+  //   const bytecode = ralph.buildContractByteCode(compiled, variables)
+  //   expect(bytecode).toEqual(
+  //     '01024046405301000203021205160016015f14402055834baf25f40fe5a8d6ac83c5f2b76a1677ed3ddbd6a79c4dea274992982e2b1702a00016002a16012aa100a00016001601160201000200000202020416001601000002'
+  //   )
+  // })
+})

package/src/contract/ralph.ts

@@ -0,0 +1,362 @@
+/*
+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 { Buffer } from 'buffer/'
+import { bs58, isHexString } from '../utils'
+import { node } from '../api'
+import { Fields, Val } from './contract'
+
+const bigIntZero = BigInt(0)
+
+class UnSigned {
+  static readonly oneByteBound = BigInt(0x40)
+  static readonly twoByteBound = UnSigned.oneByteBound << BigInt(8)
+  static readonly fourByteBound = UnSigned.oneByteBound << BigInt(8 * 3)
+  static readonly u256UpperBound = BigInt(1) << BigInt(256)
+}
+
+class Signed {
+  static readonly oneByteBound = BigInt(0x20)
+  static readonly twoByteBound = Signed.oneByteBound << BigInt(8)
+  static readonly fourByteBound = Signed.oneByteBound << BigInt(8 * 3)
+  static readonly i256UpperBound = BigInt(1) << BigInt(255)
+  static readonly i256LowerBound = -this.i256UpperBound
+}
+
+class CompactInt {
+  static readonly oneBytePrefix = 0x00
+  static readonly oneByteNegPrefix = 0xc0
+  static readonly twoBytePrefix = 0x40
+  static readonly twoByteNegPrefix = 0x80
+  static readonly fourBytePrefix = 0x80
+  static readonly fourByteNegPrefix = 0x40
+  static readonly multiBytePrefix = 0xc0
+}
+
+export function encodeBool(bool: boolean): Uint8Array {
+  return bool ? Uint8Array.from([1]) : Uint8Array.from([0])
+}
+
+export function encodeI256(i256: bigint): Uint8Array {
+  if (i256 >= bigIntZero) {
+    return encodeI256Positive(i256)
+  } else {
+    return encodeI256Negative(i256)
+  }
+}
+
+// n should be positive
+function toByteArray(n: bigint, signed: boolean, notBit: boolean): Uint8Array {
+  let hex = n.toString(16)
+  if (hex.length % 2 === 1) {
+    hex = '0' + hex
+  } else if (signed && hex[0] >= '8') {
+    hex = '00' + hex // add the byte for sign
+  }
+
+  const byteLength = hex.length / 2
+  const bytes = new Uint8Array(byteLength + 1)
+  for (let index = 0; index < byteLength; index++) {
+    const offset = index * 2
+    const byte = parseInt(hex.slice(offset, offset + 2), 16)
+    bytes[`${index + 1}`] = notBit ? ~byte : byte
+  }
+
+  const header = byteLength - 4 + CompactInt.multiBytePrefix
+  bytes[0] = header
+  return bytes
+}
+
+function encodeI256Positive(i256: bigint): Uint8Array {
+  if (i256 < Signed.oneByteBound) {
+    return new Uint8Array([Number(i256) + CompactInt.oneBytePrefix])
+  } else if (i256 < Signed.twoByteBound) {
+    const num = Number(i256)
+    return new Uint8Array([(num >> 8) + CompactInt.twoBytePrefix, num & 0xff])
+  } else if (i256 < Signed.fourByteBound) {
+    const num = Number(i256)
+    return new Uint8Array([(num >> 24) + CompactInt.fourBytePrefix, (num >> 16) & 0xff, (num >> 8) & 0xff, num & 0xff])
+  } else if (i256 < Signed.i256UpperBound) {
+    return toByteArray(i256, true, false)
+  } else {
+    throw Error(`Too large number for i256: ${i256}`)
+  }
+}
+
+function encodeI256Negative(i256: bigint): Uint8Array {
+  if (i256 >= -Signed.oneByteBound) {
+    const num = Number(i256)
+    return new Uint8Array([(num ^ CompactInt.oneByteNegPrefix) & 0xff])
+  } else if (i256 >= -Signed.twoByteBound) {
+    const num = Number(i256)
+    return new Uint8Array([((num >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, num & 0xff])
+  } else if (i256 >= -Signed.fourByteBound) {
+    const num = Number(i256)
+    return new Uint8Array([
+      ((num >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
+      (num >> 16) & 0xff,
+      (num >> 8) & 0xff,
+      num & 0xff
+    ])
+  } else if (i256 >= Signed.i256LowerBound) {
+    return toByteArray(~i256, true, true)
+  } else {
+    throw Error(`Too small number for i256: ${i256}`)
+  }
+}
+
+export function encodeU256(u256: bigint): Uint8Array {
+  if (u256 < bigIntZero) {
+    throw Error(`Negative number for U256: ${u256}`)
+  } else if (u256 < UnSigned.oneByteBound) {
+    return new Uint8Array([Number(u256) + CompactInt.oneBytePrefix])
+  } else if (u256 < UnSigned.twoByteBound) {
+    const num = Number(u256)
+    return new Uint8Array([((num >> 8) & 0xff) + CompactInt.twoBytePrefix, num & 0xff])
+  } else if (u256 < UnSigned.fourByteBound) {
+    const num = Number(u256)
+    return new Uint8Array([
+      ((num >> 24) & 0xff) + CompactInt.fourBytePrefix,
+      (num >> 16) & 0xff,
+      (num >> 8) & 0xff,
+      num & 0xff
+    ])
+  } else if (u256 < UnSigned.u256UpperBound) {
+    return toByteArray(u256, false, false)
+  } else {
+    throw Error(`Too large number for U256: ${u256}`)
+  }
+}
+
+export function encodeByteVec(bytes: string): Uint8Array {
+  if (!isHexString(bytes)) {
+    throw Error(`Given value ${bytes} is not a valid hex string`)
+  }
+
+  const buffer0 = Buffer.from(bytes, 'hex')
+  const buffer1 = Buffer.from(encodeI256(BigInt(buffer0.length)))
+  return Buffer.concat([buffer1, buffer0])
+}
+
+export function encodeAddress(address: string): Uint8Array {
+  return bs58.decode(address)
+}
+
+function invalidScriptField(tpe: string, value: Val): Error {
+  return Error(`Invalid script field ${value} for type ${tpe}`)
+}
+
+enum Instruction {
+  trueConst = 3,
+  falseConst = 4,
+  i256Const0 = 5,
+  i256Const1 = 6,
+  i256Const2 = 7,
+  i256Const3 = 8,
+  i256Const4 = 9,
+  i256Const5 = 10,
+  i256ConstN1 = 11,
+  u256Const0 = 12,
+  u256Const1 = 13,
+  u256Const2 = 14,
+  u256Const3 = 15,
+  u256Const4 = 16,
+  u256Const5 = 17,
+  i256Const = 18,
+  u256Const = 19,
+  bytesConst = 20,
+  addressConst = 21
+}
+
+// TODO: optimize
+function encodeScriptFieldI256(value: bigint): Uint8Array {
+  return new Uint8Array([Instruction.i256Const, ...encodeI256(value)])
+}
+
+// TODO: optimize
+function encodeScriptFieldU256(value: bigint): Uint8Array {
+  return new Uint8Array([Instruction.u256Const, ...encodeU256(value)])
+}
+
+export function encodeScriptFieldAsString(tpe: string, value: Val): string {
+  return Buffer.from(encodeScriptField(tpe, value)).toString('hex')
+}
+
+export function encodeScriptField(tpe: string, value: Val): Uint8Array {
+  switch (tpe) {
+    case 'Bool':
+      if (typeof value === 'boolean') {
+        const byte = value ? Instruction.trueConst : Instruction.falseConst
+        return new Uint8Array([byte])
+      }
+      break
+    case 'I256':
+      if (typeof value === 'number' && Number.isInteger(value)) {
+        return encodeScriptFieldI256(BigInt(value))
+      } else if (typeof value === 'bigint') {
+        return encodeScriptFieldI256(value)
+      }
+      break
+    case 'U256':
+      if (typeof value === 'number' && Number.isInteger(value)) {
+        return encodeScriptFieldU256(BigInt(value))
+      } else if (typeof value === 'bigint') {
+        return encodeScriptFieldU256(value)
+      }
+      break
+    case 'ByteVec':
+      if (typeof value === 'string') {
+        return new Uint8Array([Instruction.bytesConst, ...encodeByteVec(value)])
+      }
+      break
+    case 'Address':
+      if (typeof value === 'string') {
+        return new Uint8Array([Instruction.addressConst, ...encodeAddress(value)])
+      }
+      break
+  }
+
+  throw invalidScriptField(tpe, value)
+}
+
+const scriptFieldRegex = /\{([0-9]*)\}/g
+
+export function buildScriptByteCode(bytecodeTemplate: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+  return bytecodeTemplate.replace(scriptFieldRegex, (_, fieldIndex: string) => {
+    const fieldName = fieldsSig.names[`${fieldIndex}`]
+    const fieldType = fieldsSig.types[`${fieldIndex}`]
+    if (fieldName in fields) {
+      const fieldValue = fields[`${fieldName}`]
+      return encodeScriptFieldAsString(fieldType, fieldValue)
+    } else {
+      throw new Error(`The value of field ${fieldName} is not provided`)
+    }
+  })
+}
+
+export function buildContractByteCode(bytecode: string, fields: Fields, fieldsSig: node.FieldsSig): string {
+  const fieldsEncoded = fieldsSig.names.flatMap((fieldName, fieldIndex) => {
+    const fieldType = fieldsSig.types[`${fieldIndex}`]
+    if (fieldName in fields) {
+      const fieldValue = fields[`${fieldName}`]
+      return encodeContractField(fieldType, fieldValue)
+    } else {
+      throw new Error(`The value of field ${fieldName} is not provided`)
+    }
+  })
+  const fieldsLength = Buffer.from(encodeI256(BigInt(fieldsEncoded.length))).toString('hex')
+  return bytecode + fieldsLength + fieldsEncoded.map((f) => Buffer.from(f).toString('hex')).join('')
+}
+
+enum ApiValType {
+  Bool = 0,
+  I256 = 1,
+  U256 = 2,
+  ByteVec = 3,
+  Address = 4
+}
+
+function encodeContractFieldI256(value: bigint): Uint8Array {
+  return new Uint8Array([ApiValType.I256, ...encodeI256(value)])
+}
+
+function encodeContractFieldU256(value: bigint): Uint8Array {
+  return new Uint8Array([ApiValType.U256, ...encodeU256(value)])
+}
+
+function encodeContractFieldArray(tpe: string, val: Val): Uint8Array[] {
+  if (!Array.isArray(val)) {
+    throw new Error(`Expected array, got ${val}`)
+  }
+
+  const semiColonIndex = tpe.lastIndexOf(';')
+  if (semiColonIndex == -1) {
+    throw new Error(`Invalid Array type: ${tpe}`)
+  }
+
+  const subType = tpe.slice(1, semiColonIndex)
+  const dim = parseInt(tpe.slice(semiColonIndex + 1, -1))
+  if ((val as Val[]).length != dim) {
+    throw new Error(`Invalid val dimension: ${val}`)
+  } else {
+    return (val as Val[]).flatMap((v) => encodeContractField(subType, v))
+  }
+}
+
+export function encodeContractField(tpe: string, value: Val): Uint8Array[] {
+  switch (tpe) {
+    case 'Bool':
+      if (typeof value === 'boolean') {
+        const byte = value ? 1 : 0
+        return [new Uint8Array([ApiValType.Bool, byte])]
+      }
+      break
+    case 'I256':
+      if (typeof value === 'number' && Number.isInteger(value)) {
+        return [encodeContractFieldI256(BigInt(value))]
+      } else if (typeof value === 'bigint') {
+        return [encodeContractFieldI256(value)]
+      }
+      break
+    case 'U256':
+      if (typeof value === 'number' && Number.isInteger(value)) {
+        return [encodeContractFieldU256(BigInt(value))]
+      } else if (typeof value === 'bigint') {
+        return [encodeContractFieldU256(value)]
+      }
+      break
+    case 'ByteVec':
+      if (typeof value === 'string') {
+        return [new Uint8Array([ApiValType.ByteVec, ...encodeByteVec(value)])]
+      }
+      break
+    case 'Address':
+      if (typeof value === 'string') {
+        return [new Uint8Array([ApiValType.Address, ...encodeAddress(value)])]
+      }
+      break
+
+    default:
+      // Array type
+      return encodeContractFieldArray(tpe, value)
+  }
+
+  throw invalidVal(tpe, value)
+}
+
+function invalidVal(tpe: string, value: Val): Error {
+  return Error(`Invalid API value ${value} for type ${tpe}`)
+}
+
+// export function buildContractByteCode(
+//   compiled: node.TemplateContractByteCode,
+//   templateVariables: TemplateVariables
+// ): string {
+//   const methodsBuilt = compiled.methodsByteCode.map((template) => buildByteCode(template, templateVariables))
+//   let count = 0
+//   const methodIndexes = methodsBuilt.map((hex) => {
+//     count += hex.length / 2
+//     return count
+//   })
+//   return (
+//     binToHex(encodeI256(BigInt(compiled.filedLength))) +
+//     binToHex(encodeI256(BigInt(methodIndexes.length))) +
+//     methodIndexes.map((index) => binToHex(encodeI256(BigInt(index)))).join('') +
+//     methodsBuilt.join('')
+//   )
+// }

package/src/fixtures/address.json

@@ -0,0 +1,36 @@
+{
+  "hash": "16sR3EMn2BdFgENRhz6N2TJ78nfaADdv3prKXUQMaB6m3",
+  "details": {
+    "balance": "string",
+    "txNumber": 0
+  },
+  "transactions": [
+    {
+      "hash": "string",
+      "blockHash": "string",
+      "timestamp": 0,
+      "inputs": [
+        {
+          "outputRef": {
+            "hint": 0,
+            "key": "string"
+          },
+          "unlockScript": "string",
+          "txHashRef": "string",
+          "address": "string",
+          "amount": "string"
+        }
+      ],
+      "outputs": [
+        {
+          "amount": "string",
+          "address": "string",
+          "lockTime": 0,
+          "spent": "string"
+        }
+      ],
+      "gasAmount": 0,
+      "gasPrice": "string"
+    }
+  ]
+}