xpi-ts 0.2.0

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

@@ -0,0 +1,185 @@
+import { BN } from './bn.js';
+import { Point } from './point.js';
+import { Signature } from './signature.js';
+import { Hash } from './hash.js';
+export class Schnorr {
+    hashbuf;
+    endian;
+    privkey;
+    pubkey;
+    sig;
+    verified;
+    constructor(obj) {
+        if (obj) {
+            this.set(obj);
+        }
+    }
+    set(obj) {
+        this.hashbuf = obj.hashbuf || this.hashbuf;
+        this.endian = obj.endian || this.endian;
+        this.privkey = obj.privkey || this.privkey;
+        this.pubkey =
+            obj.pubkey || (this.privkey ? this.privkey.toPublicKey() : this.pubkey);
+        this.sig = obj.sig || this.sig;
+        this.verified = obj.verified || this.verified;
+        return this;
+    }
+    privkey2pubkey() {
+        this.pubkey = this.privkey.toPublicKey();
+        return this;
+    }
+    toPublicKey() {
+        return this.privkey.toPublicKey();
+    }
+    sign() {
+        const hashbuf = this.hashbuf;
+        const privkey = this.privkey;
+        const d = privkey.bn;
+        if (!hashbuf || !privkey || !d) {
+            throw new Error('invalid parameters');
+        }
+        if (!Buffer.isBuffer(hashbuf) || hashbuf.length !== 32) {
+            throw new Error('hashbuf must be a 32 byte buffer');
+        }
+        const e = new BN(hashbuf, 'be');
+        const obj = this._findSignature(d, e);
+        obj.compressed = this.pubkey.compressed;
+        obj.isSchnorr = true;
+        this.sig = new Signature(obj);
+        return this;
+    }
+    _findSignature(d, e) {
+        const n = Point.getN();
+        const G = Point.getG();
+        if (d.lte(new BN(0))) {
+            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));
+        const P = G.mul(d);
+        const R = G.mul(k);
+        if (R.hasSquare()) {
+        }
+        else {
+            k = n.sub(k);
+        }
+        const r = R.getX();
+        const rBuffer = this.getrBuffer(r);
+        const e0 = new BN(Hash.sha256(Buffer.concat([
+            rBuffer,
+            Point.pointToCompressed(P),
+            e.toArrayLike(Buffer, 'be', 32),
+        ])), 'be');
+        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');
+    }
+    getsBuffer(s) {
+        const sNaturalLength = s.toArrayLike(Buffer, 'be').length;
+        if (sNaturalLength < 32) {
+            return s.toArrayLike(Buffer, 'be', 32);
+        }
+        return s.toArrayLike(Buffer, 'be');
+    }
+    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)) {
+            return true;
+        }
+        const hashbuf = this.endian === 'little' ? this.reverseBuffer(this.hashbuf) : this.hashbuf;
+        const P = this.pubkey.point;
+        const G = Point.getG();
+        if (P.isInfinity()) {
+            return true;
+        }
+        const r = this.sig.r;
+        const s = this.sig.s;
+        const p = new BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
+        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 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)) {
+            return true;
+        }
+        return false;
+    }
+    verify() {
+        this.verified = !!!this.sigError();
+        return this;
+    }
+    nonceFunctionRFC6979(privkey, msgbuf) {
+        let V = Buffer.from('0101010101010101010101010101010101010101010101010101010101010101', 'hex');
+        let K = Buffer.from('0000000000000000000000000000000000000000000000000000000000000000', 'hex');
+        const blob = Buffer.concat([
+            privkey,
+            msgbuf,
+            Buffer.from('', 'ascii'),
+            Buffer.from('Schnorr+SHA256  ', 'ascii'),
+        ]);
+        K = Hash.sha256hmac(Buffer.concat([V, Buffer.from('00', 'hex'), blob]), K);
+        V = Hash.sha256hmac(V, K);
+        K = Hash.sha256hmac(Buffer.concat([V, Buffer.from('01', 'hex'), blob]), K);
+        V = Hash.sha256hmac(V, K);
+        let k = new BN(0);
+        let T;
+        while (true) {
+            V = Hash.sha256hmac(V, K);
+            T = new BN(V, 'be');
+            k = T;
+            if (V.length < 32) {
+                throw new Error('V length should be >= 32');
+            }
+            if (k.gt(new BN(0)) && k.lt(Point.getN())) {
+                break;
+            }
+            K = Hash.sha256hmac(Buffer.concat([V, Buffer.from('00', 'hex')]), K);
+            V = Hash.sha256hmac(V, K);
+        }
+        return k;
+    }
+    static sign(hashbuf, privkey, endian) {
+        return new Schnorr()
+            .set({
+            hashbuf: hashbuf,
+            endian: endian,
+            privkey: privkey,
+        })
+            .sign().sig;
+    }
+    static verify(hashbuf, sig, pubkey, endian) {
+        return new Schnorr()
+            .set({
+            hashbuf: hashbuf,
+            endian: endian,
+            sig: sig,
+            pubkey: pubkey,
+        })
+            .verify().verified;
+    }
+    reverseBuffer(buf) {
+        const buf2 = Buffer.alloc(buf.length);
+        for (let i = 0; i < buf.length; i++) {
+            buf2[i] = buf[buf.length - 1 - i];
+        }
+        return buf2;
+    }
+}

