xpi-ts 0.2.13 → 0.2.15

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

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MerkleBlock = exports.MerkleBlockValidationError = exports.InvalidMerkleBlockError = void 0;
+const buffer_1 = require("buffer/");
+const blockheader_js_1 = require("./blockheader.js");
+const bufferreader_js_1 = require("../encoding/bufferreader.js");
+const bufferwriter_js_1 = require("../encoding/bufferwriter.js");
+const hash_js_1 = require("../crypto/hash.js");
+const buffer_js_1 = require("../util/buffer.js");
+const index_js_1 = require("../transaction/index.js");
+const errors_js_1 = require("../errors.js");
+const preconditions_js_1 = require("../util/preconditions.js");
+const bits_js_1 = require("../util/bits.js");
+const merkle_js_1 = require("../util/merkle.js");
+class InvalidMerkleBlockError extends Error {
+    code;
+    context;
+    constructor(message, context = {}) {
+        super(message);
+        this.name = 'InvalidMerkleBlockError';
+        this.code = 'INVALID_MERKLE_BLOCK';
+        this.context = context;
+    }
+}
+exports.InvalidMerkleBlockError = InvalidMerkleBlockError;
+class MerkleBlockValidationError extends Error {
+    code;
+    context;
+    constructor(message, context = {}) {
+        super(message);
+        this.name = 'MerkleBlockValidationError';
+        this.code = 'MERKLE_BLOCK_VALIDATION_ERROR';
+        this.context = context;
+    }
+}
+exports.MerkleBlockValidationError = MerkleBlockValidationError;
+class MerkleBlock {
+    static NULL_HASH = buffer_js_1.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_js_1.BlockHeader) {
+            this.header = info.header;
+        }
+        else {
+            this.header = new blockheader_js_1.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_js_1.BlockHeader.fromObject(obj.header),
+            numTransactions: obj.numTransactions,
+            hashes: obj.hashes,
+            flags: obj.flags,
+        });
+    }
+    static fromBuffer(buf) {
+        if (!buffer_js_1.BufferUtil.isBuffer(buf) || buf.length === 0) {
+            throw new InvalidMerkleBlockError('Invalid buffer provided', {
+                isBuffer: buffer_js_1.BufferUtil.isBuffer(buf),
+                length: buf?.length,
+            });
+        }
+        return MerkleBlock.fromBufferReader(new bufferreader_js_1.BufferReader(buf));
+    }
+    static fromBufferReader(br) {
+        const info = MerkleBlock._readFromBuffer(br);
+        return new MerkleBlock(info);
+    }
+    static fromString(str) {
+        preconditions_js_1.Preconditions.checkArgument(typeof str === 'string' && str.length > 0, 'str', 'Invalid hex string provided');
+        return MerkleBlock.fromBuffer(buffer_1.Buffer.from(str, 'hex'));
+    }
+    toBuffer() {
+        return this.toBufferWriter().concat();
+    }
+    toBufferWriter(bw) {
+        if (!bw) {
+            bw = new bufferwriter_js_1.BufferWriter();
+        }
+        bw.write(this.header.toBuffer());
+        bw.writeUInt32LE(this.numTransactions);
+        bw.writeVarintNum(this.hashes.length);
+        for (const hash of this.hashes) {
+            bw.write(buffer_1.Buffer.from(hash, 'hex'));
+        }
+        const flagBytes = (0, bits_js_1.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 buffer_js_1.BufferUtil.equals(root, this.header.merkleRoot);
+    }
+    filteredTxsHash() {
+        if (!Array.isArray(this.flags) || !Array.isArray(this.hashes)) {
+            throw new errors_js_1.BitcoreError.MerkleBlock.InvalidMerkleTree();
+        }
+        if (this.hashes.length > this.numTransactions) {
+            throw new errors_js_1.BitcoreError.MerkleBlock.InvalidMerkleTree();
+        }
+        if (this.flags.length * 8 < this.hashes.length) {
+            throw new errors_js_1.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 errors_js_1.BitcoreError.MerkleBlock.InvalidMerkleTree();
+        }
+        return state.txs;
+    }
+    hasTransaction(tx) {
+        if (!tx) {
+            throw new errors_js_1.BitcoreError('Transaction cannot be undefined');
+        }
+        if (!(tx instanceof index_js_1.Transaction) && typeof tx !== 'string') {
+            throw new errors_js_1.BitcoreError('Invalid transaction: must be string or Transaction');
+        }
+        if (typeof tx === 'string' && !/^[0-9a-fA-F]{64}$/.test(tx)) {
+            throw new errors_js_1.BitcoreError('Invalid transaction ID format: must be 64-character hex string');
+        }
+        let searchTxid;
+        let searchHash;
+        if (tx instanceof index_js_1.Transaction) {
+            searchTxid = buffer_js_1.BufferUtil.reverse(buffer_1.Buffer.from(tx.txid, 'hex')).toString('hex');
+            searchHash = buffer_js_1.BufferUtil.reverse(buffer_1.Buffer.from(tx.hash, 'hex')).toString('hex');
+        }
+        else {
+            searchTxid = buffer_js_1.BufferUtil.reverse(buffer_1.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 (buffer_js_1.BufferUtil.isBuffer(arg)) {
+            return MerkleBlock._readFromBuffer(new bufferreader_js_1.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_js_1.BlockHeader
+            ? data.header
+            : new blockheader_js_1.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_js_1.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 = (0, bits_js_1.bytesToBits)(flagBytes).map(b => (b ? 1 : 0));
+        return { header, numTransactions, hashes, flags };
+    }
+    _calcTreeWidth(height) {
+        return (0, merkle_js_1.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 = (0, bits_js_1.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_1.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_js_1.Hash.sha256sha256(buffer_1.Buffer.concat([left, right]));
+    }
+}
+exports.MerkleBlock = MerkleBlock;

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

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BN = void 0;
 const bn_js_1 = __importDefault(require("bn.js"));
+const util_1 = require("../util");
 class BNWrapper {
     _bn;
     static Zero = new BNWrapper(0);
@@ -14,7 +15,7 @@ class BNWrapper {
         if (n instanceof bn_js_1.default) {
             this._bn = n.clone();
         }
-        else if (Buffer.isBuffer(n)) {
+        else if (util_1.BufferUtil.isBuffer(n)) {
             if (base === 'le' || base === 'be') {
                 this._bn = new bn_js_1.default(n, undefined, base);
             }
@@ -33,7 +34,7 @@ class BNWrapper {
     static fromBuffer(buf, opts) {
         let buffer = buf;
         if (opts?.size) {
-            buffer = Buffer.alloc(opts.size);
+            buffer = util_1.BufferUtil.alloc(opts.size);
             buf.copy(buffer, opts.size - buf.length);
         }
         if (opts?.endian === 'little') {
@@ -43,7 +44,7 @@ class BNWrapper {
     }
     static fromSM(buf, opts) {
         if (buf.length === 0) {
-            return BNWrapper.fromBuffer(Buffer.from([0]));
+            return BNWrapper.fromBuffer(util_1.BufferUtil.from([0]));
         }
         let endian = 'big';
         if (opts) {
@@ -79,17 +80,17 @@ class BNWrapper {
         return BNWrapper.fromSM(buf, { endian: 'little' });
     }
     static reversebuf(buf) {
-        const buf2 = Buffer.alloc(buf.length);
+        const buf2 = util_1.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 = util_1.BufferUtil.alloc(size);
         for (let i = 0; i < buf.length; i++) {
             rbuf[rbuf.length - 1 - i] = buf[buf.length - 1 - i];
         }
@@ -120,28 +121,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 = util_1.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 = util_1.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 = util_1.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));
     }
@@ -202,7 +198,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 = util_1.BufferUtil.concat([util_1.BufferUtil.from([0x80]), buf]);
             }
             else {
                 buf[0] = buf[0] | 0x80;
@@ -211,11 +207,11 @@ class BNWrapper {
         else {
             buf = this.toBuffer();
             if (buf[0] & 0x80) {
-                buf = Buffer.concat([Buffer.from([0x00]), buf]);
+                buf = util_1.BufferUtil.concat([util_1.BufferUtil.from([0x00]), buf]);
             }
         }
         if (buf.length === 1 && buf[0] === 0) {
-            buf = Buffer.from([]);
+            buf = util_1.BufferUtil.from([]);
         }
         return buf;
     }

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

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ECDSA = void 0;
-const bn_js_1 = require("./bn.js");
-const point_js_1 = require("./point.js");
-const signature_js_1 = require("./signature.js");
-const hash_js_1 = require("./hash.js");
-const random_js_1 = require("./random.js");
-const publickey_js_1 = require("../publickey.js");
+const bn_1 = require("./bn");
+const point_1 = require("./point");
+const signature_1 = require("./signature");
+const hash_1 = require("./hash");
+const random_1 = require("./random");
+const publickey_1 = require("../publickey");
+const util_1 = require("../util");
 class ECDSA {
     hashbuf;
     endian;
@@ -62,35 +63,35 @@ class ECDSA {
         return new ECDSA(obj);
     }
     randomK() {
-        const N = point_js_1.Point.getN();
+        const N = point_1.Point.getN();
         let k;
         do {
-            k = new bn_js_1.BN(random_js_1.Random.getRandomBuffer(32), 'be');
-        } while (!(k.lt(N) && k.gt(new bn_js_1.BN(0))));
+            k = bn_1.BN.fromBuffer(random_1.Random.getRandomBuffer(32));
+        } while (!(k.lt(N) && k.gt(new bn_1.BN(0))));
         this.k = k;
         return this;
     }
     deterministicK(badrs = 0) {
-        let v = Buffer.alloc(32);
+        let v = util_1.BufferUtil.alloc(32);
         v.fill(0x01);
-        let k = Buffer.alloc(32);
+        let k = util_1.BufferUtil.alloc(32);
         k.fill(0x00);
         const x = this.privkey.toBuffer();
         const hashbuf = this.endian === 'little'
             ? this.reverseBuffer(this.hashbuf)
             : this.hashbuf;
-        k = hash_js_1.Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x00]), x, hashbuf]), k);
-        v = hash_js_1.Hash.sha256hmac(v, k);
-        k = hash_js_1.Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x01]), x, hashbuf]), k);
-        v = hash_js_1.Hash.sha256hmac(v, k);
-        v = hash_js_1.Hash.sha256hmac(v, k);
-        let T = new bn_js_1.BN(v, 'be');
-        const N = point_js_1.Point.getN();
-        for (let i = 0; i < badrs || !(T.lt(N) && T.gt(new bn_js_1.BN(0))); i++) {
-            k = hash_js_1.Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x00])]), k);
-            v = hash_js_1.Hash.sha256hmac(v, k);
-            v = hash_js_1.Hash.sha256hmac(v, k);
-            T = new bn_js_1.BN(v, 'be');
+        k = hash_1.Hash.sha256hmac(util_1.BufferUtil.concat([v, util_1.BufferUtil.from([0x00]), x, hashbuf]), k);
+        v = hash_1.Hash.sha256hmac(v, k);
+        k = hash_1.Hash.sha256hmac(util_1.BufferUtil.concat([v, util_1.BufferUtil.from([0x01]), x, hashbuf]), k);
+        v = hash_1.Hash.sha256hmac(v, k);
+        v = hash_1.Hash.sha256hmac(v, k);
+        let T = new bn_1.BN(v, 'be');
+        const N = point_1.Point.getN();
+        for (let i = 0; i < badrs || !(T.lt(N) && T.gt(new bn_1.BN(0))); i++) {
+            k = hash_1.Hash.sha256hmac(util_1.BufferUtil.concat([v, util_1.BufferUtil.from([0x00])]), k);
+            v = hash_1.Hash.sha256hmac(v, k);
+            v = hash_1.Hash.sha256hmac(v, k);
+            T = new bn_1.BN(v, 'be');
         }
         this.k = T;
         return this;
