xpi-ts 0.2.13 → 0.2.15

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

@@ -1,4 +1,6 @@
-import { BN } from './bn.js';
+import { BN } from './bn';
+import { BufferUtil } from '../util';
+import { isSchnorrSignature } from './sigtype';
 export class Signature {
     r;
     s;
@@ -12,6 +14,8 @@ export class Signature {
     static SIGHASH_FORKID = 0x40;
     static SIGHASH_LOTUS = 0x60;
     static SIGHASH_ANYONECANPAY = 0x80;
+    static SIGHASH_RESERVED = 0x20;
+    static SIGHASH_ALGORITHM_MASK = 0x60;
     constructor(r, s, isSchnorr) {
         if (r instanceof BN) {
             this.set({
@@ -38,18 +42,18 @@ export class Signature {
         return this;
     }
     static fromCompact(buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!BufferUtil.isBuffer(buf)) {
             throw new Error('Argument is expected to be a Buffer');
         }
         const sig = new Signature(new BN(0), new BN(0));
         let compressed = true;
-        let i = buf.subarray(0, 1)[0] - 27 - 4;
+        let i = buf.slice(0, 1)[0] - 27 - 4;
         if (i < 0) {
             compressed = false;
             i = i + 4;
         }
-        const b2 = buf.subarray(1, 33);
-        const b3 = buf.subarray(33, 65);
+        const b2 = buf.slice(1, 33);
+        const b3 = buf.slice(33, 65);
         if (!(i === 0 || i === 1 || i === 2 || i === 3)) {
             throw new Error('i must be 0, 1, 2, or 3');
         }
@@ -61,12 +65,13 @@ export class Signature {
         }
         sig.compressed = compressed;
         sig.i = i;
-        sig.r = new BN(b2, 'le');
-        sig.s = new BN(b3, 'le');
+        sig.r = BN.fromBuffer(b2);
+        sig.s = BN.fromBuffer(b3);
         return sig;
     }
     static fromDER(buf, strict = true) {
-        if ((buf.length === 64 || buf.length === 65) && buf[0] !== 0x30) {
+        const rawSig = buf.length === 65 && buf[0] !== 0x30 ? buf.slice(0, 64) : buf;
+        if (isSchnorrSignature(rawSig) && buf[0] !== 0x30) {
             const obj = Signature.parseSchnorrEncodedSig(buf);
             const sig = new Signature(new BN(0), new BN(0));
             sig.r = obj.r;
@@ -74,7 +79,7 @@ export class Signature {
             sig.isSchnorr = true;
             return sig;
         }
-        if (buf.length === 64 && buf[0] === 0x30) {
+        if (isSchnorrSignature(buf) && buf[0] === 0x30) {
             throw new Error('64 DER (ecdsa) signatures not allowed');
         }
         const obj = Signature.parseDER(buf, strict);
@@ -88,17 +93,17 @@ export class Signature {
     }
     static fromTxFormat(buf) {
         const nhashtype = buf.readUInt8(buf.length - 1);
-        const derbuf = buf.subarray(0, buf.length - 1);
+        const derbuf = buf.slice(0, buf.length - 1);
         const sig = Signature.fromDER(derbuf, false);
         sig.nhashtype = nhashtype;
         return sig;
     }
     static fromDataFormat(buf) {
-        const derbuf = buf.subarray(0, buf.length);
+        const derbuf = buf.slice(0, buf.length);
         return Signature.fromDER(derbuf, false);
     }
     static fromString(str) {
-        const buf = Buffer.from(str, 'hex');
+        const buf = BufferUtil.from(str, 'hex');
         return Signature.fromDER(buf);
     }
     static fromSchnorr(buf) {
@@ -114,20 +119,20 @@ export class Signature {
         if (buf.length !== 64 && buf.length !== 65) {
             throw new Error(`Invalid Schnorr signature length: ${buf.length} bytes (expected 64 or 65)`);
         }
-        const r = buf.subarray(0, 32);
-        const s = buf.subarray(32, 64);
+        const r = buf.slice(0, 32);
+        const s = buf.slice(32, 64);
         let hashtype;
         if (buf.length === 65) {
-            hashtype = buf.subarray(64, 65);
+            hashtype = buf.slice(64, 65);
         }
         return {
-            r: new BN(r, 'be'),
-            s: new BN(s, 'be'),
+            r: BN.fromBuffer(r),
+            s: BN.fromBuffer(s),
             nhashtype: hashtype,
         };
     }
     static parseDER(buf, strict = true) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!BufferUtil.isBuffer(buf)) {
             throw new Error('DER formatted signature should be a buffer');
         }
         const header = buf[0];
@@ -135,7 +140,7 @@ export class Signature {
             throw new Error('Header byte should be 0x30');
         }
         let length = buf[1];
-        const buflength = buf.subarray(2).length;
+        const buflength = buf.slice(2).length;
         if (strict && length !== buflength) {
             throw new Error('Length byte should length of what follows');
         }
@@ -145,7 +150,7 @@ export class Signature {
             throw new Error('Integer byte for r should be 0x02');
         }
         const rlength = buf[2 + 1];
-        const rbuf = buf.subarray(2 + 2, 2 + 2 + rlength);
+        const rbuf = buf.slice(2 + 2, 2 + 2 + rlength);
         const r = new BN(rbuf, 'be');
         if (rlength !== rbuf.length) {
             throw new Error('Length of r incorrect');
@@ -155,7 +160,7 @@ export class Signature {
             throw new Error('Integer byte for s should be 0x02');
         }
         const slength = buf[2 + 2 + rlength + 1];
-        const sbuf = buf.subarray(2 + 2 + rlength + 2, 2 + 2 + rlength + 2 + slength);
+        const sbuf = buf.slice(2 + 2 + rlength + 2, 2 + 2 + rlength + 2 + slength);
         const s = new BN(sbuf, 'be');
         if (slength !== sbuf.length) {
             throw new Error('Length of s incorrect');
@@ -179,34 +184,38 @@ export class Signature {
         if (isCompressed === false) {
             val = val - 4;
         }
-        const b1 = Buffer.from([val]);
-        const b2 = this.r.toArrayLike(Buffer, 'le', 32);
-        const b3 = this.s.toArrayLike(Buffer, 'le', 32);
-        return Buffer.concat([b1, b2, b3]);
+        const b1 = BufferUtil.from([val]);
+        const b2 = this.r.toBuffer({ size: 32 });
+        const b3 = this.s.toBuffer({ size: 32 });
+        return BufferUtil.concat([b1, b2, b3]);
     }
     toDER(signingMethod = 'ecdsa') {
         if (signingMethod === 'schnorr') {
-            return Buffer.concat([
-                this.r.toArrayLike(Buffer, 'be', 32),
-                this.s.toArrayLike(Buffer, 'be', 32),
+            return BufferUtil.concat([
+                this.r.toBuffer({ size: 32 }),
+                this.s.toBuffer({ size: 32 }),
             ]);
         }
-        const rnbuf = this.r.toArrayLike(Buffer, 'be');
-        const snbuf = this.s.toArrayLike(Buffer, 'be');
+        const rnbuf = this.r.toBuffer();
+        const snbuf = this.s.toBuffer();
         const rneg = (rnbuf[0] & 0x80) !== 0;
         const sneg = (snbuf[0] & 0x80) !== 0;
-        const rbuf = rneg ? Buffer.concat([Buffer.from([0x00]), rnbuf]) : rnbuf;
-        const sbuf = sneg ? Buffer.concat([Buffer.from([0x00]), snbuf]) : snbuf;
+        const rbuf = rneg
+            ? BufferUtil.concat([BufferUtil.from([0x00]), rnbuf])
+            : rnbuf;
+        const sbuf = sneg
+            ? BufferUtil.concat([BufferUtil.from([0x00]), snbuf])
+            : snbuf;
         const rlength = rbuf.length;
         const slength = sbuf.length;
         const length = 2 + rlength + 2 + slength;
         const rheader = 0x02;
         const sheader = 0x02;
         const header = 0x30;
-        return Buffer.concat([
-            Buffer.from([header, length, rheader, rlength]),
+        return BufferUtil.concat([
+            BufferUtil.from([header, length, rheader, rlength]),
             rbuf,
-            Buffer.from([sheader, slength]),
+            BufferUtil.from([sheader, slength]),
             sbuf,
         ]);
     }
@@ -221,9 +230,12 @@ export class Signature {
     }
     toTxFormat(signingMethod) {
         const derbuf = this.toDER(signingMethod);
-        const buf = Buffer.alloc(1);
-        buf.writeUInt8(this.nhashtype || 0, 0);
-        return Buffer.concat([derbuf, buf]);
+        const buf = BufferUtil.alloc(1);
+        const defaultSighash = this.isSchnorr
+            ? Signature.SIGHASH_ALL | Signature.SIGHASH_LOTUS
+            : 0;
+        buf.writeUInt8(this.nhashtype ?? defaultSighash, 0);
+        return BufferUtil.concat([derbuf, buf]);
     }
     static isDER(buf) {
         if (buf.length < 8 || buf.length > 72) {
@@ -271,8 +283,8 @@ export class Signature {
         return true;
     }
     hasLowS() {
-        const lowSThreshold = new BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 16);
-        if (this.s.lt(new BN(1)) || this.s.gt(lowSThreshold)) {
+        const lowSThreshold = BN.fromString('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 'hex');
+        if (this.s.lt(BN.One) || this.s.gt(lowSThreshold)) {
             return false;
         }
         return true;
@@ -281,20 +293,20 @@ export class Signature {
         if (typeof this.nhashtype !== 'number') {
             return false;
         }
-        if (this.nhashtype & Signature.SIGHASH_LOTUS) {
-            const baseMask = ~(Signature.SIGHASH_LOTUS | Signature.SIGHASH_ANYONECANPAY) >>> 0;
-            const baseType = this.nhashtype & baseMask;
-            return (baseType >= Signature.SIGHASH_ALL &&
-                baseType <= Signature.SIGHASH_SINGLE);
+        const baseType = this.nhashtype & 0x1f;
+        if (baseType < Signature.SIGHASH_ALL ||
+            baseType > Signature.SIGHASH_SINGLE) {
+            return false;
         }
-        const mask = ~(Signature.SIGHASH_FORKID | Signature.SIGHASH_ANYONECANPAY) >>> 0;
-        const temp = this.nhashtype & mask;
-        if (temp < Signature.SIGHASH_ALL || temp > Signature.SIGHASH_SINGLE) {
+        const algorithm = this.nhashtype & Signature.SIGHASH_ALGORITHM_MASK;
+        if (algorithm !== 0x00 &&
+            algorithm !== Signature.SIGHASH_FORKID &&
+            algorithm !== Signature.SIGHASH_LOTUS) {
             return false;
         }
         return true;
     }
     static isTxDER(buf) {
-        return Signature.isDER(buf.subarray(0, buf.length - 1));
+        return Signature.isDER(buf.slice(0, buf.length - 1));
     }
 }

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

@@ -11,7 +11,7 @@ export function isValidSignatureLength(sig) {
     if (sig.length === 64) {
         return true;
     }
-    if (sig.length >= 9 && sig.length <= 73) {
+    if (sig.length >= 8 && sig.length <= 72) {
         return true;
     }
     return false;

package/dist/esm/lib/bitcore/encoding/base58.js

@@ -1,9 +1,10 @@
 import bs58 from 'bs58';
+import { BufferUtil } from '../util';
 const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.split('');
 export class Base58 {
     buf;
     constructor(obj) {
-        if (Buffer.isBuffer(obj)) {
+        if (BufferUtil.isBuffer(obj)) {
             const buf = obj;
             this.fromBuffer(buf);
         }
@@ -16,7 +17,7 @@ export class Base58 {
         }
     }
     static validCharacters(chars) {
-        if (Buffer.isBuffer(chars)) {
+        if (BufferUtil.isBuffer(chars)) {
             chars = chars.toString();
         }
         return Array.from(chars).every(char => ALPHABET.includes(char));
@@ -26,7 +27,7 @@ export class Base58 {
         return this;
     }
     static encode(buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!BufferUtil.isBuffer(buf)) {
             throw new Error('Input should be a buffer');
         }
         return bs58.encode(buf);
@@ -35,7 +36,7 @@ export class Base58 {
         if (typeof str !== 'string') {
             throw new Error('Input should be a string');
         }
-        return Buffer.from(bs58.decode(str));
+        return BufferUtil.from(bs58.decode(str));
     }
     fromBuffer(buf) {
         this.buf = buf;

package/dist/esm/lib/bitcore/encoding/base58check.js

@@ -1,82 +1,36 @@
-import { sha256 } from '@noble/hashes/sha256';
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-const ALPHABET_MAP = {};
-for (let i = 0; i < ALPHABET.length; i++) {
-    ALPHABET_MAP[ALPHABET[i]] = i;
-}
+import { sha256 } from '@noble/hashes/sha2';
+import bs58 from 'bs58';
+import { BufferUtil } from '../util';
 export class Base58Check {
     static encode(buf) {
-        if (!Buffer.isBuffer(buf)) {
+        if (!BufferUtil.isBuffer(buf)) {
             throw new Error('Input must be a Buffer');
         }
         const checksum = this.checksum(buf);
-        const payload = Buffer.concat([buf, checksum]);
-        return this.base58Encode(payload);
+        const payload = BufferUtil.concat([buf, checksum]);
+        return bs58.encode(payload);
     }
     static decode(str) {
         if (typeof str !== 'string') {
             throw new Error('Input must be a string');
         }
-        const buf = this.base58Decode(str);
+        const buf = BufferUtil.from(bs58.decode(str));
         if (buf.length < 4) {
             throw new Error('Input string too short');
         }
-        const data = buf.subarray(0, -4);
-        const checksum = buf.subarray(-4);
+        const data = buf.slice(0, -4);
+        const checksum = buf.slice(-4);
         if (!this.validChecksum(data, checksum)) {
             throw new Error('Invalid checksum');
         }
         return data;
     }
     static checksum(data) {
-        const hash1 = sha256(data);
-        const hash2 = sha256(hash1);
-        return Buffer.from(hash2).subarray(0, 4);
+        const hash = sha256(sha256(data));
+        return BufferUtil.from(hash).slice(0, 4);
     }
     static validChecksum(data, checksum) {
         const calculatedChecksum = this.checksum(data);
         return calculatedChecksum.equals(checksum);
     }
-    static base58Encode(buf) {
-        if (buf.length === 0)
-            return '';
-        let num = 0n;
-        for (let i = 0; i < buf.length; i++) {
-            num = num * 256n + BigInt(buf[i]);
-        }
-        let result = '';
-        while (num > 0n) {
-            result = ALPHABET[Number(num % 58n)] + result;
-            num = num / 58n;
-        }
-        for (let i = 0; i < buf.length && buf[i] === 0; i++) {
-            result = '1' + result;
-        }
-        return result;
-    }
-    static base58Decode(str) {
-        if (str.length === 0)
-            return Buffer.alloc(0);
-        let num = 0n;
-        let leadingZeros = 0;
-        for (let i = 0; i < str.length; i++) {
-            const char = str[i];
-            if (ALPHABET_MAP[char] === undefined) {
-                throw new Error(`Invalid character: ${char}`);
-            }
-            num = num * 58n + BigInt(ALPHABET_MAP[char]);
-        }
-        for (let i = 0; i < str.length && str[i] === '1'; i++) {
-            leadingZeros++;
-        }
-        const bytes = [];
-        while (num > 0n) {
-            bytes.unshift(Number(num % 256n));
-            num = num / 256n;
-        }
-        for (let i = 0; i < leadingZeros; i++) {
-            bytes.unshift(0);
-        }
-        return Buffer.from(bytes);
-    }
 }

package/dist/esm/lib/bitcore/encoding/bufferreader.js

@@ -1,6 +1,6 @@
-import { Preconditions } from '../util/preconditions.js';
-import { BN } from '../crypto/bn.js';
-import { BufferUtil } from '../util/buffer.js';
+import { Preconditions } from '../util/preconditions';
+import { BN } from '../crypto/bn';
+import { BufferUtil } from '../util/buffer';
 export class BufferReader {
     buf;
     pos = 0;
@@ -8,13 +8,13 @@ export class BufferReader {
         if (buf === undefined) {
             return;
         }
-        if (Buffer.isBuffer(buf)) {
+        if (BufferUtil.isBuffer(buf)) {
             this.set({
                 buf: buf,
             });
         }
         else if (typeof buf === 'string') {
-            const b = Buffer.from(buf, 'hex');
+            const b = BufferUtil.from(buf, 'hex');
             if (b.length * 2 !== buf.length) {
                 throw new TypeError('Invalid hex string');
             }
@@ -112,7 +112,7 @@ export class BufferReader {
         }
         else {
             const data = Array.prototype.slice.call(this.buf, this.pos, this.pos + 8);
-            bn = new BN(Buffer.from(data), 'le');
+            bn = new BN(BufferUtil.from(data), 'le');
         }
         this.pos = this.pos + 8;
         return bn;
@@ -180,7 +180,7 @@ export class BufferReader {
         }
     }
     reverse() {
-        const buf = Buffer.alloc(this.buf.length);
+        const buf = BufferUtil.alloc(this.buf.length);
         for (let i = 0; i < buf.length; i++) {
             buf[i] = this.buf[this.buf.length - 1 - i];
         }

package/dist/esm/lib/bitcore/encoding/bufferwriter.js

@@ -1,5 +1,5 @@
-import { BufferUtil } from '../util/buffer.js';
-import { BN } from '../crypto/bn.js';
+import { BufferUtil } from '../util/buffer';
+import { BN } from '../crypto/bn';
 export class BufferWriter {
     bufs = [];
     bufLen = 0;
@@ -24,7 +24,7 @@ export class BufferWriter {
         return this.concat();
     }
     concat() {
-        return Buffer.concat(this.bufs, this.bufLen);
+        return BufferUtil.concat(this.bufs, this.bufLen);
     }
     write(buf) {
         if (!BufferUtil.isBuffer(buf)) {
@@ -43,49 +43,49 @@ export class BufferWriter {
         return this;
     }
     writeUInt8(n) {
-        const buf = Buffer.alloc(1);
+        const buf = BufferUtil.alloc(1);
         buf.writeUInt8(n, 0);
         this.write(buf);
         return this;
     }
     writeUInt16BE(n) {
-        const buf = Buffer.alloc(2);
+        const buf = BufferUtil.alloc(2);
         buf.writeUInt16BE(n, 0);
         this.write(buf);
         return this;
     }
     writeUInt16LE(n) {
-        const buf = Buffer.alloc(2);
+        const buf = BufferUtil.alloc(2);
         buf.writeUInt16LE(n, 0);
         this.write(buf);
         return this;
     }
     writeUInt32BE(n) {
-        const buf = Buffer.alloc(4);
+        const buf = BufferUtil.alloc(4);
         buf.writeUInt32BE(n, 0);
         this.write(buf);
         return this;
     }
     writeInt32LE(n) {
-        const buf = Buffer.alloc(4);
+        const buf = BufferUtil.alloc(4);
         buf.writeInt32LE(n, 0);
         this.write(buf);
         return this;
     }
     writeUInt32LE(n) {
-        const buf = Buffer.alloc(4);
+        const buf = BufferUtil.alloc(4);
         buf.writeUInt32LE(n, 0);
         this.write(buf);
         return this;
     }
     writeUInt48LE(n) {
-        const buf = Buffer.alloc(6);
+        const buf = BufferUtil.alloc(6);
         buf.writeUIntLE(n, 0, 6);
         this.write(buf);
         return this;
     }
     writeUInt56LE(n) {
-        const buf = Buffer.alloc(7);
+        const buf = BufferUtil.alloc(7);
         buf.writeUIntLE(n, 0, 7);
         this.write(buf);
         return this;
@@ -136,21 +136,21 @@ export class BufferWriter {
     static varintBufNum(n) {
         let buf;
         if (n < 253) {
-            buf = Buffer.alloc(1);
+            buf = BufferUtil.alloc(1);
             buf.writeUInt8(n, 0);
         }
         else if (n < 0x10000) {
-            buf = Buffer.alloc(1 + 2);
+            buf = BufferUtil.alloc(1 + 2);
             buf.writeUInt8(253, 0);
             buf.writeUInt16LE(n, 1);
         }
         else if (n < 0x100000000) {
-            buf = Buffer.alloc(1 + 4);
+            buf = BufferUtil.alloc(1 + 4);
             buf.writeUInt8(254, 0);
             buf.writeUInt32LE(n, 1);
         }
         else {
-            buf = Buffer.alloc(1 + 8);
+            buf = BufferUtil.alloc(1 + 8);
             buf.writeUInt8(255, 0);
             buf.writeInt32LE(n & -1, 1);
             buf.writeUInt32LE(Math.floor(n / 0x100000000), 5);
@@ -160,18 +160,18 @@ export class BufferWriter {
     static varintBufBN(bn) {
         const n = bn.toNumber();
         if (n < 253) {
-            const buf = Buffer.alloc(1);
+            const buf = BufferUtil.alloc(1);
             buf.writeUInt8(n, 0);
             return buf;
         }
         else if (n < 0x10000) {
-            const buf = Buffer.alloc(1 + 2);
+            const buf = BufferUtil.alloc(1 + 2);
             buf.writeUInt8(253, 0);
             buf.writeUInt16LE(n, 1);
             return buf;
         }
         else if (n < 0x100000000) {
-            const buf = Buffer.alloc(1 + 4);
+            const buf = BufferUtil.alloc(1 + 4);
             buf.writeUInt8(254, 0);
             buf.writeUInt32LE(n, 1);
             return buf;
@@ -184,6 +184,3 @@ export class BufferWriter {
         }
     }
 }
-export function BufferWriterFactory(obj) {
-    return new BufferWriter(obj);
-}

package/dist/esm/lib/bitcore/encoding/varint.js

@@ -1,10 +1,11 @@
-import { BufferWriter } from './bufferwriter.js';
-import { BufferReader } from './bufferreader.js';
-import { BN } from '../crypto/bn.js';
+import { BufferWriter } from './bufferwriter';
+import { BufferReader } from './bufferreader';
+import { BN } from '../crypto/bn';
+import { BufferUtil } from '../util';
 export class Varint {
-    buf = Buffer.alloc(0);
+    buf = BufferUtil.alloc(0);
     constructor(buf) {
-        if (Buffer.isBuffer(buf)) {
+        if (BufferUtil.isBuffer(buf)) {
             this.buf = buf;
         }
         else if (typeof buf === 'number') {
@@ -26,7 +27,7 @@ export class Varint {
     }
     fromString(str) {
         this.set({
-            buf: Buffer.from(str, 'hex'),
+            buf: BufferUtil.from(str, 'hex'),
         });
         return this;
     }

package/dist/esm/lib/bitcore/errors.js

@@ -318,6 +318,7 @@ export class BitcoreError extends Error {
         return traverseNode(BitcoreError, spec);
     }
     static NotImplemented;
+    static MerkleBlock;
     static Script;
     static Precondition;
     static Transaction;