package/dist/lib/bitcore/crypto/signature.d.ts

@@ -0,0 +1,53 @@
+import { BN } from './bn.js';
+export interface SignatureData {
+    r: BN;
+    s: BN;
+    i?: number;
+    compressed?: boolean;
+    isSchnorr?: boolean;
+    nhashtype?: number;
+}
+export type SignatureSigningMethod = 'schnorr' | 'ecdsa';
+export declare class Signature {
+    r: BN;
+    s: BN;
+    i?: number;
+    compressed?: boolean;
+    isSchnorr?: boolean;
+    nhashtype?: number;
+    static readonly SIGHASH_ALL = 1;
+    static readonly SIGHASH_NONE = 2;
+    static readonly SIGHASH_SINGLE = 3;
+    static readonly SIGHASH_FORKID = 64;
+    static readonly SIGHASH_LOTUS = 96;
+    static readonly SIGHASH_ANYONECANPAY = 128;
+    constructor(r: BN | SignatureData, s?: BN, isSchnorr?: boolean);
+    static create(r?: BN | SignatureData, s?: BN, isSchnorr?: boolean): Signature;
+    set(obj: SignatureData): Signature;
+    static fromCompact(buf: Buffer): Signature;
+    static fromDER(buf: Buffer, strict?: boolean): Signature;
+    static fromBuffer(buf: Buffer, strict?: boolean): Signature;
+    static fromTxFormat(buf: Buffer): Signature;
+    static fromDataFormat(buf: Buffer): Signature;
+    static fromString(str: string): Signature;
+    static fromSchnorr(buf: Buffer): Signature;
+    static parseSchnorrEncodedSig(buf: Buffer): {
+        r: BN;
+        s: BN;
+        nhashtype?: Buffer;
+    };
+    static parseDER(buf: Buffer, strict?: boolean): {
+        r: BN;
+        s: BN;
+    };
+    toCompact(i?: number, compressed?: boolean): Buffer;
+    toDER(signingMethod?: string): Buffer;
+    toBuffer(signingMethod?: string): Buffer;
+    toString(): string;
+    toTxFormat(signingMethod?: SignatureSigningMethod): Buffer;
+    static isDER(buf: Buffer): boolean;
+    hasLowS(): boolean;
+    hasDefinedHashtype(): boolean;
+    static isTxDER(buf: Buffer): boolean;
+}
+//# sourceMappingURL=signature.d.ts.map

