xpi-ts 0.2.0

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

@@ -0,0 +1,238 @@
+import BN from 'bn.js';
+class BNWrapper {
+    _bn;
+    static Zero = new BNWrapper(0);
+    static One = new BNWrapper(1);
+    static Minus1 = new BNWrapper(-1);
+    constructor(n, base) {
+        if (n instanceof BN) {
+            this._bn = n.clone();
+        }
+        else if (Buffer.isBuffer(n)) {
+            if (base === 'le' || base === 'be') {
+                this._bn = new BN(n, undefined, base);
+            }
+            else {
+                this._bn = new BN(n, base || 'hex');
+            }
+        }
+        else {
+            const validBase = base === 'hex' || typeof base === 'number' ? base : undefined;
+            this._bn = new BN(n, validBase);
+        }
+    }
+    static fromString(str, base) {
+        return new BNWrapper(str, base);
+    }
+    static fromBuffer(buf, opts) {
+        let buffer = buf;
+        if (opts?.size) {
+            buffer = Buffer.alloc(opts.size);
+            buf.copy(buffer, opts.size - buf.length);
+        }
+        if (opts?.endian === 'little') {
+            buffer = BNWrapper.reversebuf(buffer);
+        }
+        return new BNWrapper(buffer, 'hex');
+    }
+    static fromSM(buf, opts) {
+        if (buf.length === 0) {
+            return BNWrapper.fromBuffer(Buffer.from([0]));
+        }
+        let endian = 'big';
+        if (opts) {
+            endian = opts.endian || 'big';
+        }
+        let buffer = buf;
+        if (endian === 'little') {
+            buffer = BNWrapper.reversebuf(buf);
+        }
+        let result;
+        if (buffer[0] & 0x80) {
+            buffer[0] = buffer[0] & 0x7f;
+            result = BNWrapper.fromBuffer(buffer);
+            result = result.neg();
+        }
+        else {
+            result = BNWrapper.fromBuffer(buffer);
+        }
+        return result;
+    }
+    static fromScriptNumBuffer(buf, fRequireMinimal, size) {
+        const nMaxNumSize = size || 4;
+        if (buf.length > nMaxNumSize) {
+            throw new Error('script number overflow');
+        }
+        if (fRequireMinimal && buf.length > 0) {
+            if ((buf[buf.length - 1] & 0x7f) === 0) {
+                if (buf.length <= 1 || (buf[buf.length - 2] & 0x80) === 0) {
+                    throw new Error('non-minimally encoded script number');
+                }
+            }
+        }
+        return BNWrapper.fromSM(buf, { endian: 'little' });
+    }
+    static reversebuf(buf) {
+        const buf2 = Buffer.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);
+    }
+    static pad(buf, natlen, size) {
+        const rbuf = Buffer.alloc(size);
+        for (let i = 0; i < buf.length; i++) {
+            rbuf[rbuf.length - 1 - i] = buf[buf.length - 1 - i];
+        }
+        for (let i = 0; i < size - natlen; i++) {
+            rbuf[i] = 0;
+        }
+        return rbuf;
+    }
+    static fromNumber(n) {
+        return new BNWrapper(n);
+    }
+    toNumber() {
+        return parseInt(this.toString(10), 10);
+    }
+    add(r) {
+        return new BNWrapper(this._bn.add(r._bn));
+    }
+    mod(r) {
+        return new BNWrapper(this._bn.mod(r._bn));
+    }
+    umod(r) {
+        return new BNWrapper(this._bn.umod(r._bn));
+    }
+    get bn() {
+        return this._bn;
+    }
+    toString(base) {
+        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);
+            }
+            else if (buf.length < opts.size) {
+                const padded = Buffer.alloc(opts.size);
+                buf.copy(padded, opts.size - buf.length);
+                buf = padded;
+            }
+        }
+        else {
+            buf = this._bn.toArrayLike(Buffer, opts?.endian === 'little' ? 'le' : 'be');
+        }
+        return buf;
+    }
+    toArrayLike(ArrayType, endian, length) {
+        return this._bn.toArrayLike(ArrayType, endian || 'be', length);
+    }
+    mul(r) {
+        return new BNWrapper(this._bn.mul(r._bn));
+    }
+    sub(r) {
+        return new BNWrapper(this._bn.sub(r._bn));
+    }
+    pow(r) {
+        return new BNWrapper(this._bn.pow(r._bn));
+    }
+    div(r) {
+        return new BNWrapper(this._bn.div(r._bn));
+    }
+    modPow(exponent, modulus) {
+        const red = BN.red(modulus._bn);
+        const base = this._bn.toRed(red);
+        const result = base.redPow(exponent._bn);
+        return new BNWrapper(result.fromRed());
+    }
+    and(other) {
+        const otherBN = other instanceof BNWrapper ? other._bn : new BN(other);
+        return new BNWrapper(this._bn.and(otherBN));
+    }
+    neg() {
+        return new BNWrapper(this._bn.neg());
+    }
+    invm(r) {
+        return new BNWrapper(this._bn.invm(r._bn));
+    }
+    eq(other) {
+        return this._bn.eq(other._bn);
+    }
+    lt(other) {
+        return this._bn.lt(other._bn);
+    }
+    gt(other) {
+        return this._bn.gt(other._bn);
+    }
+    lte(other) {
+        return this._bn.lte(other._bn);
+    }
+    gte(other) {
+        return this._bn.gte(other._bn);
+    }
+    isZero() {
+        return this._bn.isZero();
+    }
+    isNeg() {
+        return this._bn.isNeg();
+    }
+    isOdd() {
+        return this._bn.isOdd();
+    }
+    isEven() {
+        return this._bn.isEven();
+    }
+    toSMBigEndian() {
+        let buf;
+        if (this.cmp(BNWrapper.Zero) === -1) {
+            buf = this.neg().toBuffer();
+            if (buf[0] & 0x80) {
+                buf = Buffer.concat([Buffer.from([0x80]), buf]);
+            }
+            else {
+                buf[0] = buf[0] | 0x80;
+            }
+        }
+        else {
+            buf = this.toBuffer();
+            if (buf[0] & 0x80) {
+                buf = Buffer.concat([Buffer.from([0x00]), buf]);
+            }
+        }
+        if (buf.length === 1 && buf[0] === 0) {
+            buf = Buffer.from([]);
+        }
+        return buf;
+    }
+    toSM(opts) {
+        const endian = opts ? opts.endian : 'big';
+        let buf = this.toSMBigEndian();
+        if (endian === 'little') {
+            buf = BNWrapper.reversebuf(buf);
+        }
+        return buf;
+    }
+    toScriptNumBuffer() {
+        return this.toSM({ endian: 'little' });
+    }
+    cmp(other) {
+        return this._bn.cmp(other._bn);
+    }
+    copy(other) {
+        this._bn = other._bn.clone();
+        return this;
+    }
+    clone() {
+        return new BNWrapper(this._bn.clone());
+    }
+}
+export { BNWrapper as BN };

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

