xpi-ts 0.2.13 → 0.2.15

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

@@ -1,29 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Hash = void 0;
-const sha1_1 = require("@noble/hashes/sha1");
-const sha256_1 = require("@noble/hashes/sha256");
-const sha512_1 = require("@noble/hashes/sha512");
-const ripemd160_1 = require("@noble/hashes/ripemd160");
+const legacy_1 = require("@noble/hashes/legacy");
+const sha2_1 = require("@noble/hashes/sha2");
+const util_1 = require("../util");
 const sha1Func = (buf) => {
-    if (!Buffer.isBuffer(buf)) {
+    if (!util_1.BufferUtil.isBuffer(buf)) {
         throw new Error('Argument must be a Buffer');
     }
-    return Buffer.from((0, sha1_1.sha1)(buf));
+    return util_1.BufferUtil.from((0, legacy_1.sha1)(buf));
 };
 sha1Func.blocksize = 512;
 const sha256Func = (buf) => {
-    if (!Buffer.isBuffer(buf)) {
+    if (!util_1.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((0, sha256_1.sha256)(buf));
+    return util_1.BufferUtil.from((0, sha2_1.sha256)(buf));
 };
 sha256Func.blocksize = 512;
 const sha512Func = (buf) => {
-    if (!Buffer.isBuffer(buf)) {
+    if (!util_1.BufferUtil.isBuffer(buf)) {
         throw new Error('Argument must be a Buffer');
     }
-    return Buffer.from((0, sha512_1.sha512)(buf));
+    return util_1.BufferUtil.from((0, sha2_1.sha512)(buf));
 };
 sha512Func.blocksize = 1024;
 class Hash {
@@ -31,28 +31,28 @@ class Hash {
     static sha256 = sha256Func;
     static sha512 = sha512Func;
     static sha256sha256 = function (buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!util_1.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 (!util_1.BufferUtil.isBuffer(buf)) {
             throw new Error('Argument must be a Buffer');
         }
-        return Buffer.from((0, ripemd160_1.ripemd160)(buf));
+        return util_1.BufferUtil.from((0, legacy_1.ripemd160)(buf));
     };
     static sha256ripemd160 = function (buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!util_1.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 (!util_1.BufferUtil.isBuffer(data)) {
             throw new Error('Data must be a Buffer');
         }
-        if (!Buffer.isBuffer(key)) {
+        if (!util_1.BufferUtil.isBuffer(key)) {
             throw new Error('Key must be a Buffer');
         }
         if (!hashf.blocksize) {
@@ -64,22 +64,25 @@ class Hash {
             processedKey = hashf(key);
         }
         else if (key.length < blocksize) {
-            const fill = Buffer.alloc(blocksize);
+            const fill = util_1.BufferUtil.alloc(blocksize);
             fill.fill(0);
             key.copy(fill);
             processedKey = fill;
         }
-        const o_key = Buffer.alloc(blocksize);
+        const o_key = util_1.BufferUtil.alloc(blocksize);
         o_key.fill(0x5c);
-        const i_key = Buffer.alloc(blocksize);
+        const i_key = util_1.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 = util_1.BufferUtil.alloc(blocksize);
+        const i_key_pad = util_1.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(util_1.BufferUtil.concat([
+            o_key_pad,
+            hashf(util_1.BufferUtil.concat([i_key_pad, data])),
+        ]));
     }
     static sha256hmac(data, key) {
         return Hash.hmac(Hash.sha256, data, key);

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

@@ -1,41 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MUSIG_TAG_NONCE = exports.MUSIG_TAG_NONCE_COEFF = exports.MUSIG_TAG_KEYAGG_COEFF = exports.MUSIG_TAG_KEYSORT = void 0;
-exports.musigTaggedHash = musigTaggedHash;
-exports.musigKeyAgg = musigKeyAgg;
-exports.musigNonceGen = musigNonceGen;
-exports.musigNonceAgg = musigNonceAgg;
-exports.musigPartialSign = musigPartialSign;
-exports.musigPartialSigVerify = musigPartialSigVerify;
-exports.musigSigAgg = musigSigAgg;
-const publickey_js_1 = require("../publickey.js");
-const point_js_1 = require("./point.js");
-const bn_js_1 = require("./bn.js");
-const hash_js_1 = require("./hash.js");
-const signature_js_1 = require("./signature.js");
-exports.MUSIG_TAG_KEYSORT = 'KeyAgg list';
-exports.MUSIG_TAG_KEYAGG_COEFF = 'KeyAgg coefficient';
-exports.MUSIG_TAG_NONCE_COEFF = 'MuSig/noncecoef';
-const MUSIG_TAG_AUX = 'MuSig/aux';
-exports.MUSIG_TAG_NONCE = 'MuSig/nonce';
-function musigTaggedHash(tag, data) {
-    const tagHash = hash_js_1.Hash.sha256(Buffer.from(tag, 'utf8'));
-    const combined = Buffer.concat([tagHash, tagHash, data]);
-    return hash_js_1.Hash.sha256(combined);
+exports.MUSIG2_TAG_NONCE = exports.MUSIG2_TAG_AUX = exports.MUSIG2_TAG_NONCE_COEFF = exports.MUSIG2_TAG_KEYAGG_COEFF = exports.MUSIG2_TAG_KEYSORT = void 0;
+exports.muSig2TaggedHash = muSig2TaggedHash;
+exports.muSig2KeyAgg = muSig2KeyAgg;
+exports.muSig2NonceGen = muSig2NonceGen;
+exports.muSig2NonceAgg = muSig2NonceAgg;
+exports.muSig2PartialSign = muSig2PartialSign;
+exports.muSig2PartialSigVerify = muSig2PartialSigVerify;
+exports.muSig2SigAgg = muSig2SigAgg;
+const publickey_1 = require("../publickey");
+const point_1 = require("./point");
+const bn_1 = require("./bn");
+const hash_1 = require("./hash");
+const signature_1 = require("./signature");
+const util_1 = require("../util");
+exports.MUSIG2_TAG_KEYSORT = 'KeyAgg list';
+exports.MUSIG2_TAG_KEYAGG_COEFF = 'KeyAgg coefficient';
+exports.MUSIG2_TAG_NONCE_COEFF = 'MuSig/noncecoef';
+exports.MUSIG2_TAG_AUX = 'MuSig/aux';
+exports.MUSIG2_TAG_NONCE = 'MuSig/nonce';
+function muSig2TaggedHash(tag, data) {
+    const tagHash = hash_1.Hash.sha256(util_1.BufferUtil.from(tag, 'utf8'));
+    const combined = util_1.BufferUtil.concat([tagHash, tagHash, data]);
+    return hash_1.Hash.sha256(combined);
 }
 function hashKeys(pubkeys) {
-    const data = Buffer.concat(pubkeys.map(pk => pk.toBuffer()));
-    return musigTaggedHash(exports.MUSIG_TAG_KEYSORT, data);
+    const data = util_1.BufferUtil.concat(pubkeys.map(pk => pk.toBuffer()));
+    return muSig2TaggedHash(exports.MUSIG2_TAG_KEYSORT, data);
 }
 function keyAggCoeff(L, pubkey, isSecondKey, equalsFirstKey) {
     if (isSecondKey && equalsFirstKey) {
-        return new bn_js_1.BN(1);
+        return bn_1.BN.One;
     }
-    const data = Buffer.concat([L, pubkey.toBuffer()]);
-    const hash = musigTaggedHash(exports.MUSIG_TAG_KEYAGG_COEFF, data);
-    return new bn_js_1.BN(hash, 'be');
+    const data = util_1.BufferUtil.concat([L, pubkey.toBuffer()]);
+    const hash = muSig2TaggedHash(exports.MUSIG2_TAG_KEYAGG_COEFF, data);
+    return bn_1.BN.fromBuffer(hash);
 }
-function musigKeyAgg(pubkeys) {
+function muSig2KeyAgg(pubkeys) {
     if (pubkeys.length === 0) {
         throw new Error('Cannot aggregate zero public keys');
     }
@@ -56,13 +57,13 @@ 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_js_1.Point.getN();
+    const n = point_1.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,7 +76,7 @@ function musigKeyAgg(pubkeys) {
         throw new Error('Key aggregation failed: result is null');
     }
     Q.validate();
-    const aggregatedPubKey = new publickey_js_1.PublicKey(Q, {
+    const aggregatedPubKey = new publickey_1.PublicKey(Q, {
         compressed: true,
         network: sortedPubkeys[0].network,
     });
@@ -85,25 +86,25 @@ function musigKeyAgg(pubkeys) {
         aggregatedPubKey,
     };
 }
-function musigNonceGen(privateKey, aggregatedPubKey, message, extraInput) {
-    const G = point_js_1.Point.getG();
-    const n = point_js_1.Point.getN();
-    const sessionData = Buffer.concat([
-        privateKey.bn.toArrayLike(Buffer, 'be', 32),
+function muSig2NonceGen(privateKey, aggregatedPubKey, message, extraInput) {
+    const G = point_1.Point.getG();
+    const n = point_1.Point.getN();
+    const sessionData = util_1.BufferUtil.concat([
+        privateKey.bn.toBuffer({ size: 32 }),
         aggregatedPubKey.toBuffer(),
-        message || Buffer.alloc(32),
-        extraInput || Buffer.alloc(32),
+        message || util_1.BufferUtil.alloc(32),
+        extraInput || util_1.BufferUtil.alloc(32),
     ]);
-    const auxHash = musigTaggedHash(MUSIG_TAG_AUX, sessionData);
-    const rand1 = musigTaggedHash(exports.MUSIG_TAG_NONCE, Buffer.concat([auxHash, Buffer.from([0x01])]));
-    const rand2 = musigTaggedHash(exports.MUSIG_TAG_NONCE, Buffer.concat([auxHash, Buffer.from([0x02])]));
-    let k1 = new bn_js_1.BN(rand1, 'be').umod(n);
-    let k2 = new bn_js_1.BN(rand2, 'be').umod(n);
+    const auxHash = muSig2TaggedHash(exports.MUSIG2_TAG_AUX, sessionData);
+    const rand1 = muSig2TaggedHash(exports.MUSIG2_TAG_NONCE, util_1.BufferUtil.concat([auxHash, util_1.BufferUtil.from([0x01])]));
+    const rand2 = muSig2TaggedHash(exports.MUSIG2_TAG_NONCE, util_1.BufferUtil.concat([auxHash, util_1.BufferUtil.from([0x02])]));
+    let k1 = bn_1.BN.fromBuffer(rand1).umod(n);
+    let k2 = bn_1.BN.fromBuffer(rand2).umod(n);
     if (k1.isZero()) {
-        k1 = new bn_js_1.BN(1);
+        k1 = bn_1.BN.One;
     }
     if (k2.isZero()) {
-        k2 = new bn_js_1.BN(1);
+        k2 = bn_1.BN.One;
     }
     const R1 = G.mul(k1);
     const R2 = G.mul(k2);
@@ -114,7 +115,7 @@ function musigNonceGen(privateKey, aggregatedPubKey, message, extraInput) {
         publicNonces: [R1, R2],
     };
 }
-function musigNonceAgg(publicNonces) {
+function muSig2NonceAgg(publicNonces) {
     if (publicNonces.length === 0) {
         throw new Error('Cannot aggregate zero nonces');
     }
@@ -140,65 +141,67 @@ function musigNonceAgg(publicNonces) {
         R2: R2_agg,
     };
 }
-function musigPartialSign(secretNonce, privateKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
-    const n = point_js_1.Point.getN();
+function muSig2PartialSign(secretNonce, privateKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
+    const n = point_1.Point.getN();
     const [k1, k2] = secretNonce.secretNonces;
     const { R1, R2 } = aggregatedNonce;
     const Q = keyAggContext.aggregatedPubKey;
-    const nonceCoefData = Buffer.concat([
+    const nonceCoefData = util_1.BufferUtil.concat([
         Q.toBuffer(),
-        point_js_1.Point.pointToCompressed(R1),
-        point_js_1.Point.pointToCompressed(R2),
+        point_1.Point.pointToCompressed(R1),
+        point_1.Point.pointToCompressed(R2),
         message,
     ]);
-    const b = new bn_js_1.BN(musigTaggedHash(exports.MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+    const b = bn_1.BN.fromBuffer(muSig2TaggedHash(exports.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_js_1.Point.pointToCompressed(keyForChallenge.point);
-    const challengeData = Buffer.concat([R_x, Q_compressed, message]);
-    const e = new bn_js_1.BN(hash_js_1.Hash.sha256(challengeData), 'be').umod(n);
-    const a = keyAggContext.keyAggCoeff.get(signerIndex);
+    const Q_compressed = point_1.Point.pointToCompressed(keyForChallenge.point);
+    const challengeData = util_1.BufferUtil.concat([R_x, Q_compressed, message]);
+    const e = bn_1.BN.fromBuffer(hash_1.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;
 }
-function musigPartialSigVerify(partialSig, publicNonce, publicKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
+function muSig2PartialSigVerify(partialSig, publicNonce, publicKey, keyAggContext, signerIndex, aggregatedNonce, message, publicKeyForChallenge) {
     try {
-        const G = point_js_1.Point.getG();
-        const n = point_js_1.Point.getN();
+        const G = point_1.Point.getG();
+        const n = point_1.Point.getN();
         const [R1_i, R2_i] = publicNonce;
         const { R1, R2 } = aggregatedNonce;
         const Q = keyAggContext.aggregatedPubKey;
-        const nonceCoefData = Buffer.concat([
+        const nonceCoefData = util_1.BufferUtil.concat([
             Q.toBuffer(),
-            point_js_1.Point.pointToCompressed(R1),
-            point_js_1.Point.pointToCompressed(R2),
+            point_1.Point.pointToCompressed(R1),
+            point_1.Point.pointToCompressed(R2),
             message,
         ]);
-        const b = new bn_js_1.BN(musigTaggedHash(exports.MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+        const b = bn_1.BN.fromBuffer(muSig2TaggedHash(exports.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_js_1.Point.pointToCompressed(keyForChallenge.point);
-        const challengeData = Buffer.concat([R_x, Q_compressed, message]);
-        const e = new bn_js_1.BN(hash_js_1.Hash.sha256(challengeData), 'be').umod(n);
-        const a = keyAggContext.keyAggCoeff.get(signerIndex);
+        const Q_compressed = point_1.Point.pointToCompressed(keyForChallenge.point);
+        const challengeData = util_1.BufferUtil.concat([R_x, Q_compressed, message]);
+        const e = bn_1.BN.fromBuffer(hash_1.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_js_1.BN(1))) : R_i;
+        const R_i_adjusted = negated ? R_i.mul(n.sub(bn_1.BN.One)) : R_i;
         const rhs = R_i_adjusted.add(eaP);
         return lhs.eq(rhs);
     }
@@ -206,30 +209,30 @@ function musigPartialSigVerify(partialSig, publicNonce, publicKey, keyAggContext
         return false;
     }
 }
-function musigSigAgg(partialSigs, aggregatedNonce, message, aggregatedPubKey, sighashType, publicKeyForNonceCoef) {
+function muSig2SigAgg(partialSigs, aggregatedNonce, message, aggregatedPubKey, sighashType, publicKeyForNonceCoef) {
     if (partialSigs.length === 0) {
         throw new Error('Cannot aggregate zero partial signatures');
     }
-    const n = point_js_1.Point.getN();
+    const n = point_1.Point.getN();
     const { R1, R2 } = aggregatedNonce;
     const keyForNonceCoef = publicKeyForNonceCoef || aggregatedPubKey;
-    const nonceCoefData = Buffer.concat([
+    const nonceCoefData = util_1.BufferUtil.concat([
         keyForNonceCoef.toBuffer(),
-        point_js_1.Point.pointToCompressed(R1),
-        point_js_1.Point.pointToCompressed(R2),
+        point_1.Point.pointToCompressed(R1),
+        point_1.Point.pointToCompressed(R2),
         message,
     ]);
-    const b = new bn_js_1.BN(musigTaggedHash(exports.MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+    const b = bn_1.BN.fromBuffer(muSig2TaggedHash(exports.MUSIG2_TAG_NONCE_COEFF, nonceCoefData));
     const R = R1.add(R2.mul(b));
-    let s = new bn_js_1.BN(0);
+    let s = bn_1.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 signature = new signature_js_1.Signature({
+    const r = R.x;
+    const signature = new signature_1.Signature({
         r: r,
         s: s,
         compressed: true,
@@ -238,12 +241,3 @@ function musigSigAgg(partialSigs, aggregatedNonce, message, aggregatedPubKey, si
     });
     return signature;
 }
-exports.default = {
-    musigKeyAgg,
-    musigNonceGen,
-    musigNonceAgg,
-    musigPartialSign,
-    musigPartialSigVerify,
-    musigSigAgg,
-    musigTaggedHash,
-};

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

@@ -3,18 +3,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Point = void 0;
+exports.Point = exports.PREFIX_Y_EVEN = exports.PREFIX_Y_ODD = void 0;
 const elliptic_1 = __importDefault(require("elliptic"));
-const bn_js_1 = require("./bn.js");
+const bn_1 = require("./bn");
+const util_1 = require("../util");
 const ecInstance = new elliptic_1.default.ec('secp256k1');
 const ecPoint = ecInstance.curve.point.bind(ecInstance.curve);
 const ecPointFromX = ecInstance.curve.pointFromX.bind(ecInstance.curve);
+exports.PREFIX_Y_ODD = 0x03;
+exports.PREFIX_Y_EVEN = 0x02;
 class Point {
     _point;
+    static PrefixOddY = util_1.BufferUtil.from([exports.PREFIX_Y_ODD]);
+    static PrefixEvenY = util_1.BufferUtil.from([exports.PREFIX_Y_EVEN]);
     constructor(x, y, isRed) {
         try {
-            const bnX = x instanceof bn_js_1.BN ? x.bn : new bn_js_1.BN(x);
-            const bnY = y instanceof bn_js_1.BN ? y.bn : new bn_js_1.BN(y);
+            const bnX = x instanceof bn_1.BN ? x.bn : new bn_1.BN(x);
+            const bnY = y instanceof bn_1.BN ? y.bn : new bn_1.BN(y);
             this._point = ecPoint(bnX, bnY, isRed);
         }
         catch (e) {
@@ -22,27 +27,35 @@ class Point {
         }
         this.validate();
     }
+    get x() {
+        const xBuffer = this._point.getX().toBuffer();
+        return bn_1.BN.fromString(xBuffer.toString('hex'), 'hex');
+    }
+    get y() {
+        const yBuffer = this._point.getY().toBuffer();
+        return bn_1.BN.fromString(yBuffer.toString('hex'), 'hex');
+    }
     static fromX(odd, x) {
         try {
             const xStr = typeof x === 'string' ? x : x.toString();
             let point;
             try {
-                const bnX = x instanceof bn_js_1.BN ? x.bn : new bn_js_1.BN(xStr);
+                const bnX = x instanceof bn_1.BN ? x.bn : new bn_1.BN(xStr);
                 point = ecInstance.curve.pointFromX(bnX, odd);
             }
             catch (e1) {
                 try {
                     const hexStr = typeof x === 'string' ? x : '0x' + x.toString(16);
-                    const bnX = new bn_js_1.BN(hexStr);
+                    const bnX = new bn_1.BN(hexStr);
                     point = ecInstance.curve.pointFromX(bnX, odd);
                 }
                 catch (e2) {
-                    const xBigInt = typeof x === 'string' ? new bn_js_1.BN(xStr) : x.bn;
+                    const xBigInt = typeof x === 'string' ? new bn_1.BN(xStr) : x.bn;
                     const y = ecInstance.curve.yFromX(xBigInt.toString(), odd);
                     point = ecInstance.curve.point(xBigInt.toString(), y);
                 }
             }
-            const instance = new Point(new bn_js_1.BN(0), new bn_js_1.BN(0));
+            const instance = new Point(new bn_1.BN(0), new bn_1.BN(0));
             instance._point = point;
             instance.validate();
             return instance;
@@ -52,26 +65,20 @@ class Point {
         }
     }
     static getG() {
-        const instance = new Point(new bn_js_1.BN(0), new bn_js_1.BN(0));
+        const instance = new Point(new bn_1.BN(0), new bn_1.BN(0));
         instance._point = ecInstance.curve.g;
         return instance;
     }
     static getN() {
-        return new bn_js_1.BN(ecInstance.curve.n.toArray());
-    }
-    getX() {
-        return new bn_js_1.BN(this._point.getX().toString());
-    }
-    getY() {
-        return new bn_js_1.BN(this._point.getY().toString());
+        return new bn_1.BN(ecInstance.curve.n.toArray());
     }
     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');
             }
@@ -90,17 +97,17 @@ class Point {
         return this._point.isInfinity();
     }
     add(other) {
-        const result = new Point(new bn_js_1.BN(0), new bn_js_1.BN(0));
+        const result = new Point(new bn_1.BN(0), new bn_1.BN(0));
         result._point = this._point.add(other._point);
         return result;
     }
     mul(scalar) {
-        const result = new Point(new bn_js_1.BN(0), new bn_js_1.BN(0));
+        const result = new Point(new bn_1.BN(0), new bn_1.BN(0));
         result._point = this._point.mul(scalar.bn);
         return result;
     }
     mulAdd(scalar1, other, scalar2) {
-        const result = new Point(new bn_js_1.BN(0), new bn_js_1.BN(0));
+        const result = new Point(new bn_1.BN(0), new bn_1.BN(0));
         const point1 = this._point.mul(scalar1.bn);
         const point2 = other._point.mul(scalar2.bn);
         result._point = point1.add(point2);
@@ -110,31 +117,31 @@ class Point {
         return this._point.eq(other._point);
     }
     static pointToCompressed(point) {
-        const xbuf = point.getX().toArrayLike(Buffer, 'be', 32);
-        const y = point.getY();
-        const odd = y.mod(new bn_js_1.BN(2)).isOdd();
-        const prefix = odd ? Buffer.from([0x03]) : Buffer.from([0x02]);
-        return Buffer.concat([prefix, xbuf]);
+        const xbuf = point.x.toBuffer({ size: 32 });
+        const y = point.y;
+        const odd = y.mod(new bn_1.BN(2)).isOdd();
+        const prefix = odd ? Point.PrefixOddY : Point.PrefixEvenY;
+        return util_1.BufferUtil.concat([prefix, xbuf]);
     }
     hasSquare() {
         if (this.isInfinity()) {
             return false;
         }
-        const x = this.getX();
-        const y = this.getY();
-        const p = new bn_js_1.BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
+        const x = this.x;
+        const y = this.y;
+        const p = new bn_1.BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
         const x3 = x.mul(x).mod(p).mul(x).mod(p);
-        const c = x3.add(new bn_js_1.BN(7)).mod(p);
-        const exp = p.add(new bn_js_1.BN(1)).div(new bn_js_1.BN(4));
+        const c = x3.add(new bn_1.BN(7)).mod(p);
+        const exp = p.add(new bn_1.BN(1)).div(new bn_1.BN(4));
         const canonicalY = c.modPow(exp, p);
         return y.eq(canonicalY);
     }
     isSquare(x) {
-        const p = new bn_js_1.BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
-        const x0 = new bn_js_1.BN(x.toString());
-        const exponent = p.sub(new bn_js_1.BN(1)).div(new bn_js_1.BN(2));
+        const p = new bn_1.BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
+        const x0 = new bn_1.BN(x.toString());
+        const exponent = p.sub(new bn_1.BN(1)).div(new bn_1.BN(2));
         const result = x0.modPow(exponent, p);
-        return result.eq(new bn_js_1.BN(1));
+        return result.eq(new bn_1.BN(1));
     }
 }
 exports.Point = Point;

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

@@ -2,9 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Random = void 0;
 const utils_1 = require("@noble/hashes/utils");
+const util_1 = require("../util");
 class Random {
     static getRandomBuffer(size) {
-        return Buffer.from((0, utils_1.randomBytes)(size));
+        return util_1.BufferUtil.from((0, utils_1.randomBytes)(size));
     }
     static getRandomBufferNode(size) {
         return Random.getRandomBuffer(size);
@@ -14,7 +15,7 @@ class Random {
     }
     static getPseudoRandomBuffer(size) {
         const b32 = 0x100000000;
-        const b = Buffer.alloc(size);
+        const b = util_1.BufferUtil.alloc(size);
         let r = 0;
         for (let i = 0; i <= size; i++) {
             const j = Math.floor(i / 4);