package/dist/lib/bitcore/crypto/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/signature.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAY5B,MAAM,WAAW,aAAa;IAC5B,CAAC,EAAE,EAAE,CAAA;IACL,CAAC,EAAE,EAAE,CAAA;IACL,CAAC,CAAC,EAAE,MAAM,CAAA;IACV,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED,MAAM,MAAM,sBAAsB,GAAG,SAAS,GAAG,OAAO,CAAA;AAgCxD,qBAAa,SAAS;IAEpB,CAAC,EAAG,EAAE,CAAA;IAGN,CAAC,EAAG,EAAE,CAAA;IAGN,CAAC,CAAC,EAAE,MAAM,CAAA;IAGV,UAAU,CAAC,EAAE,OAAO,CAAA;IAGpB,SAAS,CAAC,EAAE,OAAO,CAAA;IAGnB,SAAS,CAAC,EAAE,MAAM,CAAA;IAclB,MAAM,CAAC,QAAQ,CAAC,WAAW,KAAO;IAclC,MAAM,CAAC,QAAQ,CAAC,YAAY,KAAO;IAenC,MAAM,CAAC,QAAQ,CAAC,cAAc,KAAO;IAoBrC,MAAM,CAAC,QAAQ,CAAC,cAAc,MAAO;IAiCrC,MAAM,CAAC,QAAQ,CAAC,aAAa,MAAO;IAmBpC,MAAM,CAAC,QAAQ,CAAC,oBAAoB,OAAO;gBAyB/B,CAAC,EAAE,EAAE,GAAG,aAAa,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,SAAS,CAAC,EAAE,OAAO;IAoB9D,MAAM,CAAC,MAAM,CACX,CAAC,CAAC,EAAE,EAAE,GAAG,aAAa,EACtB,CAAC,CAAC,EAAE,EAAE,EACN,SAAS,CAAC,EAAE,OAAO,GAClB,SAAS;IAaZ,GAAG,CAAC,GAAG,EAAE,aAAa,GAAG,SAAS;IA4BlC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAwD1C,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAc,GAAG,SAAS;IA6B9D,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAc,GAAG,SAAS;IAgBjE,MAAM,CAAC,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAc3C,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAW7C,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAazC,MAAM,CAAC,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS;IAmB1C,MAAM,CAAC,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG;QAC1C,CAAC,EAAE,EAAE,CAAA;QACL,CAAC,EAAE,EAAE,CAAA;QACL,SAAS,CAAC,EAAE,MAAM,CAAA;KACnB;IA4CD,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,GAAE,OAAc,GAAG;QAAE,CAAC,EAAE,EAAE,CAAC;QAAC,CAAC,EAAE,EAAE,CAAA;KAAE;IAwEtE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,MAAM;IAqCnD,KAAK,CAAC,aAAa,GAAE,MAAgB,GAAG,MAAM;IAwC9C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM;IAexC,QAAQ,IAAI,MAAM;IAyBlB,UAAU,CAAC,aAAa,CAAC,EAAE,sBAAsB,GAAG,MAAM;IAsB1D,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IA4ElC,OAAO,IAAI,OAAO;IAqBlB,kBAAkB,IAAI,OAAO;IAqC7B,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;CAGrC"}

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

