xpi-ts 0.2.13 → 0.2.15

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

@@ -1,31 +1,32 @@
-import { PublicKey } from '../publickey.js';
-import { Point } from './point.js';
-import { BN } from './bn.js';
-import { Hash } from './hash.js';
-import { Signature } from './signature.js';
-export const MUSIG_TAG_KEYSORT = 'KeyAgg list';
-export const MUSIG_TAG_KEYAGG_COEFF = 'KeyAgg coefficient';
-export const MUSIG_TAG_NONCE_COEFF = 'MuSig/noncecoef';
-const MUSIG_TAG_AUX = 'MuSig/aux';
-export const MUSIG_TAG_NONCE = 'MuSig/nonce';
-export function musigTaggedHash(tag, data) {
-    const tagHash = Hash.sha256(Buffer.from(tag, 'utf8'));
-    const combined = Buffer.concat([tagHash, tagHash, data]);
+import { PublicKey } from '../publickey';
+import { Point } from './point';
+import { BN } from './bn';
+import { Hash } from './hash';
+import { Signature } from './signature';
+import { BufferUtil } from '../util';
+export const MUSIG2_TAG_KEYSORT = 'KeyAgg list';
+export const MUSIG2_TAG_KEYAGG_COEFF = 'KeyAgg coefficient';
+export const MUSIG2_TAG_NONCE_COEFF = 'MuSig/noncecoef';
+export const MUSIG2_TAG_AUX = 'MuSig/aux';
+export const MUSIG2_TAG_NONCE = 'MuSig/nonce';
+export function muSig2TaggedHash(tag, data) {
+    const tagHash = Hash.sha256(BufferUtil.from(tag, 'utf8'));
+    const combined = BufferUtil.concat([tagHash, tagHash, data]);
     return Hash.sha256(combined);
 }
 function hashKeys(pubkeys) {
-    const data = Buffer.concat(pubkeys.map(pk => pk.toBuffer()));
-    return musigTaggedHash(MUSIG_TAG_KEYSORT, data);
+    const data = BufferUtil.concat(pubkeys.map(pk => pk.toBuffer()));
+    return muSig2TaggedHash(MUSIG2_TAG_KEYSORT, data);
 }
 function keyAggCoeff(L, pubkey, isSecondKey, equalsFirstKey) {
     if (isSecondKey && equalsFirstKey) {
-        return new BN(1);
+        return BN.One;
     }
-    const data = Buffer.concat([L, pubkey.toBuffer()]);
-    const hash = musigTaggedHash(MUSIG_TAG_KEYAGG_COEFF, data);
-    return new BN(hash, 'be');
+    const data = BufferUtil.concat([L, pubkey.toBuffer()]);
+    const hash = muSig2TaggedHash(MUSIG2_TAG_KEYAGG_COEFF, data);
+    return BN.fromBuffer(hash);
 }
-export function musigKeyAgg(pubkeys) {
+export function muSig2KeyAgg(pubkeys) {
     if (pubkeys.length === 0) {
         throw new Error('Cannot aggregate zero public keys');
     }
@@ -46,13 +47,13 @@ export function musigKeyAgg(pubkeys) {
         const isSecond = i === 1;
         const equalsFirst = sortedPubkeys[i].toString() === firstKey.toString();
         const coeff = keyAggCoeff(L, sortedPubkeys[i], isSecond, equalsFirst);
-        keyAggCoeffMap.set(i, coeff);
+        keyAggCoeffMap.set(sortedPubkeys[i].toString(), coeff);
     }
     let Q = null;
     const n = Point.getN();
     for (let i = 0; i < sortedPubkeys.length; i++) {
-        const coeff = keyAggCoeffMap.get(i);
         const pk = sortedPubkeys[i];
+        const coeff = keyAggCoeffMap.get(pk.toString());
         const term = pk.point.mul(coeff.umod(n));
         if (Q === null) {
             Q = term;
@@ -75,25 +76,25 @@ export function musigKeyAgg(pubkeys) {
         aggregatedPubKey,
     };
 }
-export function musigNonceGen(privateKey, aggregatedPubKey, message, extraInput) {
+export function muSig2NonceGen(privateKey, aggregatedPubKey, message, extraInput) {
     const G = Point.getG();
     const n = Point.getN();
-    const sessionData = Buffer.concat([
-        privateKey.bn.toArrayLike(Buffer, 'be', 32),
+    const sessionData = BufferUtil.concat([
+        privateKey.bn.toBuffer({ size: 32 }),
         aggregatedPubKey.toBuffer(),
-        message || Buffer.alloc(32),
-        extraInput || Buffer.alloc(32),
+        message || BufferUtil.alloc(32),
+        extraInput || BufferUtil.alloc(32),
     ]);
-    const auxHash = musigTaggedHash(MUSIG_TAG_AUX, sessionData);
-    const rand1 = musigTaggedHash(MUSIG_TAG_NONCE, Buffer.concat([auxHash, Buffer.from([0x01])]));
-    const rand2 = musigTaggedHash(MUSIG_TAG_NONCE, Buffer.concat([auxHash, Buffer.from([0x02])]));
-    let k1 = new BN(rand1, 'be').umod(n);
-    let k2 = new BN(rand2, 'be').umod(n);
+    const auxHash = muSig2TaggedHash(MUSIG2_TAG_AUX, sessionData);
+    const rand1 = muSig2TaggedHash(MUSIG2_TAG_NONCE, BufferUtil.concat([auxHash, BufferUtil.from([0x01])]));
+    const rand2 = muSig2TaggedHash(MUSIG2_TAG_NONCE, BufferUtil.concat([auxHash, BufferUtil.from([0x02])]));
+    let k1 = BN.fromBuffer(rand1).umod(n);
+    let k2 = BN.fromBuffer(rand2).umod(n);
     if (k1.isZero()) {
-        k1 = new BN(1);
+        k1 = BN.One;
     }
     if (k2.isZero()) {
-        k2 = new BN(1);
+        k2 = BN.One;
     }
     const R1 = G.mul(k1);
     const R2 = G.mul(k2);
@@ -104,7 +105,7 @@ export function musigNonceGen(privateKey, aggregatedPubKey, message, extraInput)
         publicNonces: [R1, R2],
     };
 }
-export function musigNonceAgg(publicNonces) {
+export function muSig2NonceAgg(publicNonces) {
     if (publicNonces.length === 0) {
         throw new Error('Cannot aggregate zero nonces');
     }
@@ -130,65 +131,67 @@ export function musigNonceAgg(publicNonces) {
         R2: R2_agg,
     };
 }
-export function musigPartialSign(secretNonce, privateKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
+export function muSig2PartialSign(secretNonce, privateKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
     const n = Point.getN();
     const [k1, k2] = secretNonce.secretNonces;
     const { R1, R2 } = aggregatedNonce;
     const Q = keyAggContext.aggregatedPubKey;
-    const nonceCoefData = Buffer.concat([
+    const nonceCoefData = BufferUtil.concat([
         Q.toBuffer(),
         Point.pointToCompressed(R1),
         Point.pointToCompressed(R2),
         message,
     ]);
-    const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+    const b = BN.fromBuffer(muSig2TaggedHash(MUSIG2_TAG_NONCE_COEFF, nonceCoefData));
     let k = k1.add(b.mul(k2)).umod(n);
     const R = R1.add(R2.mul(b));
     if (!R.hasSquare()) {
         k = n.sub(k).umod(n);
     }
-    const R_x = R.getX().toArrayLike(Buffer, 'be', 32);
+    const R_x = R.x.toBuffer({ size: 32 });
     const keyForChallenge = publicKeyForChallenge || Q;
     const Q_compressed = Point.pointToCompressed(keyForChallenge.point);
-    const challengeData = Buffer.concat([R_x, Q_compressed, message]);
-    const e = new BN(Hash.sha256(challengeData), 'be').umod(n);
-    const a = keyAggContext.keyAggCoeff.get(signerIndex);
+    const challengeData = BufferUtil.concat([R_x, Q_compressed, message]);
+    const e = BN.fromBuffer(Hash.sha256(challengeData)).umod(n);
+    const signerPubKey = privateKey.publicKey.toString();
+    const a = keyAggContext.keyAggCoeff.get(signerPubKey);
     if (!a) {
-        throw new Error(`Invalid signer index: ${signerIndex}`);
+        throw new Error(`Public key not found in key aggregation context: ${signerPubKey.slice(0, 20)}...`);
     }
     const x = privateKey.bn;
     const s = k.add(e.mul(a).mul(x)).umod(n);
     return s;
 }
-export function musigPartialSigVerify(partialSig, publicNonce, publicKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
+export function muSig2PartialSigVerify(partialSig, publicNonce, publicKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
     try {
         const G = Point.getG();
         const n = Point.getN();
         const [R1_i, R2_i] = publicNonce;
         const { R1, R2 } = aggregatedNonce;
         const Q = keyAggContext.aggregatedPubKey;
-        const nonceCoefData = Buffer.concat([
+        const nonceCoefData = BufferUtil.concat([
             Q.toBuffer(),
             Point.pointToCompressed(R1),
             Point.pointToCompressed(R2),
             message,
         ]);
-        const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+        const b = BN.fromBuffer(muSig2TaggedHash(MUSIG2_TAG_NONCE_COEFF, nonceCoefData));
         const R_i = R1_i.add(R2_i.mul(b));
         const R = R1.add(R2.mul(b));
         const negated = !R.hasSquare();
-        const R_x = R.getX().toArrayLike(Buffer, 'be', 32);
+        const R_x = R.x.toBuffer({ size: 32 });
         const keyForChallenge = publicKeyForChallenge || Q;
         const Q_compressed = Point.pointToCompressed(keyForChallenge.point);
-        const challengeData = Buffer.concat([R_x, Q_compressed, message]);
-        const e = new BN(Hash.sha256(challengeData), 'be').umod(n);
-        const a = keyAggContext.keyAggCoeff.get(signerIndex);
+        const challengeData = BufferUtil.concat([R_x, Q_compressed, message]);
+        const e = BN.fromBuffer(Hash.sha256(challengeData)).umod(n);
+        const signerPubKeyStr = publicKey.toString();
+        const a = keyAggContext.keyAggCoeff.get(signerPubKeyStr);
         if (!a) {
-            throw new Error(`Invalid signer index: ${signerIndex}`);
+            throw new Error(`Public key not found in key aggregation context: ${signerPubKeyStr.slice(0, 20)}...`);
         }
         const lhs = G.mul(partialSig.umod(n));
         const eaP = publicKey.point.mul(e.mul(a).umod(n));
-        const R_i_adjusted = negated ? R_i.mul(n.sub(new BN(1))) : R_i;
+        const R_i_adjusted = negated ? R_i.mul(n.sub(BN.One)) : R_i;
         const rhs = R_i_adjusted.add(eaP);
         return lhs.eq(rhs);
     }
@@ -196,29 +199,29 @@ export function musigPartialSigVerify(partialSig, publicNonce, publicKey, keyAgg
         return false;
     }
 }
-export function musigSigAgg(partialSigs, aggregatedNonce, message, aggregatedPubKey, sighashType, publicKeyForNonceCoef) {
+export function muSig2SigAgg(partialSigs, aggregatedNonce, message, aggregatedPubKey, sighashType, publicKeyForNonceCoef) {
     if (partialSigs.length === 0) {
         throw new Error('Cannot aggregate zero partial signatures');
     }
     const n = Point.getN();
     const { R1, R2 } = aggregatedNonce;
     const keyForNonceCoef = publicKeyForNonceCoef || aggregatedPubKey;
-    const nonceCoefData = Buffer.concat([
+    const nonceCoefData = BufferUtil.concat([
         keyForNonceCoef.toBuffer(),
         Point.pointToCompressed(R1),
         Point.pointToCompressed(R2),
         message,
     ]);
-    const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+    const b = BN.fromBuffer(muSig2TaggedHash(MUSIG2_TAG_NONCE_COEFF, nonceCoefData));
     const R = R1.add(R2.mul(b));
-    let s = new BN(0);
+    let s = BN.Zero;
     for (const partialSig of partialSigs) {
         s = s.add(partialSig).umod(n);
     }
     if (s.isZero()) {
         throw new Error('Aggregated signature s is zero (invalid)');
     }
-    const r = R.getX();
+    const r = R.x;
     const signature = new Signature({
         r: r,
         s: s,
@@ -228,12 +231,3 @@ export function musigSigAgg(partialSigs, aggregatedNonce, message, aggregatedPub
     });
     return signature;
 }
-export default {
-    musigKeyAgg,
-    musigNonceGen,
-    musigNonceAgg,
-    musigPartialSign,
-    musigPartialSigVerify,
-    musigSigAgg,
-    musigTaggedHash,
-};

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

@@ -1,10 +1,15 @@
 import elliptic from 'elliptic';
-import { BN } from './bn.js';
+import { BN } from './bn';
+import { BufferUtil } from '../util';
 const ecInstance = new elliptic.ec('secp256k1');
 const ecPoint = ecInstance.curve.point.bind(ecInstance.curve);
 const ecPointFromX = ecInstance.curve.pointFromX.bind(ecInstance.curve);
+export const PREFIX_Y_ODD = 0x03;
+export const PREFIX_Y_EVEN = 0x02;
 export class Point {
     _point;
+    static PrefixOddY = BufferUtil.from([PREFIX_Y_ODD]);
+    static PrefixEvenY = BufferUtil.from([PREFIX_Y_EVEN]);
     constructor(x, y, isRed) {
         try {
             const bnX = x instanceof BN ? x.bn : new BN(x);
@@ -16,6 +21,14 @@ export class Point {
         }
         this.validate();
     }
+    get x() {
+        const xBuffer = this._point.getX().toBuffer();
+        return BN.fromString(xBuffer.toString('hex'), 'hex');
+    }
+    get y() {
+        const yBuffer = this._point.getY().toBuffer();
+        return BN.fromString(yBuffer.toString('hex'), 'hex');
+    }
     static fromX(odd, x) {
         try {
             const xStr = typeof x === 'string' ? x : x.toString();
@@ -53,19 +66,13 @@ export class Point {
     static getN() {
         return new BN(ecInstance.curve.n.toArray());
     }
-    getX() {
-        return new BN(this._point.getX().toString());
-    }
-    getY() {
-        return new BN(this._point.getY().toString());
-    }
     validate() {
         if (this.isInfinity()) {
             throw new Error('Point cannot be equal to Infinity');
         }
         try {
-            const x = this.getX();
-            const y = this.getY();
+            const x = this.x;
+            const y = this.y;
             if (x === undefined || y === undefined) {
                 throw new Error('Point coordinates are undefined');
             }
@@ -104,18 +111,18 @@ export class Point {
         return this._point.eq(other._point);
     }
     static pointToCompressed(point) {
-        const xbuf = point.getX().toArrayLike(Buffer, 'be', 32);
-        const y = point.getY();
+        const xbuf = point.x.toBuffer({ size: 32 });
+        const y = point.y;
         const odd = y.mod(new BN(2)).isOdd();
-        const prefix = odd ? Buffer.from([0x03]) : Buffer.from([0x02]);
-        return Buffer.concat([prefix, xbuf]);
+        const prefix = odd ? Point.PrefixOddY : Point.PrefixEvenY;
+        return BufferUtil.concat([prefix, xbuf]);
     }
     hasSquare() {
         if (this.isInfinity()) {
             return false;
         }
-        const x = this.getX();
-        const y = this.getY();
+        const x = this.x;
+        const y = this.y;
         const p = new BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
         const x3 = x.mul(x).mod(p).mul(x).mod(p);
         const c = x3.add(new BN(7)).mod(p);

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

@@ -1,7 +1,8 @@
 import { randomBytes as nobleRandomBytes } from '@noble/hashes/utils';
+import { BufferUtil } from '../util';
 export class Random {
     static getRandomBuffer(size) {
-        return Buffer.from(nobleRandomBytes(size));
+        return BufferUtil.from(nobleRandomBytes(size));
     }
     static getRandomBufferNode(size) {
         return Random.getRandomBuffer(size);
@@ -11,7 +12,7 @@ export class Random {
     }
     static getPseudoRandomBuffer(size) {
         const b32 = 0x100000000;
-        const b = Buffer.alloc(size);
+        const b = BufferUtil.alloc(size);
         let r = 0;
         for (let i = 0; i <= size; i++) {
             const j = Math.floor(i / 4);

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

@@ -1,7 +1,8 @@
-import { BN } from './bn.js';
-import { Point } from './point.js';
-import { Signature } from './signature.js';
-import { Hash } from './hash.js';
+import { BN } from './bn';
+import { Point } from './point';
+import { Signature } from './signature';
+import { Hash } from './hash';
+import { BufferUtil } from '../util';
 export class Schnorr {
     hashbuf;
     endian;
@@ -38,10 +39,10 @@ export class Schnorr {
         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, 'be');
+        const e = BN.fromBuffer(hashbuf);
         const obj = this._findSignature(d, e);
         obj.compressed = this.pubkey.compressed;
         obj.isSchnorr = true;
@@ -51,13 +52,13 @@ export class Schnorr {
     _findSignature(d, e) {
         const n = Point.getN();
         const G = Point.getG();
-        if (d.lte(new BN(0))) {
+        if (d.lte(BN.Zero)) {
             throw new Error('privkey out of field of curve');
         }
         if (d.gte(n)) {
             throw new Error('privkey out of field of curve');
         }
-        let k = this.nonceFunctionRFC6979(d.toArrayLike(Buffer, 'be', 32), e.toArrayLike(Buffer, 'be', 32));
+        let k = this.nonceFunctionRFC6979(d.toBuffer({ size: 32 }), e.toBuffer({ size: 32 }));
         const P = G.mul(d);
         const R = G.mul(k);
         if (R.hasSquare()) {
@@ -65,36 +66,26 @@ export class Schnorr {
         else {
             k = n.sub(k);
         }
-        const r = R.getX();
+        const r = R.x;
         const rBuffer = this.getrBuffer(r);
-        const e0 = new BN(Hash.sha256(Buffer.concat([
+        const e0 = BN.fromBuffer(Hash.sha256(BufferUtil.concat([
             rBuffer,
             Point.pointToCompressed(P),
-            e.toArrayLike(Buffer, 'be', 32),
-        ])), 'be');
+            e.toBuffer({ size: 32 }),
+        ])));
         const s = e0.mul(d).add(k).mod(n);
         return { r, s, compressed: this.pubkey.compressed, isSchnorr: true };
     }
     getrBuffer(r) {
-        const rNaturalLength = r.toArrayLike(Buffer, 'be').length;
-        if (rNaturalLength < 32) {
-            return r.toArrayLike(Buffer, 'be', 32);
-        }
-        return r.toArrayLike(Buffer, 'be');
+        const buf = r.toBuffer();
+        return buf.length < 32 ? r.toBuffer({ size: 32 }) : buf;
     }
     getsBuffer(s) {
-        const sNaturalLength = s.toArrayLike(Buffer, 'be').length;
-        if (sNaturalLength < 32) {
-            return s.toArrayLike(Buffer, 'be', 32);
-        }
-        return s.toArrayLike(Buffer, 'be');
+        const buf = s.toBuffer();
+        return buf.length < 32 ? s.toBuffer({ size: 32 }) : buf;
     }
     sigError() {
-        if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
-            return true;
-        }
-        const sigLength = this.getrBuffer(this.sig.r).length + this.getsBuffer(this.sig.s).length;
-        if (!(sigLength === 64 || sigLength === 65)) {
+        if (!BufferUtil.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
             return true;
         }
         const hashbuf = this.endian === 'little' ? this.reverseBuffer(this.hashbuf) : this.hashbuf;
@@ -105,53 +96,53 @@ export class Schnorr {
         }
         const r = this.sig.r;
         const s = this.sig.s;
-        const p = new BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
+        const p = BN.fromString('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 'hex');
         const n = Point.getN();
         if (r.gte(p) || s.gte(n)) {
             return true;
         }
         const Br = this.getrBuffer(this.sig.r);
         const Bp = Point.pointToCompressed(P);
-        const hash = Hash.sha256(Buffer.concat([Br, Bp, hashbuf]));
-        const e = new BN(hash, 'be').mod(n);
+        const hash = Hash.sha256(BufferUtil.concat([Br, Bp, hashbuf]));
+        const e = BN.fromBuffer(hash).mod(n);
         const sG = G.mul(s);
         const eP = P.mul(n.sub(e));
         const R = sG.add(eP);
-        if (R.isInfinity() || !R.hasSquare() || !R.getX().eq(r)) {
+        if (R.isInfinity() || !R.hasSquare() || !R.x.eq(r)) {
             return true;
         }
         return false;
     }
     verify() {
-        this.verified = !!!this.sigError();
+        this.verified = this.sigError() === false;
         return this;
     }
     nonceFunctionRFC6979(privkey, msgbuf) {
-        let V = Buffer.from('0101010101010101010101010101010101010101010101010101010101010101', 'hex');
-        let K = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
-        const blob = Buffer.concat([
+        let V = BufferUtil.from('0101010101010101010101010101010101010101010101010101010101010101', 'hex');
+        let K = BufferUtil.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+        const blob = BufferUtil.concat([
             privkey,
             msgbuf,
-            Buffer.from('', 'ascii'),
-            Buffer.from('Schnorr+SHA256  ', 'ascii'),
+            BufferUtil.from('', 'ascii'),
+            BufferUtil.from('Schnorr+SHA256  ', 'ascii'),
         ]);
-        K = Hash.sha256hmac(Buffer.concat([V, Buffer.from('00', 'hex'), blob]), K);
+        K = Hash.sha256hmac(BufferUtil.concat([V, BufferUtil.from('00', 'hex'), blob]), K);
         V = Hash.sha256hmac(V, K);
-        K = Hash.sha256hmac(Buffer.concat([V, Buffer.from('01', 'hex'), blob]), K);
+        K = Hash.sha256hmac(BufferUtil.concat([V, BufferUtil.from('01', 'hex'), blob]), K);
         V = Hash.sha256hmac(V, K);
-        let k = new BN(0);
+        let k = BN.Zero;
         let T;
         while (true) {
             V = Hash.sha256hmac(V, K);
-            T = new BN(V, 'be');
+            T = BN.fromBuffer(V);
             k = T;
             if (V.length < 32) {
                 throw new Error('V length should be >= 32');
             }
-            if (k.gt(new BN(0)) && k.lt(Point.getN())) {
+            if (k.gt(BN.Zero) && k.lt(Point.getN())) {
                 break;
             }
-            K = Hash.sha256hmac(Buffer.concat([V, Buffer.from('00', 'hex')]), K);
+            K = Hash.sha256hmac(BufferUtil.concat([V, BufferUtil.from('00', 'hex')]), K);
             V = Hash.sha256hmac(V, K);
         }
         return k;
@@ -176,7 +167,7 @@ export class Schnorr {
             .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];
         }