@alephium/web3 0.41.0 → 0.43.0

package/src/codec/asset-output-codec.ts

@@ -15,17 +15,16 @@ 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 { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
 import { signedIntCodec } from './signed-int-codec'
 import { longCodec } from './long-codec'
 import { ByteString, byteStringCodec } from './bytestring-codec'
-import { LockupScript, MultiSig, P2C, P2SH, lockupScriptCodec } from './lockup-script-codec'
+import { LockupScript, MultiSig, P2SH, lockupScriptCodec } from './lockup-script-codec'
 import { FixedAssetOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
-import { bs58, binToHex } from '../utils'
+import { bs58, binToHex, hexToBinUnsafe, concatBytes } from '../utils'
 import { Codec } from './codec'
 import { PublicKeyHash } from './lockup-script-codec'
 import { Token, tokensCodec } from './token-codec'
@@ -33,7 +32,7 @@ import { Token, tokensCodec } from './token-codec'
 export interface AssetOutput {
   amount: DecodedCompactInt
   lockupScript: LockupScript
-  lockTime: Buffer
+  lockTime: Uint8Array
   tokens: DecodedArray<Token>
   additionalData: ByteString
 }
@@ -56,17 +55,16 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
       type: byteStringCodec.parser
     })
 
-  encode(input: AssetOutput): Buffer {
-    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
+  encode(input: AssetOutput): Uint8Array {
+    const amount = compactUnsignedIntCodec.encode(input.amount)
     const lockupScript = lockupScriptCodec.encode(input.lockupScript)
-    const lockTime = Buffer.from(input.lockTime)
-    const tokens = Buffer.from(tokensCodec.encode(input.tokens.value))
-    const additionalData = Buffer.from(byteStringCodec.encode(input.additionalData))
+    const tokens = tokensCodec.encode(input.tokens.value)
+    const additionalData = byteStringCodec.encode(input.additionalData)
 
-    return Buffer.concat([amount, lockupScript, lockTime, tokens, additionalData])
+    return concatBytes([amount, lockupScript, input.lockTime, tokens, additionalData])
   }
 
-  decode(input: Buffer): AssetOutput {
+  decode(input: Uint8Array): AssetOutput {
     return this.parser.parse(input)
   }
 
@@ -79,13 +77,13 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
     const lockTime = Number(longCodec.decode(output.lockTime))
     const tokens = output.tokens.value.map((token) => {
       return {
-        id: token.tokenId.toString('hex'),
+        id: binToHex(token.tokenId),
         amount: compactUnsignedIntCodec.toU256(token.amount).toString()
       }
     })
-    const message = output.additionalData.value.toString('hex')
+    const message = binToHex(output.additionalData.value)
     const scriptType = output.lockupScript.scriptType
-    const key = binToHex(blakeHash(Buffer.concat([txIdBytes, signedIntCodec.encode(index)])))
+    const key = binToHex(blakeHash(concatBytes([txIdBytes, signedIntCodec.encode(index)])))
     const outputLockupScript = output.lockupScript.script
     const address = bs58.encode(lockupScriptCodec.encode(output.lockupScript))
 
@@ -117,11 +115,11 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
   static fromFixedAssetOutput(fixedOutput: FixedAssetOutput): AssetOutput {
     const amount: DecodedCompactInt = compactUnsignedIntCodec.fromU256(BigInt(fixedOutput.attoAlphAmount))
 
-    const lockTime: Buffer = longCodec.encode(BigInt(fixedOutput.lockTime))
-    const lockupScript: LockupScript = lockupScriptCodec.decode(Buffer.from(bs58.decode(fixedOutput.address)))
+    const lockTime = longCodec.encode(BigInt(fixedOutput.lockTime))
+    const lockupScript: LockupScript = lockupScriptCodec.decode(bs58.decode(fixedOutput.address))
     const tokensValue = fixedOutput.tokens.map((token) => {
       return {
-        tokenId: Buffer.from(token.id, 'hex'),
+        tokenId: hexToBinUnsafe(token.id),
         amount: compactUnsignedIntCodec.fromU256(BigInt(token.amount))
       }
     })
@@ -129,7 +127,7 @@ export class AssetOutputCodec implements Codec<AssetOutput> {
       length: compactUnsignedIntCodec.fromU32(tokensValue.length),
       value: tokensValue
     }
-    const additionalDataValue = Buffer.from(fixedOutput.message, 'hex')
+    const additionalDataValue = hexToBinUnsafe(fixedOutput.message)
     const additionalData: ByteString = {
       length: compactUnsignedIntCodec.fromU32(additionalDataValue.length),
       value: additionalDataValue

package/src/codec/bigint-codec.ts

@@ -15,12 +15,11 @@ 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/'
 export class BigIntCodec {
-  static encode(value: bigint): Buffer {
+  static encode(value: bigint): Uint8Array {
     // Special case for zero.
     if (value === 0n) {
-      return Buffer.from([0])
+      return new Uint8Array([0])
     }
 
     const isNegative = value < 0n
@@ -62,10 +61,10 @@ export class BigIntCodec {
     }
 
     // The byte array needs to be reversed since we've constructed it in little-endian order.
-    return Buffer.from(new Uint8Array(bytes.reverse()))
+    return new Uint8Array(bytes.reverse())
   }
 
-  static decode(encoded: Buffer, signed: boolean): bigint {
+  static decode(encoded: Uint8Array, signed: boolean): bigint {
     // Special case for zero.
     if (encoded.length === 1 && encoded[0] === 0) {
       return 0n

package/src/codec/bytestring-codec.ts

@@ -15,14 +15,14 @@ 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 { Parser } from 'binary-parser'
 import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
+import { concatBytes } from '../utils'
 
 export interface ByteString {
   length: DecodedCompactInt
-  value: Buffer
+  value: Uint8Array
 }
 
 export class ByteStringCodec implements Codec<ByteString> {
@@ -36,19 +36,19 @@ export class ByteStringCodec implements Codec<ByteString> {
       }
     })
 
-  encode(input: ByteString): Buffer {
-    return Buffer.from([...compactUnsignedIntCodec.encode(input.length), ...input.value])
+  encode(input: ByteString): Uint8Array {
+    return concatBytes([compactUnsignedIntCodec.encode(input.length), input.value])
   }
 
-  decode(input: Buffer): ByteString {
+  decode(input: Uint8Array): ByteString {
     return this.parser.parse(input)
   }
 
-  encodeBuffer(input: Buffer): Buffer {
-    return Buffer.from([...compactUnsignedIntCodec.encodeU32(input.length), ...input])
+  encodeBytes(input: Uint8Array): Uint8Array {
+    return concatBytes([compactUnsignedIntCodec.encodeU32(input.length), input])
   }
 
-  decodeBuffer(input: Buffer): Buffer {
+  decodeBytes(input: Uint8Array): Uint8Array {
     return this.decode(input).value
   }
 }

package/src/codec/codec.ts

@@ -15,13 +15,12 @@ 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 { Parser } from 'binary-parser'
 
 export interface Codec<T> {
   parser: Parser
-  encode(input: T): Buffer
-  decode(input: Buffer): T
+  encode(input: T): Uint8Array
+  decode(input: Uint8Array): T
 }
 
 export function assert(value: boolean, message: string) {

package/src/codec/compact-int-codec.ts

@@ -15,11 +15,10 @@ 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 { Parser } from 'binary-parser'
 import { Codec, assert } from './codec'
 import { BigIntCodec } from './bigint-codec'
-import { ArrayCodec } from './array-codec'
+import { binToHex } from '../utils'
 
 export class CompactInt {
   static readonly oneBytePrefix = 0x00
@@ -66,24 +65,24 @@ export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
 
   parser = compactIntParser
 
-  encode(input: DecodedCompactInt): Buffer {
-    return Buffer.from([input.mode, ...input.rest])
+  encode(input: DecodedCompactInt): Uint8Array {
+    return new Uint8Array([input.mode, ...input.rest])
   }
 
-  encodeU32(value: number): Buffer {
+  encodeU32(value: number): Uint8Array {
     if (value < this.oneByteBound) {
-      return Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff])
+      return new Uint8Array([(CompactInt.oneBytePrefix + value) & 0xff])
     } else if (value < this.twoByteBound) {
-      return Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
+      return new Uint8Array([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
     } else if (value < this.fourByteBound) {
-      return Buffer.from([
+      return new Uint8Array([
         (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
         (value >> 16) & 0xff,
         (value >> 8) & 0xff,
         value & 0xff
       ])
     } else {
-      return Buffer.from([
+      return new Uint8Array([
         CompactInt.multiBytePrefix,
         (value >> 24) & 0xff,
         (value >> 16) & 0xff,
@@ -93,7 +92,7 @@ export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
     }
   }
 
-  encodeU256(value: bigint): Buffer {
+  encodeU256(value: bigint): Uint8Array {
     assert(value >= 0n, 'Value should be positive')
 
     if (value < this.fourByteBound) {
@@ -107,26 +106,26 @@ export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
       assert(bytes.length <= 32, 'Expect <= 32 bytes for U256')
 
       const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff
-      return Buffer.concat([Buffer.from([header]), bytes])
+      return new Uint8Array([header, ...bytes])
     }
   }
 
-  decodeU32(input: Buffer): number {
+  decodeU32(input: Uint8Array): number {
     const decoded = this.decode(input)
     return this.toU32(decoded)
   }
 
-  decodeU256(input: Buffer): bigint {
+  decodeU256(input: Uint8Array): bigint {
     const decoded = this.decode(input)
     return this.toU256(decoded)
   }
 
-  decode(input: Buffer): DecodedCompactInt {
+  decode(input: Uint8Array): DecodedCompactInt {
     return this.parser.parse(input)
   }
 
   toU32(value: DecodedCompactInt): number {
-    const body = Buffer.from([value.mode, ...value.rest])
+    const body = new Uint8Array([value.mode, ...value.rest])
     return decodePositiveInt(value.mode, body)
   }
 
@@ -140,7 +139,7 @@ export class CompactUnsignedIntCodec implements Codec<DecodedCompactInt> {
       return BigInt(this.toU32(value))
     } else {
       assert(value.rest.length <= 32, 'Expect <= 32 bytes for U256')
-      return BigIntCodec.decode(Buffer.from(value.rest), false)
+      return BigIntCodec.decode(value.rest, false)
     }
   }
 
@@ -159,34 +158,34 @@ export class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
 
   parser = compactIntParser
 
-  encode(input: DecodedCompactInt): Buffer {
-    return Buffer.from([input.mode, ...input.rest])
+  encode(input: DecodedCompactInt): Uint8Array {
+    return new Uint8Array([input.mode, ...input.rest])
   }
 
-  decode(input: Buffer): DecodedCompactInt {
+  decode(input: Uint8Array): DecodedCompactInt {
     return this.parser.parse(input)
   }
 
-  decodeI32(input: Buffer): number {
+  decodeI32(input: Uint8Array): number {
     const decoded = this.decode(input)
     return this.toI32(decoded)
   }
 
-  encodeI32(value: number): Buffer {
+  encodeI32(value: number): Uint8Array {
     if (value >= 0) {
       if (value < this.oneByteBound) {
-        return Buffer.from([(CompactInt.oneBytePrefix + value) & 0xff])
+        return new Uint8Array([(CompactInt.oneBytePrefix + value) & 0xff])
       } else if (value < this.twoByteBound) {
-        return Buffer.from([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
+        return new Uint8Array([(CompactInt.twoBytePrefix + (value >> 8)) & 0xff, value & 0xff])
       } else if (value < this.fourByteBound) {
-        return Buffer.from([
+        return new Uint8Array([
           (CompactInt.fourBytePrefix + (value >> 24)) & 0xff,
           (value >> 16) & 0xff,
           (value >> 8) & 0xff,
           value & 0xff
         ])
       } else {
-        return Buffer.from([
+        return new Uint8Array([
           CompactInt.multiBytePrefix,
           (value >> 24) & 0xff,
           (value >> 16) & 0xff,
@@ -196,18 +195,18 @@ export class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
       }
     } else {
       if (value >= -this.oneByteBound) {
-        return Buffer.from([(value ^ CompactInt.oneByteNegPrefix) & 0xff])
+        return new Uint8Array([(value ^ CompactInt.oneByteNegPrefix) & 0xff])
       } else if (value >= -this.twoByteBound) {
-        return Buffer.from([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff])
+        return new Uint8Array([((value >> 8) ^ CompactInt.twoByteNegPrefix) & 0xff, value & 0xff])
       } else if (value >= -this.fourByteBound) {
-        return Buffer.from([
+        return new Uint8Array([
           ((value >> 24) ^ CompactInt.fourByteNegPrefix) & 0xff,
           (value >> 16) & 0xff,
           (value >> 8) & 0xff,
           value & 0xff
         ])
       } else {
-        return Buffer.from([
+        return new Uint8Array([
           CompactInt.multiBytePrefix,
           (value >> 24) & 0xff,
           (value >> 16) & 0xff,
@@ -218,23 +217,23 @@ export class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
     }
   }
 
-  encodeI256(value: bigint): Buffer {
+  encodeI256(value: bigint): Uint8Array {
     if (value >= -0x20000000 && value < 0x20000000) {
       return this.encodeI32(Number(value))
     } else {
       const bytes = BigIntCodec.encode(value)
       const header = (bytes.length - 4 + CompactInt.multiBytePrefix) & 0xff
-      return Buffer.concat([Buffer.from([header]), bytes])
+      return new Uint8Array([header, ...bytes])
     }
   }
 
-  decodeI256(input: Buffer): bigint {
+  decodeI256(input: Uint8Array): bigint {
     const decoded = this.decode(input)
     return this.toI256(decoded)
   }
 
   toI32(value: DecodedCompactInt): number {
-    const body = Buffer.from([value.mode, ...value.rest])
+    const body = new Uint8Array([value.mode, ...value.rest])
     const mode = value.mode & maskRest
     if (fixedSize(mode)) {
       const isPositive = (value.mode & signFlag) == 0
@@ -263,7 +262,7 @@ export class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
       return BigInt(this.toI32(value))
     } else {
       assert(value.rest.length <= 32, 'Expect <= 32 bytes for I256')
-      return BigIntCodec.decode(Buffer.from(value.rest), true)
+      return BigIntCodec.decode(value.rest, true)
     }
   }
 
@@ -274,7 +273,7 @@ export class CompactSignedIntCodec implements Codec<DecodedCompactInt> {
 
 export const compactSignedIntCodec = new CompactSignedIntCodec()
 
-function decodePositiveInt(rawMode: number, body: Buffer): number {
+function decodePositiveInt(rawMode: number, body: Uint8Array): number {
   const mode = rawMode & maskRest
 
   switch (mode) {
@@ -288,14 +287,14 @@ function decodePositiveInt(rawMode: number, body: Buffer): number {
       return ((body[0] & maskMode) << 24) | ((body[1] & 0xff) << 16) | ((body[2] & 0xff) << 8) | (body[3] & 0xff)
     default:
       if (body.length === 5) {
-        return Number(BigInt('0x' + body.slice(1).toString('hex')))
+        return Number(BigInt('0x' + binToHex(body.slice(1))))
       } else {
         throw new Error(`decodePositiveInt: Expect 4 bytes int, but get ${body.length - 1} bytes int`)
       }
   }
 }
 
-function decodeNegativeInt(rawMode: number, body: Buffer) {
+function decodeNegativeInt(rawMode: number, body: Uint8Array) {
   const mode = rawMode & maskRest
   switch (mode) {
     case CompactInt.oneBytePrefix:

package/src/codec/contract-codec.ts

@@ -16,19 +16,19 @@ 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 { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { Codec } from './codec'
 import { compactSignedIntCodec, compactUnsignedIntCodec, DecodedCompactInt } from './compact-int-codec'
 import { Method, MethodCodec, methodCodec } from './method-codec'
+import { concatBytes } from '../utils'
 
 const compactSignedIntsCodec = new ArrayCodec(compactSignedIntCodec)
 
 export interface HalfDecodedContract {
   fieldLength: DecodedCompactInt
   methodIndexes: DecodedArray<DecodedCompactInt>
-  methods: Buffer
+  methods: Uint8Array
 }
 
 export interface Contract {
@@ -36,24 +36,6 @@ export interface Contract {
   methods: Method[]
 }
 
-export function toHalfDecoded(contract: Contract): HalfDecodedContract {
-  const fieldLength = compactSignedIntCodec.fromI32(contract.fieldLength)
-  const methods = contract.methods.map((m) => methodCodec.encode(MethodCodec.fromMethod(m)))
-  let count = 0
-  const methodIndexes = Array.from(Array(methods.length).keys()).map((index) => {
-    count += methods[`${index}`].length
-    return count
-  })
-  return {
-    fieldLength,
-    methodIndexes: {
-      length: compactSignedIntCodec.fromI32(methodIndexes.length),
-      value: methodIndexes.map((value) => compactSignedIntCodec.fromI32(value))
-    },
-    methods: methods.reduce((acc, buffer) => Buffer.concat([acc, buffer]))
-  }
-}
-
 export class ContractCodec implements Codec<HalfDecodedContract> {
   parser = Parser.start()
     .nest('fieldLength', {
@@ -64,19 +46,19 @@ export class ContractCodec implements Codec<HalfDecodedContract> {
     })
     .buffer('methods', { readUntil: 'eof' })
 
-  encode(input: HalfDecodedContract): Buffer {
-    return Buffer.from([
-      ...compactSignedIntCodec.encode(input.fieldLength),
-      ...compactSignedIntsCodec.encode(input.methodIndexes.value),
-      ...input.methods
+  encode(input: HalfDecodedContract): Uint8Array {
+    return concatBytes([
+      compactSignedIntCodec.encode(input.fieldLength),
+      compactSignedIntsCodec.encode(input.methodIndexes.value),
+      input.methods
     ])
   }
 
-  decode(input: Buffer): HalfDecodedContract {
+  decode(input: Uint8Array): HalfDecodedContract {
     return this.parser.parse(input)
   }
 
-  decodeContract(input: Buffer): Contract {
+  decodeContract(input: Uint8Array): Contract {
     const halfDecoded = this.decode(input)
     const fieldLength = compactUnsignedIntCodec.toU32(halfDecoded.fieldLength)
     const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compactUnsignedIntCodec.toU32(v))
@@ -90,6 +72,25 @@ export class ContractCodec implements Codec<HalfDecodedContract> {
 
     return { fieldLength, methods }
   }
+
+  encodeContract(contract: Contract): Uint8Array {
+    const fieldLength = compactSignedIntCodec.fromI32(contract.fieldLength)
+    const methods = contract.methods.map((m) => methodCodec.encode(MethodCodec.fromMethod(m)))
+    let count = 0
+    const methodIndexes = Array.from(Array(methods.length).keys()).map((index) => {
+      count += methods[`${index}`].length
+      return count
+    })
+    const halfDecoded = {
+      fieldLength,
+      methodIndexes: {
+        length: compactSignedIntCodec.fromI32(methodIndexes.length),
+        value: methodIndexes.map((value) => compactSignedIntCodec.fromI32(value))
+      },
+      methods: concatBytes(methods)
+    }
+    return this.encode(halfDecoded)
+  }
 }
 
 export const contractCodec = new ContractCodec()

package/src/codec/contract-output-codec.ts

@@ -15,7 +15,6 @@ 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 { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
 import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
@@ -24,7 +23,7 @@ import { Codec } from './codec'
 import { Token, tokensCodec } from './token-codec'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
-import { binToHex, bs58 } from '../utils'
+import { binToHex, bs58, concatBytes, hexToBinUnsafe } from '../utils'
 import { signedIntCodec } from './signed-int-codec'
 import { lockupScriptCodec } from './lockup-script-codec'
 
@@ -46,26 +45,26 @@ export class ContractOutputCodec implements Codec<ContractOutput> {
       type: tokensCodec.parser
     })
 
-  encode(input: ContractOutput): Buffer {
-    const amount = Buffer.from(compactUnsignedIntCodec.encode(input.amount))
+  encode(input: ContractOutput): Uint8Array {
+    const amount = compactUnsignedIntCodec.encode(input.amount)
     const lockupScript = input.lockupScript.contractId
-    const tokens = Buffer.from(tokensCodec.encode(input.tokens.value))
+    const tokens = tokensCodec.encode(input.tokens.value)
 
-    return Buffer.concat([amount, lockupScript, tokens])
+    return concatBytes([amount, lockupScript, tokens])
   }
 
-  decode(input: Buffer): ContractOutput {
+  decode(input: Uint8Array): ContractOutput {
     return this.parser.parse(input)
   }
 
   static convertToApiContractOutput(txIdBytes: Uint8Array, output: ContractOutput, index: number): ApiContractOutput {
     const hint = createHint(output.lockupScript.contractId)
-    const key = binToHex(blakeHash(Buffer.concat([txIdBytes, signedIntCodec.encode(index)])))
+    const key = binToHex(blakeHash(concatBytes([txIdBytes, signedIntCodec.encode(index)])))
     const attoAlphAmount = compactUnsignedIntCodec.toU256(output.amount).toString()
-    const address = bs58.encode(Buffer.concat([Buffer.from([0x03]), output.lockupScript.contractId]))
+    const address = bs58.encode(new Uint8Array([0x03, ...output.lockupScript.contractId]))
     const tokens = output.tokens.value.map((token) => {
       return {
-        id: token.tokenId.toString('hex'),
+        id: binToHex(token.tokenId),
         amount: compactUnsignedIntCodec.toU256(token.amount).toString()
       }
     })
@@ -74,12 +73,11 @@ export class ContractOutputCodec implements Codec<ContractOutput> {
 
   static convertToOutput(apiContractOutput: ApiContractOutput): ContractOutput {
     const amount: DecodedCompactInt = compactUnsignedIntCodec.fromU256(BigInt(apiContractOutput.attoAlphAmount))
-    const lockupScript: P2C = lockupScriptCodec.decode(Buffer.from(bs58.decode(apiContractOutput.address)))
-      .script as P2C
+    const lockupScript: P2C = lockupScriptCodec.decode(bs58.decode(apiContractOutput.address)).script as P2C
 
     const tokensValue = apiContractOutput.tokens.map((token) => {
       return {
-        tokenId: Buffer.from(token.id, 'hex'),
+        tokenId: hexToBinUnsafe(token.id),
         amount: compactUnsignedIntCodec.fromU256(BigInt(token.amount))
       }
     })

package/src/codec/contract-output-ref-codec.ts

@@ -15,25 +15,25 @@ 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 { Parser } from 'binary-parser'
 import { ArrayCodec } from './array-codec'
 import { Codec } from './codec'
 import { signedIntCodec } from './signed-int-codec'
+import { concatBytes } from '../utils'
 
 export interface ContractOutputRef {
   hint: number
-  key: Buffer
+  key: Uint8Array
 }
 
 export class ContractOutputRefCodec implements Codec<ContractOutputRef> {
   parser = Parser.start().int32('hint').buffer('key', { length: 32 })
 
-  encode(input: ContractOutputRef): Buffer {
-    return Buffer.concat([Buffer.from([...signedIntCodec.encode(input.hint), ...input.key])])
+  encode(input: ContractOutputRef): Uint8Array {
+    return concatBytes([signedIntCodec.encode(input.hint), input.key])
   }
 
-  decode(input: Buffer): ContractOutputRef {
+  decode(input: Uint8Array): ContractOutputRef {
     return this.parser.parse(input)
   }
 }

package/src/codec/either-codec.ts

@@ -15,7 +15,6 @@ 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 { Parser } from 'binary-parser'
 import { Codec } from './codec'
 
@@ -39,17 +38,17 @@ export class EitherCodec<L, R> implements Codec<Either<L, R>> {
       })
   ) {}
 
-  encode(input: Either<L, R>): Buffer {
+  encode(input: Either<L, R>): Uint8Array {
     const result = [input.either]
     if (input.either === 0) {
       result.push(...this.leftCodec.encode(input.value as L))
     } else {
       result.push(...this.rightCodec.encode(input.value as R))
     }
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): Either<L, R> {
+  decode(input: Uint8Array): Either<L, R> {
     const result = this.parser.parse(input)
     return {
       ...result,

package/src/codec/hash.ts

@@ -15,14 +15,13 @@ 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 blake from 'blakejs'
 
 export function blakeHash(raw: Uint8Array) {
   return blake.blake2b(raw, undefined, 32)
 }
 
-export function djbIntHash(bytes: Buffer): number {
+export function djbIntHash(bytes: Uint8Array): number {
   let hash = 5381
   bytes.forEach((byte) => {
     hash = (hash << 5) + hash + (byte & 0xff)
@@ -30,6 +29,6 @@ export function djbIntHash(bytes: Buffer): number {
   return hash
 }
 
-export function createHint(input: Buffer): number {
+export function createHint(input: Uint8Array): number {
   return djbIntHash(input) | 1
 }