@@ -0,0 +1,46 @@
+import { BN } from './bn.js';
+import { Signature } from './signature.js';
+import { PrivateKey } from '../privatekey.js';
+import { PublicKey } from '../publickey.js';
+export interface ECDSAData {
+    hashbuf?: Buffer;
+    endian?: 'little' | 'big';
+    privkey?: PrivateKey;
+    pubkey?: PublicKey;
+    sig?: Signature;
+    k?: BN;
+    verified?: boolean;
+}
+export declare class ECDSA {
+    hashbuf: Buffer;
+    endian?: 'little' | 'big';
+    privkey: PrivateKey;
+    pubkey: PublicKey;
+    sig: Signature;
+    k: BN;
+    verified: boolean;
+    constructor(obj?: ECDSAData);
+    static create(obj?: ECDSAData): ECDSA;
+    set(obj: ECDSAData): ECDSA;
+    privkey2pubkey(): ECDSA;
+    calci(): ECDSA;
+    static fromString(str: string): ECDSA;
+    randomK(): ECDSA;
+    deterministicK(badrs?: number): ECDSA;
+    toPublicKey(): PublicKey;
+    sigError(): string | false;
+    static toLowS(s: BN): BN;
+    _findSignature(d: BN, e: BN): {
+        s: BN;
+        r: BN;
+        compressed?: boolean;
+    };
+    sign(): ECDSA;
+    signRandomK(): ECDSA;
+    toString(): string;
+    verify(): ECDSA;
+    static sign(hashbuf: Buffer, privkey: PrivateKey, endian?: 'little' | 'big'): Signature;
+    static verify(hashbuf: Buffer, sig: Signature, pubkey: PublicKey, endian?: 'little' | 'big'): boolean;
+    private reverseBuffer;
+}
+//# sourceMappingURL=ecdsa.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/ecdsa.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAG1C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,MAAM,WAAW,SAAS;IACxB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAA;IACzB,OAAO,CAAC,EAAE,UAAU,CAAA;IACpB,MAAM,CAAC,EAAE,SAAS,CAAA;IAClB,GAAG,CAAC,EAAE,SAAS,CAAA;IACf,CAAC,CAAC,EAAE,EAAE,CAAA;IACN,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,qBAAa,KAAK;IAChB,OAAO,EAAG,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAA;IACzB,OAAO,EAAG,UAAU,CAAA;IACpB,MAAM,EAAG,SAAS,CAAA;IAClB,GAAG,EAAG,SAAS,CAAA;IACf,CAAC,EAAG,EAAE,CAAA;IACN,QAAQ,EAAG,OAAO,CAAA;gBAEN,GAAG,CAAC,EAAE,SAAS;IAO3B,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,SAAS,GAAG,KAAK;IAIrC,GAAG,CAAC,GAAG,EAAE,SAAS,GAAG,KAAK;IAe1B,cAAc,IAAI,KAAK;IAQvB,KAAK,IAAI,KAAK;IAwBd,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK;IAQrC,OAAO,IAAI,KAAK;IAahB,cAAc,CAAC,KAAK,GAAE,MAAU,GAAG,KAAK;IA4CxC,WAAW,IAAI,SAAS;IAoCxB,QAAQ,IAAI,MAAM,GAAG,KAAK;IA2C1B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,GAAG,EAAE;IAexB,cAAc,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,GAAG;QAAE,CAAC,EAAE,EAAE,CAAC;QAAC,CAAC,EAAE,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAE;IA2BpE,IAAI,IAAI,KAAK;IAuBb,WAAW,IAAI,KAAK;IAQpB,QAAQ,IAAI,MAAM;IAuBlB,MAAM,IAAI,KAAK;IAYf,MAAM,CAAC,IAAI,CACT,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,UAAU,EACnB,MAAM,CAAC,EAAE,QAAQ,GAAG,KAAK,GACxB,SAAS;IAaZ,MAAM,CAAC,MAAM,CACX,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,SAAS,EACd,MAAM,EAAE,SAAS,EACjB,MAAM,CAAC,EAAE,QAAQ,GAAG,KAAK,GACxB,OAAO;IAcV,OAAO,CAAC,aAAa;CAOtB"}

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

