xpi-ts 0.2.13 → 0.2.15

package/dist/esm/lib/bitcore/block/merkleblock.js

@@ -0,0 +1,295 @@
+import { Buffer } from 'buffer/';
+import { BlockHeader, } from './blockheader.js';
+import { BufferReader } from '../encoding/bufferreader.js';
+import { BufferWriter } from '../encoding/bufferwriter.js';
+import { Hash } from '../crypto/hash.js';
+import { BufferUtil, NULL_HASH } from '../util/buffer.js';
+import { Transaction } from '../transaction/index.js';
+import { BitcoreError } from '../errors.js';
+import { Preconditions as $ } from '../util/preconditions.js';
+import { bitsToBytes, bytesToBits, extractBit } from '../util/bits.js';
+import { calcTreeWidth } from '../util/merkle.js';
+export class InvalidMerkleBlockError extends Error {
+    code;
+    context;
+    constructor(message, context = {}) {
+        super(message);
+        this.name = 'InvalidMerkleBlockError';
+        this.code = 'INVALID_MERKLE_BLOCK';
+        this.context = context;
+    }
+}
+export class MerkleBlockValidationError extends Error {
+    code;
+    context;
+    constructor(message, context = {}) {
+        super(message);
+        this.name = 'MerkleBlockValidationError';
+        this.code = 'MERKLE_BLOCK_VALIDATION_ERROR';
+        this.context = context;
+    }
+}
+export class MerkleBlock {
+    static NULL_HASH = NULL_HASH;
+    header;
+    numTransactions;
+    hashes;
+    flags;
+    constructor(arg) {
+        if (arg instanceof MerkleBlock) {
+            return arg;
+        }
+        if (!arg) {
+            throw new InvalidMerkleBlockError('Argument is required for MerkleBlock', {
+                received: arg,
+            });
+        }
+        const info = MerkleBlock._from(arg);
+        if (info.header instanceof BlockHeader) {
+            this.header = info.header;
+        }
+        else {
+            this.header = new BlockHeader(info.header);
+        }
+        this.numTransactions = info.numTransactions;
+        this.hashes = info.hashes;
+        this.flags = info.flags;
+    }
+    static fromObject(obj) {
+        if (!obj.header) {
+            throw new MerkleBlockValidationError('Block header is required', {
+                header: obj.header,
+            });
+        }
+        return new MerkleBlock({
+            header: BlockHeader.fromObject(obj.header),
+            numTransactions: obj.numTransactions,
+            hashes: obj.hashes,
+            flags: obj.flags,
+        });
+    }
+    static fromBuffer(buf) {
+        if (!BufferUtil.isBuffer(buf) || buf.length === 0) {
+            throw new InvalidMerkleBlockError('Invalid buffer provided', {
+                isBuffer: BufferUtil.isBuffer(buf),
+                length: buf?.length,
+            });
+        }
+        return MerkleBlock.fromBufferReader(new BufferReader(buf));
+    }
+    static fromBufferReader(br) {
+        const info = MerkleBlock._readFromBuffer(br);
+        return new MerkleBlock(info);
+    }
+    static fromString(str) {
+        $.checkArgument(typeof str === 'string' && str.length > 0, 'str', 'Invalid hex string provided');
+        return MerkleBlock.fromBuffer(Buffer.from(str, 'hex'));
+    }
+    toBuffer() {
+        return this.toBufferWriter().concat();
+    }
+    toBufferWriter(bw) {
+        if (!bw) {
+            bw = new BufferWriter();
+        }
+        bw.write(this.header.toBuffer());
+        bw.writeUInt32LE(this.numTransactions);
+        bw.writeVarintNum(this.hashes.length);
+        for (const hash of this.hashes) {
+            bw.write(Buffer.from(hash, 'hex'));
+        }
+        const flagBytes = bitsToBytes(this.flags.map(f => f !== 0));
+        bw.writeVarintNum(flagBytes.length);
+        for (const byte of flagBytes) {
+            bw.writeUInt8(byte);
+        }
+        return bw;
+    }
+    toObject() {
+        return {
+            header: this.header.toObject(),
+            numTransactions: this.numTransactions,
+            hashes: this.hashes,
+            flags: this.flags,
+        };
+    }
+    toJSON() {
+        return this.toObject();
+    }
+    validMerkleTree() {
+        if (!Array.isArray(this.flags) || !Array.isArray(this.hashes)) {
+            return false;
+        }
+        if (this.hashes.length > this.numTransactions) {
+            return false;
+        }
+        if (this.flags.length * 8 < this.hashes.length) {
+            return false;
+        }
+        const height = this._calcTreeHeight();
+        const state = {
+            hashesUsed: 0,
+            flagBitsUsed: 0,
+            txs: [],
+        };
+        const root = this._traverseAndExtract(height, 0, state);
+        if (state.hashesUsed !== this.hashes.length) {
+            return false;
+        }
+        return BufferUtil.equals(root, this.header.merkleRoot);
+    }
+    filteredTxsHash() {
+        if (!Array.isArray(this.flags) || !Array.isArray(this.hashes)) {
+            throw new BitcoreError.MerkleBlock.InvalidMerkleTree();
+        }
+        if (this.hashes.length > this.numTransactions) {
+            throw new BitcoreError.MerkleBlock.InvalidMerkleTree();
+        }
+        if (this.flags.length * 8 < this.hashes.length) {
+            throw new BitcoreError.MerkleBlock.InvalidMerkleTree();
+        }
+        if (this.hashes.length === 1) {
+            return [];
+        }
+        const height = this._calcTreeHeight();
+        const state = {
+            hashesUsed: 0,
+            flagBitsUsed: 0,
+            txs: [],
+        };
+        this._traverseAndExtract(height, 0, state);
+        if (state.hashesUsed !== this.hashes.length) {
+            throw new BitcoreError.MerkleBlock.InvalidMerkleTree();
+        }
+        return state.txs;
+    }
+    hasTransaction(tx) {
+        if (!tx) {
+            throw new BitcoreError('Transaction cannot be undefined');
+        }
+        if (!(tx instanceof Transaction) && typeof tx !== 'string') {
+            throw new BitcoreError('Invalid transaction: must be string or Transaction');
+        }
+        if (typeof tx === 'string' && !/^[0-9a-fA-F]{64}$/.test(tx)) {
+            throw new BitcoreError('Invalid transaction ID format: must be 64-character hex string');
+        }
+        let searchTxid;
+        let searchHash;
+        if (tx instanceof Transaction) {
+            searchTxid = BufferUtil.reverse(Buffer.from(tx.txid, 'hex')).toString('hex');
+            searchHash = BufferUtil.reverse(Buffer.from(tx.hash, 'hex')).toString('hex');
+        }
+        else {
+            searchTxid = BufferUtil.reverse(Buffer.from(tx, 'hex')).toString('hex');
+            searchHash = searchTxid;
+        }
+        const state = {
+            hashesUsed: 0,
+            flagBitsUsed: 0,
+            txs: [],
+        };
+        const height = this._calcTreeHeight();
+        this._traverseAndExtract(height, 0, state);
+        return state.txs.includes(searchTxid) || state.txs.includes(searchHash);
+    }
+    static _from(arg) {
+        if (BufferUtil.isBuffer(arg)) {
+            return MerkleBlock._readFromBuffer(new BufferReader(arg));
+        }
+        else if (typeof arg === 'object' && arg !== null) {
+            return MerkleBlock._validateData(arg);
+        }
+        throw new InvalidMerkleBlockError('Unrecognized argument for MerkleBlock', {
+            type: typeof arg,
+            arg,
+        });
+    }
+    static _validateData(data) {
+        if (!data.header) {
+            throw new MerkleBlockValidationError('Block header is required', {
+                header: data.header,
+            });
+        }
+        if (typeof data.numTransactions !== 'number' || data.numTransactions < 0) {
+            throw new MerkleBlockValidationError('Number of transactions must be a non-negative number', {
+                numTransactions: data.numTransactions,
+                type: typeof data.numTransactions,
+            });
+        }
+        if (!Array.isArray(data.hashes)) {
+            throw new MerkleBlockValidationError('Hashes must be an array', {
+                hashes: data.hashes,
+                type: typeof data.hashes,
+            });
+        }
+        if (!Array.isArray(data.flags)) {
+            throw new MerkleBlockValidationError('Flags must be an array', {
+                flags: data.flags,
+                type: typeof data.flags,
+            });
+        }
+        const header = data.header instanceof BlockHeader
+            ? data.header
+            : new BlockHeader(data.header);
+        return {
+            header,
+            numTransactions: data.numTransactions,
+            hashes: data.hashes,
+            flags: data.flags,
+        };
+    }
+    static _readFromBuffer(br) {
+        if (br.finished()) {
+            throw new InvalidMerkleBlockError('No merkleblock data received');
+        }
+        const header = BlockHeader.fromBufferReader(br);
+        const numTransactions = br.readUInt32LE();
+        const numHashes = br.readVarintNum();
+        const hashes = [];
+        for (let i = 0; i < numHashes; i++) {
+            hashes.push(br.read(32).toString('hex'));
+        }
+        const numFlags = br.readVarintNum();
+        const flagBytes = [];
+        for (let i = 0; i < numFlags; i++) {
+            flagBytes.push(br.readUInt8());
+        }
+        const flags = bytesToBits(flagBytes).map(b => (b ? 1 : 0));
+        return { header, numTransactions, hashes, flags };
+    }
+    _calcTreeWidth(height) {
+        return calcTreeWidth(this.numTransactions * 2, height);
+    }
+    _calcTreeHeight() {
+        let height = 0;
+        while (this._calcTreeWidth(height) > 1) {
+            height++;
+        }
+        return height;
+    }
+    _traverseAndExtract(depth, pos, state) {
+        if (state.flagBitsUsed > this.flags.length * 8) {
+            return MerkleBlock.NULL_HASH;
+        }
+        const isParentOfMatch = extractBit(this.flags, state.flagBitsUsed++);
+        if (depth === 0 || !isParentOfMatch) {
+            if (state.hashesUsed >= this.hashes.length) {
+                return MerkleBlock.NULL_HASH;
+            }
+            const hash = this.hashes[state.hashesUsed++];
+            if (depth === 0 && isParentOfMatch) {
+                state.txs.push(hash);
+            }
+            return Buffer.from(hash, 'hex');
+        }
+        const left = this._traverseAndExtract(depth - 1, pos * 2, state);
+        let right;
+        if (pos * 2 + 1 < this._calcTreeWidth(depth - 1)) {
+            right = this._traverseAndExtract(depth - 1, pos * 2 + 1, state);
+        }
+        else {
+            right = MerkleBlock.NULL_HASH;
+        }
+        return Hash.sha256sha256(Buffer.concat([left, right]));
+    }
+}