@@ -0,0 +1,300 @@
+import { BN } from './bn.js';
+export class Signature {
+    r;
+    s;
+    i;
+    compressed;
+    isSchnorr;
+    nhashtype;
+    static SIGHASH_ALL = 0x01;
+    static SIGHASH_NONE = 0x02;
+    static SIGHASH_SINGLE = 0x03;
+    static SIGHASH_FORKID = 0x40;
+    static SIGHASH_LOTUS = 0x60;
+    static SIGHASH_ANYONECANPAY = 0x80;
+    constructor(r, s, isSchnorr) {
+        if (r instanceof BN) {
+            this.set({
+                r: r,
+                s: s,
+                isSchnorr: isSchnorr,
+            });
+        }
+        else if (r) {
+            this.set(r);
+        }
+    }
+    static create(r, s, isSchnorr) {
+        return new Signature(r, s, isSchnorr);
+    }
+    set(obj) {
+        this.r = obj.r || this.r || undefined;
+        this.s = obj.s || this.s || undefined;
+        this.i = typeof obj.i !== 'undefined' ? obj.i : this.i;
+        this.compressed =
+            typeof obj.compressed !== 'undefined' ? obj.compressed : this.compressed;
+        this.isSchnorr = obj.isSchnorr;
+        this.nhashtype = obj.nhashtype || this.nhashtype || undefined;
+        return this;
+    }
+    static fromCompact(buf) {
+        if (!Buffer.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;
+        if (i < 0) {
+            compressed = false;
+            i = i + 4;
+        }
+        const b2 = buf.subarray(1, 33);
+        const b3 = buf.subarray(33, 65);
+        if (!(i === 0 || i === 1 || i === 2 || i === 3)) {
+            throw new Error('i must be 0, 1, 2, or 3');
+        }
+        if (b2.length !== 32) {
+            throw new Error('r must be 32 bytes');
+        }
+        if (b3.length !== 32) {
+            throw new Error('s must be 32 bytes');
+        }
+        sig.compressed = compressed;
+        sig.i = i;
+        sig.r = new BN(b2, 'le');
+        sig.s = new BN(b3, 'le');
+        return sig;
+    }
+    static fromDER(buf, strict = true) {
+        if ((buf.length === 64 || buf.length === 65) && buf[0] !== 0x30) {
+            const obj = Signature.parseSchnorrEncodedSig(buf);
+            const sig = new Signature(new BN(0), new BN(0));
+            sig.r = obj.r;
+            sig.s = obj.s;
+            sig.isSchnorr = true;
+            return sig;
+        }
+        if (buf.length === 64 && buf[0] === 0x30) {
+            throw new Error('64 DER (ecdsa) signatures not allowed');
+        }
+        const obj = Signature.parseDER(buf, strict);
+        const sig = new Signature(new BN(0), new BN(0));
+        sig.r = obj.r;
+        sig.s = obj.s;
+        return sig;
+    }
+    static fromBuffer(buf, strict = true) {
+        return Signature.fromDER(buf, strict);
+    }
+    static fromTxFormat(buf) {
+        const nhashtype = buf.readUInt8(buf.length - 1);
+        const derbuf = buf.subarray(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);
+        return Signature.fromDER(derbuf, false);
+    }
+    static fromString(str) {
+        const buf = Buffer.from(str, 'hex');
+        return Signature.fromDER(buf);
+    }
+    static fromSchnorr(buf) {
+        const parsed = Signature.parseSchnorrEncodedSig(buf);
+        const sig = new Signature(parsed.r, parsed.s);
+        sig.isSchnorr = true;
+        if (parsed.nhashtype) {
+            sig.nhashtype = parsed.nhashtype.readUInt8(0);
+        }
+        return sig;
+    }
+    static parseSchnorrEncodedSig(buf) {
+        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);
+        let hashtype;
+        if (buf.length === 65) {
+            hashtype = buf.subarray(64, 65);
+        }
+        return {
+            r: new BN(r, 'be'),
+            s: new BN(s, 'be'),
+            nhashtype: hashtype,
+        };
+    }
+    static parseDER(buf, strict = true) {
+        if (!Buffer.isBuffer(buf)) {
+            throw new Error('DER formatted signature should be a buffer');
+        }
+        const header = buf[0];
+        if (header !== 0x30) {
+            throw new Error('Header byte should be 0x30');
+        }
+        let length = buf[1];
+        const buflength = buf.subarray(2).length;
+        if (strict && length !== buflength) {
+            throw new Error('Length byte should length of what follows');
+        }
+        length = length < buflength ? length : buflength;
+        const rheader = buf[2 + 0];
+        if (rheader !== 0x02) {
+            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 r = new BN(rbuf, 'be');
+        if (rlength !== rbuf.length) {
+            throw new Error('Length of r incorrect');
+        }
+        const sheader = buf[2 + 2 + rlength + 0];
+        if (sheader !== 0x02) {
+            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 s = new BN(sbuf, 'be');
+        if (slength !== sbuf.length) {
+            throw new Error('Length of s incorrect');
+        }
+        const sumlength = 2 + 2 + rlength + 2 + slength;
+        if (length !== sumlength - 2) {
+            throw new Error('Length of signature incorrect');
+        }
+        return { r, s };
+    }
+    toCompact(i, compressed) {
+        const recoveryId = typeof i === 'number' ? i : this.i;
+        const isCompressed = typeof compressed === 'boolean' ? compressed : this.compressed;
+        if (!(recoveryId === 0 ||
+            recoveryId === 1 ||
+            recoveryId === 2 ||
+            recoveryId === 3)) {
+            throw new Error('i must be equal to 0, 1, 2, or 3');
+        }
+        let val = recoveryId + 27 + 4;
+        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]);
+    }
+    toDER(signingMethod = 'ecdsa') {
+        if (signingMethod === 'schnorr') {
+            return Buffer.concat([
+                this.r.toArrayLike(Buffer, 'be', 32),
+                this.s.toArrayLike(Buffer, 'be', 32),
+            ]);
+        }
+        const rnbuf = this.r.toArrayLike(Buffer, 'be');
+        const snbuf = this.s.toArrayLike(Buffer, 'be');
+        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 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]),
+            rbuf,
+            Buffer.from([sheader, slength]),
+            sbuf,
+        ]);
+    }
+    toBuffer(signingMethod) {
+        const method = signingMethod || (this.isSchnorr ? 'schnorr' : 'ecdsa');
+        return this.toDER(method);
+    }
+    toString() {
+        const method = this.isSchnorr ? 'schnorr' : 'ecdsa';
+        const buf = this.toDER(method);
+        return buf.toString('hex');
+    }
+    toTxFormat(signingMethod) {
+        const derbuf = this.toDER(signingMethod);
+        const buf = Buffer.alloc(1);
+        buf.writeUInt8(this.nhashtype || 0, 0);
+        return Buffer.concat([derbuf, buf]);
+    }
+    static isDER(buf) {
+        if (buf.length < 8 || buf.length > 72) {
+            return false;
+        }
+        if (buf[0] !== 0x30) {
+            return false;
+        }
+        if (buf[1] !== buf.length - 2) {
+            return false;
+        }
+        if (buf[2] !== 0x02) {
+            return false;
+        }
+        const lenR = buf[3];
+        if (lenR === 0) {
+            return false;
+        }
+        if (buf[4] & 0x80) {
+            return false;
+        }
+        if (lenR > buf.length - 7) {
+            return false;
+        }
+        if (lenR > 1 && buf[4] === 0x00 && !(buf[5] & 0x80)) {
+            return false;
+        }
+        const startS = lenR + 4;
+        if (buf[startS] !== 0x02) {
+            return false;
+        }
+        const lenS = buf[startS + 1];
+        if (lenS === 0) {
+            return false;
+        }
+        if (buf[startS + 2] & 0x80) {
+            return false;
+        }
+        if (startS + lenS + 2 !== buf.length) {
+            return false;
+        }
+        if (lenS > 1 && buf[startS + 2] === 0x00 && !(buf[startS + 3] & 0x80)) {
+            return false;
+        }
+        return true;
+    }
+    hasLowS() {
+        const lowSThreshold = new BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 16);
+        if (this.s.lt(new BN(1)) || this.s.gt(lowSThreshold)) {
+            return false;
+        }
+        return true;
+    }
+    hasDefinedHashtype() {
+        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 mask = ~(Signature.SIGHASH_FORKID | Signature.SIGHASH_ANYONECANPAY) >>> 0;
+        const temp = this.nhashtype & mask;
+        if (temp < Signature.SIGHASH_ALL || temp > Signature.SIGHASH_SINGLE) {
+            return false;
+        }
+        return true;
+    }
+    static isTxDER(buf) {
+        return Signature.isDER(buf.subarray(0, buf.length - 1));
+    }
+}

