@btc-vision/bitcoin 6.5.6 → 7.0.0-alpha.1

package/src/pubkey.ts

@@ -3,32 +3,33 @@
  * @packageDocumentation
  */
 import { Point } from '@noble/secp256k1';
+import { alloc, concat, equals, fromHex, toHex } from './io/index.js';
+import type { PublicKey, XOnlyPublicKey } from './types.js';
 
 /**
  * Converts a public key to x-only format (32 bytes).
  * @param pubKey - The public key buffer (33 or 65 bytes)
  * @returns The x-only public key (32 bytes)
  */
-export const toXOnly = (pubKey: Buffer | Uint8Array): Buffer => {
-    const buffer = pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
-    return Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+export const toXOnly = (pubKey: PublicKey | XOnlyPublicKey): XOnlyPublicKey => {
+    return (pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33)) as XOnlyPublicKey;
 };
 
 export interface UncompressedPublicKey {
-    hybrid: Buffer;
-    uncompressed: Buffer;
+    hybrid: Uint8Array;
+    uncompressed: Uint8Array;
 }
 
 /**
- * Converts bigint to 32-byte Buffer.
+ * Converts bigint to 32-byte Uint8Array.
  */
-export function bigIntTo32Bytes(num: bigint): Buffer {
+export function bigIntTo32Bytes(num: bigint): Uint8Array {
     let hex = num.toString(16);
     hex = hex.padStart(64, '0');
     if (hex.length > 64) {
         hex = hex.slice(-64);
     }
-    return Buffer.from(hex, 'hex');
+    return fromHex(hex);
 }
 
 /**
@@ -36,11 +37,9 @@ export function bigIntTo32Bytes(num: bigint): Buffer {
  * to its "hybrid" form (prefix 0x06/0x07), then derives a P2PKH address from it.
  *
  * @param realPubKey - 33-byte compressed (0x02/0x03) or 65-byte uncompressed (0x04) pubkey
- * @returns Buffer | undefined
+ * @returns UncompressedPublicKey | undefined
  */
-export function decompressPublicKey(
-    realPubKey: Uint8Array | Buffer,
-): UncompressedPublicKey | undefined {
+export function decompressPublicKey(realPubKey: PublicKey): UncompressedPublicKey | undefined {
     if (realPubKey.length === 32) {
         return;
     }
@@ -54,7 +53,7 @@ export function decompressPublicKey(
 
     let point: Point;
     try {
-        point = Point.fromHex(Buffer.from(realPubKey).toString('hex'));
+        point = Point.fromHex(toHex(realPubKey));
     } catch (err) {
         throw new Error('Invalid secp256k1 public key bytes. Cannot parse.');
     }
@@ -65,12 +64,12 @@ export function decompressPublicKey(
     const isEven = point.y % 2n === 0n;
     const prefix = isEven ? 0x06 : 0x07;
 
-    const hybridPubKey = Buffer.alloc(65);
+    const hybridPubKey = alloc(65);
     hybridPubKey[0] = prefix;
-    xBuf.copy(hybridPubKey, 1);
-    yBuf.copy(hybridPubKey, 33);
+    hybridPubKey.set(xBuf, 1);
+    hybridPubKey.set(yBuf, 33);
 
-    const uncompressedPubKey = Buffer.concat([Buffer.from([0x04]), xBuf, yBuf]);
+    const uncompressedPubKey = concat([new Uint8Array([0x04]), xBuf, yBuf]);
 
     return {
         hybrid: hybridPubKey,
@@ -79,20 +78,20 @@ export function decompressPublicKey(
 }
 
 /**
- * Compare two potential pubkey Buffers, treating hybrid keys (0x06/0x07)
+ * Compare two potential pubkey Uint8Arrays, treating hybrid keys (0x06/0x07)
  * as equivalent to uncompressed (0x04).
  */
-export function pubkeysMatch(a: Buffer, b: Buffer): boolean {
-    if (a.equals(b)) return true;
+export function pubkeysMatch(a: Uint8Array, b: Uint8Array): boolean {
+    if (equals(a, b)) return true;
 
     if (a.length === 65 && b.length === 65) {
-        const aCopy = Buffer.from(a);
-        const bCopy = Buffer.from(b);
+        const aCopy = new Uint8Array(a);
+        const bCopy = new Uint8Array(b);
 
         if (aCopy[0] === 0x06 || aCopy[0] === 0x07) aCopy[0] = 0x04;
         if (bCopy[0] === 0x06 || bCopy[0] === 0x07) bCopy[0] = 0x04;
 
-        return aCopy.equals(bCopy);
+        return equals(aCopy, bCopy);
     }
 
     return false;

package/src/push_data.ts

@@ -19,27 +19,28 @@ export function encodingLength(i: number): number {
  * @param offset - The offset at which to start writing the encoded buffer.
  * @returns The size of the encoded buffer.
  */
-export function encode(buffer: Buffer, num: number, offset: number): number {
+export function encode(buffer: Uint8Array, num: number, offset: number): number {
     const size = encodingLength(num);
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
 
     // ~6 bit
     if (size === 1) {
-        buffer.writeUInt8(num, offset);
+        buffer[offset] = num;
 
         // 8 bit
     } else if (size === 2) {
-        buffer.writeUInt8(opcodes.OP_PUSHDATA1, offset);
-        buffer.writeUInt8(num, offset + 1);
+        buffer[offset] = opcodes.OP_PUSHDATA1;
+        buffer[offset + 1] = num;
 
         // 16 bit
     } else if (size === 3) {
-        buffer.writeUInt8(opcodes.OP_PUSHDATA2, offset);
-        buffer.writeUInt16LE(num, offset + 1);
+        buffer[offset] = opcodes.OP_PUSHDATA2;
+        view.setUint16(offset + 1, num, true);
 
         // 32 bit
     } else {
-        buffer.writeUInt8(opcodes.OP_PUSHDATA4, offset);
-        buffer.writeUInt32LE(num, offset + 1);
+        buffer[offset] = opcodes.OP_PUSHDATA4;
+        view.setUint32(offset + 1, num, true);
     }
 
     return size;
@@ -52,32 +53,33 @@ export function encode(buffer: Buffer, num: number, offset: number): number {
  * @returns An object containing the opcode, number, and size, or null if decoding fails.
  */
 export function decode(
-    buffer: Buffer,
+    buffer: Uint8Array,
     offset: number,
 ): {
     opcode: number;
     number: number;
     size: number;
 } | null {
-    const opcode = buffer.readUInt8(offset);
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const opcode = buffer[offset];
     let num: number;
     let size: number;
 
     // ~6 bit
-    if (opcode < opcodes.OP_PUSHDATA1) {
-        num = opcode;
+    if (opcode! < opcodes.OP_PUSHDATA1) {
+        num = opcode!;
         size = 1;
 
         // 8 bit
     } else if (opcode === opcodes.OP_PUSHDATA1) {
         if (offset + 2 > buffer.length) return null;
-        num = buffer.readUInt8(offset + 1);
+        num = buffer[offset + 1]!;
         size = 2;
 
         // 16 bit
     } else if (opcode === opcodes.OP_PUSHDATA2) {
         if (offset + 3 > buffer.length) return null;
-        num = buffer.readUInt16LE(offset + 1);
+        num = view.getUint16(offset + 1, true);
         size = 3;
 
         // 32 bit
@@ -85,12 +87,12 @@ export function decode(
         if (offset + 5 > buffer.length) return null;
         if (opcode !== opcodes.OP_PUSHDATA4) throw new Error('Unexpected opcode');
 
-        num = buffer.readUInt32LE(offset + 1);
+        num = view.getUint32(offset + 1, true);
         size = 5;
     }
 
     return {
-        opcode,
+        opcode: opcode!,
         number: num,
         size,
     };

package/src/script.ts

@@ -3,74 +3,79 @@
  * @packageDocumentation
  */
 import * as bip66 from './bip66.js';
-import { Opcodes, opcodes, REVERSE_OPS } from './opcodes.js';
+import { alloc, fromHex, toHex } from './io/index.js';
+import type { Opcodes } from './opcodes.js';
+import { opcodes, REVERSE_OPS } from './opcodes.js';
 import * as pushdata from './push_data.js';
 import * as scriptNumber from './script_number.js';
 import * as scriptSignature from './script_signature.js';
+import { isDefinedHashType } from './script_signature.js';
+import type { Script, Stack } from './types.js';
 import * as types from './types.js';
-import type { Stack } from './types.js';
-
-const { typeforce } = types;
 
 const OP_INT_BASE = opcodes.OP_RESERVED; // OP_1 - 1
 export { opcodes };
 
 function isOPInt(value: number): boolean {
     return (
-        types.Number(value) &&
+        types.isNumber(value) &&
         (value === opcodes.OP_0 ||
             (value >= opcodes.OP_1 && value <= opcodes.OP_16) ||
             value === opcodes.OP_1NEGATE)
     );
 }
 
-function isPushOnlyChunk(value: number | Buffer): boolean {
-    return types.Buffer(value) || isOPInt(value as number);
+function isPushOnlyChunk(value: number | Uint8Array): boolean {
+    if (value instanceof Uint8Array) return true;
+    return isOPInt(value);
 }
 
 export function isPushOnly(value: Stack): boolean {
-    return types.Array(value) && value.every(isPushOnlyChunk);
+    return types.isArray(value) && value.every(isPushOnlyChunk);
 }
 
 export function countNonPushOnlyOPs(value: Stack): number {
     return value.length - value.filter(isPushOnlyChunk).length;
 }
 
-function asMinimalOP(buffer: Buffer): number | undefined {
+function asMinimalOP(buffer: Uint8Array): number | undefined {
     if (buffer.length === 0) return opcodes.OP_0;
-    if (buffer.length !== 1) return;
-    if (buffer[0] >= 1 && buffer[0] <= 16) return OP_INT_BASE + buffer[0];
+    if (buffer.length !== 1) return undefined;
+    if (buffer[0]! >= 1 && buffer[0]! <= 16) return OP_INT_BASE + buffer[0]!;
     if (buffer[0] === 0x81) return opcodes.OP_1NEGATE;
+    return undefined;
 }
 
-function chunksIsBuffer(buf: Buffer | Stack): buf is Buffer {
-    return Buffer.isBuffer(buf);
+function chunksIsUint8Array(buf: Uint8Array | Stack): buf is Uint8Array {
+    return buf instanceof Uint8Array;
 }
 
-function chunksIsArray(buf: Buffer | Stack): buf is Stack {
-    return types.Array(buf);
+function chunksIsArray(buf: Uint8Array | Stack): buf is Stack {
+    return types.isArray(buf);
 }
 
-function singleChunkIsBuffer(buf: number | Buffer): buf is Buffer {
-    return Buffer.isBuffer(buf);
+function singleChunkIsUint8Array(buf: number | Uint8Array): buf is Uint8Array {
+    return buf instanceof Uint8Array;
 }
 
 /**
- * Compiles an array of chunks into a Buffer.
+ * Compiles an array of chunks into a Uint8Array.
  *
  * @param chunks - The array of chunks to compile.
- * @returns The compiled Buffer.
+ * @returns The compiled Uint8Array.
  * @throws Error if the compilation fails.
  */
-export function compile(chunks: Buffer | Stack): Buffer {
-    // TODO: remove me
-    if (chunksIsBuffer(chunks)) return chunks;
+export function compile(chunks: Uint8Array | Stack): Script {
+    // Already compiled - return as-is
+    if (chunksIsUint8Array(chunks)) return chunks as Script;
 
-    typeforce(types.Array, chunks);
+    if (!types.isArray(chunks)) {
+        throw new TypeError('Expected an array');
+    }
 
     const bufferSize = chunks.reduce((accum: number, chunk) => {
         // data chunk
-        if (singleChunkIsBuffer(chunk)) {
+        if (singleChunkIsUint8Array(chunk)) {
             // adhere to BIP62.3, minimal push policy
             if (chunk.length === 1 && asMinimalOP(chunk) !== undefined) {
                 return accum + 1;
@@ -83,46 +88,48 @@ export function compile(chunks: Buffer | Stack): Buffer {
         return accum + 1;
     }, 0.0);
 
-    const buffer = Buffer.allocUnsafe(bufferSize);
+    const buffer = new Uint8Array(bufferSize);
     let offset = 0;
 
     chunks.forEach((chunk) => {
         // data chunk
-        if (singleChunkIsBuffer(chunk)) {
+        if (singleChunkIsUint8Array(chunk)) {
             // adhere to BIP62.3, minimal push policy
             const opcode = asMinimalOP(chunk);
             if (opcode !== undefined) {
-                buffer.writeUInt8(opcode, offset);
+                buffer[offset] = opcode;
                 offset += 1;
                 return;
             }
 
             offset += pushdata.encode(buffer, chunk.length, offset);
-            chunk.copy(buffer, offset);
+            buffer.set(chunk, offset);
             offset += chunk.length;
 
             // opcode
         } else {
-            buffer.writeUInt8(chunk, offset);
+            buffer[offset] = chunk;
             offset += 1;
         }
     });
 
     if (offset !== buffer.length) throw new Error('Could not decode chunks');
-    return buffer;
+    return buffer as Script;
 }
 
-export function decompile(buffer: Buffer | Array<number | Buffer>): Array<number | Buffer> | null {
-    // TODO: remove me
-    if (chunksIsArray(buffer)) return buffer;
+export function decompile(buffer: Uint8Array | Stack): Array<number | Uint8Array> | null {
+    // Already decompiled - return as-is
+    if (chunksIsArray(buffer)) return buffer as Array<number | Uint8Array>;
 
-    typeforce(types.Buffer, buffer);
+    if (!(buffer instanceof Uint8Array)) {
+        throw new TypeError('Expected a Uint8Array');
+    }
 
-    const chunks: Array<number | Buffer> = [];
+    const chunks: Array<number | Uint8Array> = [];
     let i = 0;
 
     while (i < buffer.length) {
-        const opcode = buffer[i];
+        const opcode = buffer[i]!;
 
         // data chunk
         if (opcode > opcodes.OP_0 && opcode <= opcodes.OP_PUSHDATA4) {
@@ -159,23 +166,27 @@ export function decompile(buffer: Buffer | Array<number | Buffer>): Array<number
 
 /**
  * Converts the given chunks into an ASM (Assembly) string representation.
- * If the chunks parameter is a Buffer, it will be decompiled into a Stack before conversion.
+ * If the chunks parameter is a Uint8Array, it will be decompiled into a Stack before conversion.
  * @param chunks - The chunks to convert into ASM.
  * @returns The ASM string representation of the chunks.
  */
-export function toASM(chunks: Buffer | Array<number | Buffer>): string {
-    if (chunksIsBuffer(chunks)) {
-        chunks = decompile(chunks) as Stack;
-    }
-    if (!chunks) {
-        throw new Error('Could not convert invalid chunks to ASM');
+export function toASM(chunks: Uint8Array | Stack): string {
+    let resolved: Stack;
+    if (chunksIsUint8Array(chunks)) {
+        const decompiled = decompile(chunks);
+        if (!decompiled) {
+            throw new Error('Could not convert invalid chunks to ASM');
+        }
+        resolved = decompiled;
+    } else {
+        resolved = chunks;
     }
-    return chunks
+    return resolved
         .map((chunk) => {
             // data?
-            if (singleChunkIsBuffer(chunk)) {
+            if (singleChunkIsUint8Array(chunk)) {
                 const op = asMinimalOP(chunk);
-                if (op === undefined) return chunk.toString('hex');
+                if (op === undefined) return toHex(chunk);
                 chunk = op;
             }
 
@@ -186,12 +197,14 @@ export function toASM(chunks: Buffer | Array<number | Buffer>): string {
 }
 
 /**
- * Converts an ASM string to a Buffer.
+ * Converts an ASM string to a Uint8Array.
  * @param asm The ASM string to convert.
- * @returns The converted Buffer.
+ * @returns The converted Uint8Array.
  */
-export function fromASM(asm: string): Buffer {
-    typeforce(types.String, asm);
+export function fromASM(asm: string): Script {
+    if (typeof asm !== 'string') {
+        throw new TypeError('Expected a string');
+    }
 
     return compile(
         asm.split(' ').map((chunkStr) => {
@@ -199,41 +212,43 @@ export function fromASM(asm: string): Buffer {
             if (opcodes[chunkStr as keyof Opcodes] !== undefined) {
                 return opcodes[chunkStr as keyof Opcodes];
             }
-            typeforce(types.Hex, chunkStr);
+            if (!types.isHex(chunkStr)) {
+                throw new TypeError('Expected hex string');
+            }
 
             // data!
-            return Buffer.from(chunkStr, 'hex');
+            return fromHex(chunkStr);
         }),
     );
 }
 
 /**
- * Converts the given chunks into a stack of buffers.
+ * Converts the given chunks into a stack of Uint8Arrays.
  *
  * @param chunks - The chunks to convert.
- * @returns The stack of buffers.
+ * @returns The stack of Uint8Arrays.
  */
-export function toStack(chunks: Buffer | Array<number | Buffer>): Buffer[] {
-    chunks = decompile(chunks) as Stack;
-    typeforce(isPushOnly, chunks);
+export function toStack(chunks: Uint8Array | Stack): Uint8Array[] {
+    const resolved = chunksIsUint8Array(chunks) ? decompile(chunks) : chunks;
+    if (!resolved || !isPushOnly(resolved)) {
+        throw new TypeError('Expected push-only script');
+    }
 
-    return chunks.map((op) => {
-        if (singleChunkIsBuffer(op)) return op;
-        if (op === opcodes.OP_0) return Buffer.allocUnsafe(0);
+    return resolved.map((op) => {
+        if (singleChunkIsUint8Array(op)) return op;
+        if (op === opcodes.OP_0) return alloc(0);
 
         return scriptNumber.encode(op - OP_INT_BASE);
     });
 }
 
-export function isCanonicalPubKey(buffer: Buffer): boolean {
+export function isCanonicalPubKey(buffer: Uint8Array): boolean {
     return types.isPoint(buffer);
 }
 
-import { isDefinedHashType } from './script_signature.js';
-
-export function isCanonicalScriptSignature(buffer: Buffer): boolean {
-    if (!Buffer.isBuffer(buffer)) return false;
-    if (!isDefinedHashType(buffer[buffer.length - 1])) return false;
+export function isCanonicalScriptSignature(buffer: Uint8Array): boolean {
+    if (!(buffer instanceof Uint8Array)) return false;
+    if (!isDefinedHashType(buffer[buffer.length - 1]!)) return false;
 
     return bip66.check(buffer.subarray(0, -1));
 }

package/src/script_number.ts

@@ -16,8 +16,8 @@ export function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): n
     if (length === 0) return 0;
     if (length > maxLength) throw new TypeError('Script number overflow');
     if (minimal) {
-        if ((buffer[length - 1] & 0x7f) === 0) {
-            if (length <= 1 || (buffer[length - 2] & 0x80) === 0)
+        if ((buffer[length - 1]! & 0x7f) === 0) {
+            if (length <= 1 || (buffer[length - 2]! & 0x80) === 0)
                 throw new Error('Non-minimally encoded script number');
         }
     }
@@ -34,10 +34,10 @@ export function decode(buffer: Buffer, maxLength?: number, minimal?: boolean): n
     // 32-bit / 24-bit / 16-bit / 8-bit
     let result = 0;
     for (let i = 0; i < length; ++i) {
-        result |= buffer[i] << (8 * i);
+        result |= buffer[i]! << (8 * i);
     }
 
-    if (buffer[length - 1] & 0x80) return -(result & ~(0x80 << (8 * (length - 1))));
+    if (buffer[length - 1]! & 0x80) return -(result & ~(0x80 << (8 * (length - 1))));
     return result;
 }
 
@@ -62,10 +62,10 @@ export function encode(_number: number): Buffer {
         value >>= 8;
     }
 
-    if (buffer[size - 1] & 0x80) {
+    if (buffer[size - 1]! & 0x80) {
         buffer.writeUInt8(negative ? 0x80 : 0x00, size - 1);
     } else if (negative) {
-        buffer[size - 1] |= 0x80;
+        buffer[size - 1]! |= 0x80;
     }
 
     return buffer;

package/src/script_signature.ts

@@ -1,9 +1,8 @@
 import * as bip66 from './bip66.js';
-import * as types from './types.js';
+import { alloc, concat } from './io/index.js';
+import { isUInt8, isUint8ArrayN } from './types.js';
 
-const { typeforce } = types;
-
-const ZERO = Buffer.alloc(1, 0);
+const ZERO = new Uint8Array([0]);
 
 /**
  * Checks if a hash type is defined (valid for Bitcoin signatures).
@@ -16,48 +15,48 @@ export function isDefinedHashType(hashType: number): boolean {
 }
 
 /**
- * Converts a buffer to a DER-encoded buffer.
- * @param x - The buffer to be converted.
- * @returns The DER-encoded buffer.
+ * Converts a Uint8Array to a DER-encoded Uint8Array.
+ * @param x - The Uint8Array to be converted.
+ * @returns The DER-encoded Uint8Array.
  */
-function toDER(x: Buffer): Buffer {
+function toDER(x: Uint8Array): Uint8Array {
     let i = 0;
     while (x[i] === 0) ++i;
     if (i === x.length) return ZERO;
     x = x.subarray(i);
-    if (x[0] & 0x80) return Buffer.concat([ZERO, x], 1 + x.length);
+    if (x[0]! & 0x80) return concat([ZERO, x]);
     return x;
 }
 
 /**
- * Converts a DER-encoded signature to a buffer.
- * If the first byte of the input buffer is 0x00, it is skipped.
- * The resulting buffer is 32 bytes long, filled with zeros if necessary.
+ * Converts a DER-encoded signature to a Uint8Array.
+ * If the first byte of the input is 0x00, it is skipped.
+ * The resulting Uint8Array is 32 bytes long, filled with zeros if necessary.
  * @param x - The DER-encoded signature.
- * @returns The converted buffer.
+ * @returns The converted Uint8Array.
  */
-function fromDER(x: Buffer): Buffer {
+function fromDER(x: Uint8Array): Uint8Array {
     if (x[0] === 0x00) x = x.subarray(1);
-    const buffer = Buffer.alloc(32, 0);
+    const buffer = alloc(32);
     const bstart = Math.max(0, 32 - x.length);
-    x.copy(buffer, bstart);
+    buffer.set(x, bstart);
     return buffer;
 }
 
-interface ScriptSignature {
-    signature: Buffer;
+export interface ScriptSignature {
+    signature: Uint8Array;
     hashType: number;
 }
 
 // BIP62: 1 byte hashType flag (only 0x01, 0x02, 0x03, 0x81, 0x82 and 0x83 are allowed)
 /**
- * Decodes a buffer into a ScriptSignature object.
- * @param buffer - The buffer to decode.
+ * Decodes a Uint8Array into a ScriptSignature object.
+ * @param buffer - The Uint8Array to decode.
  * @returns The decoded ScriptSignature object.
  * @throws Error if the hashType is invalid.
  */
-export function decode(buffer: Buffer): ScriptSignature {
-    const hashType = buffer.readUInt8(buffer.length - 1);
+export function decode(buffer: Uint8Array): ScriptSignature {
+    const hashType = buffer[buffer.length - 1]!;
     if (!isDefinedHashType(hashType)) {
         throw new Error(`Invalid hashType ${hashType}`);
     }
@@ -65,36 +64,34 @@ export function decode(buffer: Buffer): ScriptSignature {
     const decoded = bip66.decode(buffer.subarray(0, -1));
     const r = fromDER(decoded.r);
     const s = fromDER(decoded.s);
-    const signature = Buffer.concat([r, s], 64);
+    const signature = concat([r, s]);
 
     return { signature, hashType };
 }
 
 /**
- * Encodes a signature and hash type into a buffer.
+ * Encodes a signature and hash type into a Uint8Array.
  * @param signature - The signature to encode.
  * @param hashType - The hash type to encode.
- * @returns The encoded buffer.
+ * @returns The encoded Uint8Array.
  * @throws Error if the hashType is invalid.
  */
-export function encode(signature: Buffer, hashType: number): Buffer {
-    typeforce(
-        {
-            signature: types.BufferN(64),
-            hashType: types.UInt8,
-        },
-        { signature, hashType },
-    );
+export function encode(signature: Uint8Array, hashType: number): Uint8Array {
+    if (!isUint8ArrayN(signature, 64)) {
+        throw new TypeError('Expected signature to be a 64-byte Uint8Array');
+    }
+    if (!isUInt8(hashType)) {
+        throw new TypeError('Expected hashType to be a UInt8');
+    }
 
     if (!isDefinedHashType(hashType)) {
         throw new Error(`Invalid hashType ${hashType}`);
     }
 
-    const hashTypeBuffer = Buffer.allocUnsafe(1);
-    hashTypeBuffer.writeUInt8(hashType, 0);
+    const hashTypeBuffer = new Uint8Array([hashType]);
 
     const r = toDER(signature.subarray(0, 32));
     const s = toDER(signature.subarray(32, 64));
 
-    return Buffer.concat([bip66.encode(r, s), hashTypeBuffer]);
+    return concat([bip66.encode(r, s), hashTypeBuffer]);
 }