package/dist/esm/lib/bitcore/crypto/bn.js

@@ -1,4 +1,5 @@
 import BN from 'bn.js';
+import { BufferUtil } from '../util';
 class BNWrapper {
     _bn;
     static Zero = new BNWrapper(0);
@@ -8,7 +9,7 @@ class BNWrapper {
         if (n instanceof BN) {
             this._bn = n.clone();
         }
-        else if (Buffer.isBuffer(n)) {
+        else if (BufferUtil.isBuffer(n)) {
             if (base === 'le' || base === 'be') {
                 this._bn = new BN(n, undefined, base);
             }
@@ -27,7 +28,7 @@ class BNWrapper {
     static fromBuffer(buf, opts) {
         let buffer = buf;
         if (opts?.size) {
-            buffer = Buffer.alloc(opts.size);
+            buffer = BufferUtil.alloc(opts.size);
             buf.copy(buffer, opts.size - buf.length);
         }
         if (opts?.endian === 'little') {
@@ -37,7 +38,7 @@ class BNWrapper {
     }
     static fromSM(buf, opts) {
         if (buf.length === 0) {
-            return BNWrapper.fromBuffer(Buffer.from([0]));
+            return BNWrapper.fromBuffer(BufferUtil.from([0]));
         }
         let endian = 'big';
         if (opts) {
@@ -73,17 +74,17 @@ class BNWrapper {
         return BNWrapper.fromSM(buf, { endian: 'little' });
     }
     static reversebuf(buf) {
-        const buf2 = Buffer.alloc(buf.length);
+        const buf2 = BufferUtil.alloc(buf.length);
         for (let i = 0; i < buf.length; i++) {
             buf2[i] = buf[buf.length - 1 - i];
         }
         return buf2;
     }
     static trim(buf, natlen) {
-        return buf.subarray(natlen - buf.length, buf.length);
+        return buf.slice(natlen - buf.length, buf.length);
     }
     static pad(buf, natlen, size) {
-        const rbuf = Buffer.alloc(size);
+        const rbuf = BufferUtil.alloc(size);
         for (let i = 0; i < buf.length; i++) {
             rbuf[rbuf.length - 1 - i] = buf[buf.length - 1 - i];
         }
@@ -114,28 +115,23 @@ class BNWrapper {
         return this._bn.toString(base);
     }
     toBuffer(opts) {
-        let buf;
-        if (opts && opts.size) {
-            buf = this._bn.toArrayLike(Buffer, opts.endian === 'little' ? 'le' : 'be');
-            if (buf.length === opts.size) {
-            }
-            else if (buf.length > opts.size) {
-                buf = buf.subarray(buf.length - opts.size);
+        let hex = this._bn.toString('hex', 2);
+        let buf = BufferUtil.from(hex, 'hex');
+        if (opts?.size) {
+            if (buf.length > opts.size) {
+                buf = buf.slice(buf.length - opts.size);
             }
             else if (buf.length < opts.size) {
-                const padded = Buffer.alloc(opts.size);
+                const padded = BufferUtil.alloc(opts.size);
                 buf.copy(padded, opts.size - buf.length);
                 buf = padded;
             }
         }
-        else {
-            buf = this._bn.toArrayLike(Buffer, opts?.endian === 'little' ? 'le' : 'be');
+        if (opts?.endian === 'little') {
+            buf = BufferUtil.from(buf).reverse();
         }
         return buf;
     }
-    toArrayLike(ArrayType, endian, length) {
-        return this._bn.toArrayLike(ArrayType, endian || 'be', length);
-    }
     mul(r) {
         return new BNWrapper(this._bn.mul(r._bn));
     }
@@ -196,7 +192,7 @@ class BNWrapper {
         if (this.cmp(BNWrapper.Zero) === -1) {
             buf = this.neg().toBuffer();
             if (buf[0] & 0x80) {
-                buf = Buffer.concat([Buffer.from([0x80]), buf]);
+                buf = BufferUtil.concat([BufferUtil.from([0x80]), buf]);
             }
             else {
                 buf[0] = buf[0] | 0x80;
@@ -205,11 +201,11 @@ class BNWrapper {
         else {
             buf = this.toBuffer();
             if (buf[0] & 0x80) {
-                buf = Buffer.concat([Buffer.from([0x00]), buf]);
+                buf = BufferUtil.concat([BufferUtil.from([0x00]), buf]);
             }
         }
         if (buf.length === 1 && buf[0] === 0) {
-            buf = Buffer.from([]);
+            buf = BufferUtil.from([]);
         }
         return buf;
     }

package/dist/esm/lib/bitcore/crypto/ecdsa.js

@@ -1,9 +1,10 @@
-import { BN } from './bn.js';
-import { Point } from './point.js';
-import { Signature } from './signature.js';
-import { Hash } from './hash.js';
-import { Random } from './random.js';
-import { PublicKey } from '../publickey.js';
+import { BN } from './bn';
+import { Point } from './point';
+import { Signature } from './signature';
+import { Hash } from './hash';
+import { Random } from './random';
+import { PublicKey } from '../publickey';
+import { BufferUtil } from '../util';
 export class ECDSA {
     hashbuf;
     endian;
@@ -62,29 +63,29 @@ export class ECDSA {
         const N = Point.getN();
         let k;
         do {
-            k = new BN(Random.getRandomBuffer(32), 'be');
+            k = BN.fromBuffer(Random.getRandomBuffer(32));
         } while (!(k.lt(N) && k.gt(new BN(0))));
         this.k = k;
         return this;
     }
     deterministicK(badrs = 0) {
-        let v = Buffer.alloc(32);
+        let v = BufferUtil.alloc(32);
         v.fill(0x01);
-        let k = Buffer.alloc(32);
+        let k = BufferUtil.alloc(32);
         k.fill(0x00);
         const x = this.privkey.toBuffer();
         const hashbuf = this.endian === 'little'
             ? this.reverseBuffer(this.hashbuf)
             : this.hashbuf;
-        k = Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x00]), x, hashbuf]), k);
+        k = Hash.sha256hmac(BufferUtil.concat([v, BufferUtil.from([0x00]), x, hashbuf]), k);
         v = Hash.sha256hmac(v, k);
-        k = Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x01]), x, hashbuf]), k);
+        k = Hash.sha256hmac(BufferUtil.concat([v, BufferUtil.from([0x01]), x, hashbuf]), k);
         v = Hash.sha256hmac(v, k);
         v = Hash.sha256hmac(v, k);
         let T = new BN(v, 'be');
         const N = Point.getN();
         for (let i = 0; i < badrs || !(T.lt(N) && T.gt(new BN(0))); i++) {
-            k = Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x00])]), k);
+            k = Hash.sha256hmac(BufferUtil.concat([v, BufferUtil.from([0x00])]), k);
             v = Hash.sha256hmac(v, k);
             v = Hash.sha256hmac(v, k);
             T = new BN(v, 'be');
@@ -97,7 +98,7 @@ export class ECDSA {
         if (!(i === 0 || i === 1 || i === 2 || i === 3)) {
             throw new Error('i must be equal to 0, 1, 2, or 3');
         }
-        const e = new BN(this.hashbuf, 'be');
+        const e = BN.fromBuffer(this.hashbuf, { endian: 'big' });
         const r = this.sig.r;
         const s = this.sig.s;
         const isYOdd = (i & 1) !== 0;
@@ -110,14 +111,14 @@ export class ECDSA {
         if (!nR.isInfinity()) {
             throw new Error('nR is not a valid curve point');
         }
-        const eNeg = e.neg().mod(n);
+        const eNeg = e.neg().umod(n);
         const rInv = r.invm(n);
         const Q = R.mul(s).add(G.mul(eNeg)).mul(rInv);
         const pubkey = PublicKey.fromPoint(Q, this.sig.compressed);
         return pubkey;
     }
     sigError() {
-        if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
+        if (!BufferUtil.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
             return 'hashbuf must be a 32 byte buffer';
         }
         const r = this.sig.r;
@@ -126,16 +127,16 @@ export class ECDSA {
         if (!(r.gt(new BN(0)) && r.lt(N)) || !(s.gt(new BN(0)) && s.lt(N))) {
             return 'r and s not in range';
         }
-        const e = new BN(this.hashbuf, this.endian === 'little' ? 'le' : 'be');
+        const e = BN.fromBuffer(this.hashbuf, { endian: this.endian || 'big' });
         const n = Point.getN();
         const sinv = s.invm(n);
-        const u1 = sinv.mul(e).mod(n);
-        const u2 = sinv.mul(r).mod(n);
+        const u1 = sinv.mul(e).umod(n);
+        const u2 = sinv.mul(r).umod(n);
         const p = Point.getG().mulAdd(u1, this.pubkey.point, u2);
         if (p.isInfinity()) {
             return 'p is infinity';
         }
-        if (p.getX().mod(n).cmp(r) !== 0) {
+        if (p.x.umod(n).cmp(r) !== 0) {
             return 'Invalid signature';
         }
         else {
@@ -161,11 +162,11 @@ export class ECDSA {
             badrs++;
             k = this.k;
             Q = G.mul(k);
-            r = Q.getX().mod(N);
+            r = Q.x.umod(N);
             s = k
                 .invm(N)
                 .mul(e.add(d.mul(r)))
-                .mod(N);
+                .umod(N);
         } while (r.cmp(new BN(0)) <= 0 || s.cmp(new BN(0)) <= 0);
         s = ECDSA.toLowS(s);
         return { s, r, compressed: this.pubkey.compressed };
@@ -177,10 +178,10 @@ export class ECDSA {
         if (!hashbuf || !privkey || !d) {
             throw new Error('invalid parameters');
         }
-        if (!Buffer.isBuffer(hashbuf) || hashbuf.length !== 32) {
+        if (!BufferUtil.isBuffer(hashbuf) || hashbuf.length !== 32) {
             throw new Error('hashbuf must be a 32 byte buffer');
         }
-        const e = new BN(hashbuf, this.endian === 'little' ? 'le' : 'be');
+        const e = BN.fromBuffer(hashbuf, { endian: this.endian || 'big' });
         const obj = this._findSignature(d, e);
         obj.compressed = this.pubkey.compressed;
         this.sig = new Signature(obj);
@@ -238,7 +239,7 @@ export class ECDSA {
             .verify().verified;
     }
     reverseBuffer(buf) {
-        const buf2 = Buffer.alloc(buf.length);
+        const buf2 = BufferUtil.alloc(buf.length);
         for (let i = 0; i < buf.length; i++) {
             buf2[i] = buf[buf.length - 1 - i];
         }

package/dist/esm/lib/bitcore/crypto/hash.js

@@ -1,26 +1,26 @@
-import { sha1 } from '@noble/hashes/sha1';
-import { sha256 } from '@noble/hashes/sha256';
-import { sha512 } from '@noble/hashes/sha512';
-import { ripemd160 } from '@noble/hashes/ripemd160';
+import { ripemd160, sha1 } from '@noble/hashes/legacy';
+import { sha256, sha512 } from '@noble/hashes/sha2';
+import { BufferUtil } from '../util';
 const sha1Func = (buf) => {
-    if (!Buffer.isBuffer(buf)) {
+    if (!BufferUtil.isBuffer(buf)) {
         throw new Error('Argument must be a Buffer');
     }
-    return Buffer.from(sha1(buf));
+    return BufferUtil.from(sha1(buf));
 };
 sha1Func.blocksize = 512;
 const sha256Func = (buf) => {
-    if (!Buffer.isBuffer(buf)) {
+    if (!BufferUtil.isBuffer(buf)) {
+        console.log('sha256Func: buf is not a Buffer', buf, typeof buf);
         throw new Error('Argument must be a Buffer');
     }
-    return Buffer.from(sha256(buf));
+    return BufferUtil.from(sha256(buf));
 };
 sha256Func.blocksize = 512;
 const sha512Func = (buf) => {
-    if (!Buffer.isBuffer(buf)) {
+    if (!BufferUtil.isBuffer(buf)) {
         throw new Error('Argument must be a Buffer');
     }
-    return Buffer.from(sha512(buf));
+    return BufferUtil.from(sha512(buf));
 };
 sha512Func.blocksize = 1024;
 export class Hash {
@@ -28,28 +28,28 @@ export class Hash {
     static sha256 = sha256Func;
     static sha512 = sha512Func;
     static sha256sha256 = function (buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!BufferUtil.isBuffer(buf)) {
             throw new Error('Argument must be a Buffer');
         }
         return Hash.sha256(Hash.sha256(buf));
     };
     static ripemd160 = function (buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!BufferUtil.isBuffer(buf)) {
             throw new Error('Argument must be a Buffer');
         }
-        return Buffer.from(ripemd160(buf));
+        return BufferUtil.from(ripemd160(buf));
     };
     static sha256ripemd160 = function (buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!BufferUtil.isBuffer(buf)) {
             throw new Error('Argument must be a Buffer');
         }
         return Hash.ripemd160(Hash.sha256(buf));
     };
     static hmac(hashf, data, key) {
-        if (!Buffer.isBuffer(data)) {
+        if (!BufferUtil.isBuffer(data)) {
             throw new Error('Data must be a Buffer');
         }
-        if (!Buffer.isBuffer(key)) {
+        if (!BufferUtil.isBuffer(key)) {
             throw new Error('Key must be a Buffer');
         }
         if (!hashf.blocksize) {
@@ -61,22 +61,25 @@ export class Hash {
             processedKey = hashf(key);
         }
         else if (key.length < blocksize) {
-            const fill = Buffer.alloc(blocksize);
+            const fill = BufferUtil.alloc(blocksize);
             fill.fill(0);
             key.copy(fill);
             processedKey = fill;
         }
-        const o_key = Buffer.alloc(blocksize);
+        const o_key = BufferUtil.alloc(blocksize);
         o_key.fill(0x5c);
-        const i_key = Buffer.alloc(blocksize);
+        const i_key = BufferUtil.alloc(blocksize);
         i_key.fill(0x36);
-        const o_key_pad = Buffer.alloc(blocksize);
-        const i_key_pad = Buffer.alloc(blocksize);
+        const o_key_pad = BufferUtil.alloc(blocksize);
+        const i_key_pad = BufferUtil.alloc(blocksize);
         for (let i = 0; i < blocksize; i++) {
             o_key_pad[i] = o_key[i] ^ processedKey[i];
             i_key_pad[i] = i_key[i] ^ processedKey[i];
         }
-        return hashf(Buffer.concat([o_key_pad, hashf(Buffer.concat([i_key_pad, data]))]));
+        return hashf(BufferUtil.concat([
+            o_key_pad,
+            hashf(BufferUtil.concat([i_key_pad, data])),
+        ]));
     }
     static sha256hmac(data, key) {
         return Hash.hmac(Hash.sha256, data, key);