package/dist/lib/bitcore/crypto/sigtype.d.ts

@@ -0,0 +1,5 @@
+export declare function isSchnorrSignature(sig: Buffer): boolean;
+export declare function isECDSASignature(sig: Buffer): boolean;
+export declare function getSignatureType(sig: Buffer): 'schnorr' | 'ecdsa';
+export declare function isValidSignatureLength(sig: Buffer): boolean;
+//# sourceMappingURL=sigtype.d.ts.map

package/dist/lib/bitcore/crypto/sigtype.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sigtype.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/sigtype.ts"],"names":[],"mappings":"AAoBA,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAEvD;AAWD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAErD;AAQD,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEjE;AAcD,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAc3D"}

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

@@ -0,0 +1,18 @@
+export function isSchnorrSignature(sig) {
+    return sig.length === 64;
+}
+export function isECDSASignature(sig) {
+    return sig.length !== 64;
+}
+export function getSignatureType(sig) {
+    return isSchnorrSignature(sig) ? 'schnorr' : 'ecdsa';
+}
+export function isValidSignatureLength(sig) {
+    if (sig.length === 64) {
+        return true;
+    }
+    if (sig.length >= 9 && sig.length <= 73) {
+        return true;
+    }
+    return false;
+}

package/dist/lib/bitcore/encoding/base58.d.ts

