@alephium/web3 0.42.0 → 0.44.0

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,40 +106,27 @@ 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 {
-    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])
-    return decodePositiveInt(value.mode, body)
-  }
-
-  fromU32(value: number): DecodedCompactInt {
-    return this.decode(this.encodeU32(value))
-  }
-
   toU256(value: DecodedCompactInt): bigint {
     const mode = value.mode & maskRest
     if (fixedSize(mode)) {
-      return BigInt(this.toU32(value))
+      const body = new Uint8Array([value.mode, ...value.rest])
+      return BigInt(decodePositiveInt(value.mode, body))
     } 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 +145,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 +182,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 +204,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 +249,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 +260,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 +274,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,22 +46,22 @@ 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))
+    const fieldLength = compactSignedIntCodec.toI32(halfDecoded.fieldLength)
+    const methodIndexes = halfDecoded.methodIndexes.value.map((v) => compactSignedIntCodec.toI32(v))
     const methods: Method[] = []
     for (let i = 0, start = 0; i < methodIndexes.length; i++) {
       const end = methodIndexes[i]
@@ -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,16 +15,15 @@ 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'
+import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
 import { P2C } from './lockup-script-codec'
 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,17 +73,16 @@ 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))
       }
     })
     const tokens: DecodedArray<Token> = {
-      length: compactUnsignedIntCodec.fromU32(tokensValue.length),
+      length: compactSignedIntCodec.fromI32(tokensValue.length),
       value: tokensValue
     }
 

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
 }

package/src/codec/input-codec.ts

@@ -15,10 +15,9 @@ 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 { AssetInput } from '../api/api-alephium'
-import { binToHex } from '../utils'
+import { binToHex, concatBytes, hexToBinUnsafe } from '../utils'
 import { UnlockScript, unlockScriptCodec } from './unlock-script-codec'
 import { Codec } from './codec'
 import { signedIntCodec } from './signed-int-codec'
@@ -27,7 +26,7 @@ import { ArrayCodec } from './array-codec'
 export interface Input {
   outputRef: {
     hint: number
-    key: Buffer
+    key: Uint8Array
   }
   unlockScript: UnlockScript
 }
@@ -41,14 +40,15 @@ export class InputCodec implements Codec<Input> {
       type: unlockScriptCodec.parser
     })
 
-  encode(input: Input): Buffer {
-    return Buffer.concat([
-      Buffer.from([...signedIntCodec.encode(input.outputRef.hint), ...input.outputRef.key]),
+  encode(input: Input): Uint8Array {
+    return concatBytes([
+      signedIntCodec.encode(input.outputRef.hint),
+      input.outputRef.key,
       unlockScriptCodec.encode(input.unlockScript)
     ])
   }
 
-  decode(input: Buffer): Input {
+  decode(input: Uint8Array): Input {
     return this.parser.parse(input)
   }
 
@@ -59,7 +59,7 @@ export class InputCodec implements Codec<Input> {
       const unlockScript = unlockScriptCodec.encode(input.unlockScript)
       return {
         outputRef: { hint, key },
-        unlockScript: unlockScript.toString('hex')
+        unlockScript: binToHex(unlockScript)
       }
     })
   }
@@ -67,8 +67,8 @@ export class InputCodec implements Codec<Input> {
   static fromAssetInputs(inputs: AssetInput[]): Input[] {
     return inputs.map((input) => {
       const hint = input.outputRef.hint
-      const key = Buffer.from(input.outputRef.key, 'hex')
-      const unlockScript = unlockScriptCodec.decode(Buffer.from(input.unlockScript, 'hex'))
+      const key = hexToBinUnsafe(input.outputRef.key)
+      const unlockScript = unlockScriptCodec.decode(hexToBinUnsafe(input.unlockScript))
       return {
         outputRef: { hint, key },
         unlockScript

package/src/codec/instr-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 { ArrayCodec, DecodedArray } from './array-codec'
 import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
@@ -458,7 +457,7 @@ export class InstrCodec implements Codec<Instr> {
       }
     })
 
-  encode(instr: Instr): Buffer {
+  encode(instr: Instr): Uint8Array {
     const instrValue = instr.value
     const result = [instr.code]
     const instrsWithIndex = [0x00, 0x01, 0x16, 0x17, 0xa0, 0xa1, 0xce]
@@ -480,10 +479,10 @@ export class InstrCodec implements Codec<Instr> {
       result.push(...signedIntCodec.encode((instrValue as InstrValueWithIndex).index))
     }
 
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): Instr {
+  decode(input: Uint8Array): Instr {
     return this.parser.parse(input)
   }
 }

package/src/codec/lockup-script-codec.ts

@@ -15,24 +15,23 @@ 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, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { ArrayCodec, DecodedArray } from './array-codec'
 
 export interface PublicKeyHash {
-  publicKeyHash: Buffer
+  publicKeyHash: Uint8Array
 }
 
 class PublicKeyHashCodec implements Codec<PublicKeyHash> {
   parser = Parser.start().buffer('publicKeyHash', { length: 32 })
 
-  encode(input: PublicKeyHash): Buffer {
+  encode(input: PublicKeyHash): Uint8Array {
     return input.publicKeyHash
   }
 
-  decode(input: Buffer): PublicKeyHash {
+  decode(input: Uint8Array): PublicKeyHash {
     return this.parser.parse(input)
   }
 }
@@ -48,11 +47,11 @@ export interface MultiSig {
 }
 
 export interface P2SH {
-  scriptHash: Buffer
+  scriptHash: Uint8Array
 }
 
 export interface P2C {
-  contractId: Buffer
+  contractId: Uint8Array
 }
 
 export interface LockupScript {
@@ -73,7 +72,7 @@ export class LockupScriptCodec implements Codec<LockupScript> {
       }
     })
 
-  encode(input: LockupScript): Buffer {
+  encode(input: LockupScript): Uint8Array {
     const result: number[] = [input.scriptType]
     if (input.scriptType === 0) {
       result.push(...(input.script as PublicKeyHash).publicKeyHash)
@@ -88,10 +87,10 @@ export class LockupScriptCodec implements Codec<LockupScript> {
       throw new Error(`Unsupported script type: ${input.scriptType}`)
     }
 
-    return Buffer.from(result)
+    return new Uint8Array(result)
   }
 
-  decode(input: Buffer): LockupScript {
+  decode(input: Uint8Array): LockupScript {
     return this.parser.parse(input)
   }
 }