@@ -0,0 +1,247 @@
+import { BN } from './bn.js';
+import { Point } from './point.js';
+import { Signature } from './signature.js';
+import { Hash } from './hash.js';
+import { Random } from './random.js';
+import { PublicKey } from '../publickey.js';
+export class ECDSA {
+    hashbuf;
+    endian;
+    privkey;
+    pubkey;
+    sig;
+    k;
+    verified;
+    constructor(obj) {
+        if (obj) {
+            this.set(obj);
+        }
+    }
+    static create(obj) {
+        return new ECDSA(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.k = obj.k || this.k;
+        this.verified = obj.verified || this.verified;
+        return this;
+    }
+    privkey2pubkey() {
+        this.pubkey = this.privkey.toPublicKey();
+        return this;
+    }
+    calci() {
+        for (let i = 0; i < 4; i++) {
+            this.sig.i = i;
+            let Qprime;
+            try {
+                Qprime = this.toPublicKey();
+            }
+            catch (e) {
+                console.error(e);
+                continue;
+            }
+            if (Qprime.point.eq(this.pubkey.point)) {
+                this.sig.compressed = this.pubkey.compressed;
+                return this;
+            }
+        }
+        this.sig.i = undefined;
+        throw new Error('Unable to find valid recovery factor');
+    }
+    static fromString(str) {
+        const obj = JSON.parse(str);
+        return new ECDSA(obj);
+    }
+    randomK() {
+        const N = Point.getN();
+        let k;
+        do {
+            k = new BN(Random.getPseudoRandomBuffer(32), 'be');
+        } while (!(k.lt(N) && k.gt(new BN(0))));
+        this.k = k;
+        return this;
+    }
+    deterministicK(badrs = 0) {
+        let v = Buffer.alloc(32);
+        v.fill(0x01);
+        let k = Buffer.alloc(32);
+        k.fill(0x00);
+        const x = this.privkey.toBuffer();
+        const hashbuf = this.endian === 'little'
+            ? this.reverseBuffer(this.hashbuf)
+            : this.hashbuf;
+        k = Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x00]), x, hashbuf]), k);
+        v = Hash.sha256hmac(v, k);
+        k = Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x01]), x, hashbuf]), k);
+        v = Hash.sha256hmac(v, k);
+        v = Hash.sha256hmac(v, k);
+        let T = new BN(v, 'be');
+        const N = Point.getN();
+        for (let i = 0; i < badrs || !(T.lt(N) && T.gt(new BN(0))); i++) {
+            k = Hash.sha256hmac(Buffer.concat([v, Buffer.from([0x00])]), k);
+            v = Hash.sha256hmac(v, k);
+            v = Hash.sha256hmac(v, k);
+            T = new BN(v, 'be');
+        }
+        this.k = T;
+        return this;
+    }
+    toPublicKey() {
+        const i = this.sig.i;
+        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(this.hashbuf, 'be');
+        const r = this.sig.r;
+        const s = this.sig.s;
+        const isYOdd = (i & 1) !== 0;
+        const isSecondKey = i >> 1 !== 0;
+        const n = Point.getN();
+        const G = Point.getG();
+        const x = isSecondKey ? r.add(n) : r;
+        const R = 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 rInv = r.invm(n);
+        const Q = R.mul(s).add(G.mul(eNeg)).mul(rInv);
+        const pubkey = PublicKey.fromPoint(Q, this.sig.compressed);
+        return pubkey;
+    }
+    sigError() {
+        if (!Buffer.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.getN();
+        if (!(r.gt(new BN(0)) && r.lt(N)) || !(s.gt(new BN(0)) && s.lt(N))) {
+            return 'r and s not in range';
+        }
+        const e = new BN(this.hashbuf, this.endian === 'little' ? 'le' : 'be');
+        const n = Point.getN();
+        const sinv = s.invm(n);
+        const u1 = sinv.mul(e).mod(n);
+        const u2 = sinv.mul(r).mod(n);
+        const p = Point.getG().mulAdd(u1, this.pubkey.point, u2);
+        if (p.isInfinity()) {
+            return 'p is infinity';
+        }
+        if (p.getX().mod(n).cmp(r) !== 0) {
+            return 'Invalid signature';
+        }
+        else {
+            return false;
+        }
+    }
+    static toLowS(s) {
+        const lowSThreshold = new BN('7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0', 16);
+        if (s.gt(lowSThreshold)) {
+            s = Point.getN().sub(s);
+        }
+        return s;
+    }
+    _findSignature(d, e) {
+        const N = Point.getN();
+        const G = Point.getG();
+        let badrs = 0;
+        let k, Q, r, s;
+        do {
+            if (!this.k || badrs > 0) {
+                this.deterministicK(badrs);
+            }
+            badrs++;
+            k = this.k;
+            Q = G.mul(k);
+            r = Q.getX().mod(N);
+            s = k
+                .invm(N)
+                .mul(e.add(d.mul(r)))
+                .mod(N);
+        } while (r.cmp(new BN(0)) <= 0 || s.cmp(new BN(0)) <= 0);
+        s = ECDSA.toLowS(s);
+        return { s, r, compressed: this.pubkey.compressed };
+    }
+    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, this.endian === 'little' ? 'le' : 'be');
+        const obj = this._findSignature(d, e);
+        obj.compressed = this.pubkey.compressed;
+        this.sig = new Signature(obj);
+        return this;
+    }
+    signRandomK() {
+        this.randomK();
+        return this.sign();
+    }
+    toString() {
+        const obj = {};
+        if (this.hashbuf) {
+            obj.hashbuf = this.hashbuf.toString('hex');
+        }
+        if (this.privkey) {
+            obj.privkey = this.privkey.toString();
+        }
+        if (this.pubkey) {
+            obj.pubkey = this.pubkey.toString();
+        }
+        if (this.sig) {
+            obj.sig = this.sig.toString();
+        }
+        if (this.k) {
+            obj.k = this.k.toString();
+        }
+        return JSON.stringify(obj);
+    }
+    verify() {
+        if (!this.sigError()) {
+            this.verified = true;
+        }
+        else {
+            this.verified = false;
+        }
+        return this;
+    }
+    static sign(hashbuf, privkey, endian) {
+        return ECDSA.create()
+            .set({
+            hashbuf: hashbuf,
+            endian: endian,
+            privkey: privkey,
+        })
+            .sign().sig;
+    }
+    static verify(hashbuf, sig, pubkey, endian) {
+        return ECDSA.create()
+            .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/hash.d.ts

@@ -0,0 +1,16 @@
+export interface HashFunction {
+    (buf: Buffer): Buffer;
+    blocksize: number;
+}
+export declare class Hash {
+    static sha1: HashFunction;
+    static sha256: HashFunction;
+    static sha512: HashFunction;
+    static sha256sha256: (buf: Buffer) => Buffer;
+    static ripemd160: (buf: Buffer) => Buffer;
+    static sha256ripemd160: (buf: Buffer) => Buffer;
+    static hmac(hashf: HashFunction, data: Buffer, key: Buffer): Buffer;
+    static sha256hmac(data: Buffer, key: Buffer): Buffer;
+    static sha512hmac(data: Buffer, key: Buffer): Buffer;
+}
+//# sourceMappingURL=hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/hash.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,YAAY;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;CAClB;AA2BD,qBAAa,IAAI;IACf,MAAM,CAAC,IAAI,eAAW;IACtB,MAAM,CAAC,MAAM,eAAa;IAC1B,MAAM,CAAC,MAAM,eAAa;IAE1B,MAAM,CAAC,YAAY,GAAa,KAAK,MAAM,KAAG,MAAM,CAKnD;IAED,MAAM,CAAC,SAAS,GAAa,KAAK,MAAM,KAAG,MAAM,CAKhD;IAED,MAAM,CAAC,eAAe,GAAa,KAAK,MAAM,KAAG,MAAM,CAKtD;IAOD,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IA0CnE,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAIpD,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;CAGrD"}

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

@@ -0,0 +1,87 @@
+import { sha1 } from '@noble/hashes/sha1';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import { ripemd160 } from '@noble/hashes/ripemd160';
+const sha1Func = (buf) => {
+    if (!Buffer.isBuffer(buf)) {
+        throw new Error('Argument must be a Buffer');
+    }
+    return Buffer.from(sha1(buf));
+};
+sha1Func.blocksize = 512;
+const sha256Func = (buf) => {
+    if (!Buffer.isBuffer(buf)) {
+        throw new Error('Argument must be a Buffer');
+    }
+    return Buffer.from(sha256(buf));
+};
+sha256Func.blocksize = 512;
+const sha512Func = (buf) => {
+    if (!Buffer.isBuffer(buf)) {
+        throw new Error('Argument must be a Buffer');
+    }
+    return Buffer.from(sha512(buf));
+};
+sha512Func.blocksize = 1024;
+export class Hash {
+    static sha1 = sha1Func;
+    static sha256 = sha256Func;
+    static sha512 = sha512Func;
+    static sha256sha256 = function (buf) {
+        if (!Buffer.isBuffer(buf)) {
+            throw new Error('Argument must be a Buffer');
+        }
+        return Hash.sha256(Hash.sha256(buf));
+    };
+    static ripemd160 = function (buf) {
+        if (!Buffer.isBuffer(buf)) {
+            throw new Error('Argument must be a Buffer');
+        }
+        return Buffer.from(ripemd160(buf));
+    };
+    static sha256ripemd160 = function (buf) {
+        if (!Buffer.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)) {
+            throw new Error('Data must be a Buffer');
+        }
+        if (!Buffer.isBuffer(key)) {
+            throw new Error('Key must be a Buffer');
+        }
+        if (!hashf.blocksize) {
+            throw new Error('Hash function must have blocksize property');
+        }
+        const blocksize = hashf.blocksize / 8;
+        let processedKey = key;
+        if (key.length > blocksize) {
+            processedKey = hashf(key);
+        }
+        else if (key.length < blocksize) {
+            const fill = Buffer.alloc(blocksize);
+            fill.fill(0);
+            key.copy(fill);
+            processedKey = fill;
+        }
+        const o_key = Buffer.alloc(blocksize);
+        o_key.fill(0x5c);
+        const i_key = Buffer.alloc(blocksize);
+        i_key.fill(0x36);
+        const o_key_pad = Buffer.alloc(blocksize);
+        const i_key_pad = Buffer.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]))]));
+    }
+    static sha256hmac(data, key) {
+        return Hash.hmac(Hash.sha256, data, key);
+    }
+    static sha512hmac(data, key) {
+        return Hash.hmac(Hash.sha512, data, key);
+    }
+}

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

@@ -0,0 +1,9 @@
+export { Hash } from './hash.js';
+export { Random } from './random.js';
+export { Point } from './point.js';
+export { Signature } from './signature.js';
+export { ECDSA } from './ecdsa.js';
+export { Schnorr } from './schnorr.js';
+export { BN } from './bn.js';
+export { isSchnorrSignature, isECDSASignature, getSignatureType, isValidSignatureLength, } from './sigtype.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAC5B,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,cAAc,CAAA"}

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

@@ -0,0 +1,8 @@
+export { Hash } from './hash.js';
+export { Random } from './random.js';
+export { Point } from './point.js';
+export { Signature } from './signature.js';
+export { ECDSA } from './ecdsa.js';
+export { Schnorr } from './schnorr.js';
+export { BN } from './bn.js';
+export { isSchnorrSignature, isECDSASignature, getSignatureType, isValidSignatureLength, } from './sigtype.js';