@@ -0,0 +1,16 @@
+export interface Base58Data {
+    buf?: Buffer;
+}
+export declare class Base58 {
+    buf?: Buffer;
+    constructor(obj?: Buffer | string | Base58Data);
+    static validCharacters(chars: string | Buffer): boolean;
+    set(obj: Base58Data): Base58;
+    static encode(buf: Buffer): string;
+    static decode(str: string): Buffer;
+    fromBuffer(buf: Buffer): Base58;
+    fromString(str: string): Base58;
+    toBuffer(): Buffer;
+    toString(): string;
+}
+//# sourceMappingURL=base58.d.ts.map

package/dist/lib/bitcore/encoding/base58.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/encoding/base58.ts"],"names":[],"mappings":"AAcA,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,MAAM,CAAA;CACb;AAED,qBAAa,MAAM;IACjB,GAAG,CAAC,EAAE,MAAM,CAAA;gBAEA,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU;IAY9C,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO;IAOvD,GAAG,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM;IAK5B,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOlC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOlC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAK/B,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAM/B,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;CAGnB"}

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

@@ -0,0 +1,55 @@
+import bs58 from 'bs58';
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'.split('');
+export class Base58 {
+    buf;
+    constructor(obj) {
+        if (Buffer.isBuffer(obj)) {
+            const buf = obj;
+            this.fromBuffer(buf);
+        }
+        else if (typeof obj === 'string') {
+            const str = obj;
+            this.fromString(str);
+        }
+        else if (obj) {
+            this.set(obj);
+        }
+    }
+    static validCharacters(chars) {
+        if (Buffer.isBuffer(chars)) {
+            chars = chars.toString();
+        }
+        return Array.from(chars).every(char => ALPHABET.includes(char));
+    }
+    set(obj) {
+        this.buf = obj.buf || this.buf || undefined;
+        return this;
+    }
+    static encode(buf) {
+        if (!Buffer.isBuffer(buf)) {
+            throw new Error('Input should be a buffer');
+        }
+        return bs58.encode(buf);
+    }
+    static decode(str) {
+        if (typeof str !== 'string') {
+            throw new Error('Input should be a string');
+        }
+        return Buffer.from(bs58.decode(str));
+    }
+    fromBuffer(buf) {
+        this.buf = buf;
+        return this;
+    }
+    fromString(str) {
+        const buf = Base58.decode(str);
+        this.buf = buf;
+        return this;
+    }
+    toBuffer() {
+        return this.buf;
+    }
+    toString() {
+        return Base58.encode(this.buf);
+    }
+}

package/dist/lib/bitcore/encoding/base58check.d.ts

@@ -0,0 +1,9 @@
+export declare class Base58Check {
+    static encode(buf: Buffer): string;
+    static decode(str: string): Buffer;
+    static checksum(data: Buffer): Buffer;
+    static validChecksum(data: Buffer, checksum: Buffer): boolean;
+    private static base58Encode;
+    private static base58Decode;
+}
+//# sourceMappingURL=base58check.d.ts.map

package/dist/lib/bitcore/encoding/base58check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base58check.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/encoding/base58check.ts"],"names":[],"mappings":"AAkBA,qBAAa,WAAW;IAItB,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAelC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAwBlC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IASrC,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAQ7D,OAAO,CAAC,MAAM,CAAC,YAAY;IA0B3B,OAAO,CAAC,MAAM,CAAC,YAAY;CAkC5B"}