@@ -100,45 +101,45 @@ 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_js_1.BN(this.hashbuf, 'be');
+        const e = bn_1.BN.fromBuffer(this.hashbuf, { endian: 'big' });
         const r = this.sig.r;
         const s = this.sig.s;
         const isYOdd = (i & 1) !== 0;
         const isSecondKey = i >> 1 !== 0;
-        const n = point_js_1.Point.getN();
-        const G = point_js_1.Point.getG();
+        const n = point_1.Point.getN();
+        const G = point_1.Point.getG();
         const x = isSecondKey ? r.add(n) : r;
-        const R = point_js_1.Point.fromX(isYOdd, x);
+        const R = point_1.Point.fromX(isYOdd, x);
         const nR = R.mul(n);
         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_js_1.PublicKey.fromPoint(Q, this.sig.compressed);
+        const pubkey = publickey_1.PublicKey.fromPoint(Q, this.sig.compressed);
         return pubkey;
     }
     sigError() {
-        if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
+        if (!util_1.BufferUtil.isBuffer(this.hashbuf) || this.hashbuf.length !== 32) {
             return 'hashbuf must be a 32 byte buffer';
         }
         const r = this.sig.r;
         const s = this.sig.s;
-        const N = point_js_1.Point.getN();
-        if (!(r.gt(new bn_js_1.BN(0)) && r.lt(N)) || !(s.gt(new bn_js_1.BN(0)) && s.lt(N))) {
+        const N = point_1.Point.getN();
+        if (!(r.gt(new bn_1.BN(0)) && r.lt(N)) || !(s.gt(new bn_1.BN(0)) && s.lt(N))) {
             return 'r and s not in range';
         }
-        const e = new bn_js_1.BN(this.hashbuf, this.endian === 'little' ? 'le' : 'be');
-        const n = point_js_1.Point.getN();
+        const e = bn_1.BN.fromBuffer(this.hashbuf, { endian: this.endian || 'big' });
+        const n = point_1.Point.getN();
         const sinv = s.invm(n);
-        const u1 = sinv.mul(e).mod(n);
-        const u2 = sinv.mul(r).mod(n);
-        const p = point_js_1.Point.getG().mulAdd(u1, this.pubkey.point, u2);
+        const u1 = sinv.mul(e).umod(n);
+        const u2 = sinv.mul(r).umod(n);
+        const p = point_1.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 {
@@ -146,15 +147,15 @@ class ECDSA {
         }
     }
     static toLowS(s) {
-        const lowSThreshold = new bn_js_1.BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 16);
+        const lowSThreshold = new bn_1.BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 16);
         if (s.gt(lowSThreshold)) {
-            s = point_js_1.Point.getN().sub(s);
+            s = point_1.Point.getN().sub(s);
         }
         return s;
     }
     _findSignature(d, e) {
-        const N = point_js_1.Point.getN();
-        const G = point_js_1.Point.getG();
+        const N = point_1.Point.getN();
+        const G = point_1.Point.getG();
         let badrs = 0;
         let k, Q, r, s;
         do {
@@ -164,12 +165,12 @@ 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);
-        } while (r.cmp(new bn_js_1.BN(0)) <= 0 || s.cmp(new bn_js_1.BN(0)) <= 0);
+                .umod(N);
+        } while (r.cmp(new bn_1.BN(0)) <= 0 || s.cmp(new bn_1.BN(0)) <= 0);
         s = ECDSA.toLowS(s);
         return { s, r, compressed: this.pubkey.compressed };
     }
@@ -180,13 +181,13 @@ class ECDSA {
         if (!hashbuf || !privkey || !d) {
             throw new Error('invalid parameters');
         }
-        if (!Buffer.isBuffer(hashbuf) || hashbuf.length !== 32) {
+        if (!util_1.BufferUtil.isBuffer(hashbuf) || hashbuf.length !== 32) {
             throw new Error('hashbuf must be a 32 byte buffer');
         }
-        const e = new bn_js_1.BN(hashbuf, this.endian === 'little' ? 'le' : 'be');
+        const e = bn_1.BN.fromBuffer(hashbuf, { endian: this.endian || 'big' });
         const obj = this._findSignature(d, e);
         obj.compressed = this.pubkey.compressed;
-        this.sig = new signature_js_1.Signature(obj);
+        this.sig = new signature_1.Signature(obj);
         return this;
     }
     signRandomK() {
@@ -241,7 +242,7 @@ class ECDSA {
             .verify().verified;
     }
     reverseBuffer(buf) {
-        const buf2 = Buffer.alloc(buf.length);
+        const buf2 = util_1.BufferUtil.alloc(buf.length);
         for (let i = 0; i < buf.length; i++) {
             buf2[i] = buf[buf.length - 1 - i];
         }