xpi-ts 0.2.0

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

@@ -0,0 +1,40 @@
+import { PublicKey } from '../publickey.js';
+import { PrivateKey } from '../privatekey.js';
+import { Point } from './point.js';
+import { BN } from './bn.js';
+import { Signature } from './signature.js';
+export interface MuSigKeyAggContext {
+    pubkeys: PublicKey[];
+    keyAggCoeff: Map<number, BN>;
+    aggregatedPubKey: PublicKey;
+}
+export interface MuSigNonce {
+    secretNonces: [BN, BN];
+    publicNonces: [Point, Point];
+}
+export interface MuSigAggregatedNonce {
+    R1: Point;
+    R2: Point;
+}
+export declare const MUSIG_TAG_KEYSORT = "KeyAgg list";
+export declare const MUSIG_TAG_KEYAGG_COEFF = "KeyAgg coefficient";
+export declare const MUSIG_TAG_NONCE_COEFF = "MuSig/noncecoef";
+export declare const MUSIG_TAG_NONCE = "MuSig/nonce";
+export declare function musigTaggedHash(tag: string, data: Buffer): Buffer;
+export declare function musigKeyAgg(pubkeys: PublicKey[]): MuSigKeyAggContext;
+export declare function musigNonceGen(privateKey: PrivateKey, aggregatedPubKey: PublicKey, message?: Buffer, extraInput?: Buffer): MuSigNonce;
+export declare function musigNonceAgg(publicNonces: Array<[Point, Point]>): MuSigAggregatedNonce;
+export declare function musigPartialSign(secretNonce: MuSigNonce, privateKey: PrivateKey, keyAggContext: MuSigKeyAggContext, signerIndex: number, aggregatedNonce: MuSigAggregatedNonce, message: Buffer): BN;
+export declare function musigPartialSigVerify(partialSig: BN, publicNonce: [Point, Point], publicKey: PublicKey, keyAggContext: MuSigKeyAggContext, signerIndex: number, aggregatedNonce: MuSigAggregatedNonce, message: Buffer): boolean;
+export declare function musigSigAgg(partialSigs: BN[], aggregatedNonce: MuSigAggregatedNonce, message: Buffer, aggregatedPubKey: PublicKey, sighashType?: number): Signature;
+declare const _default: {
+    musigKeyAgg: typeof musigKeyAgg;
+    musigNonceGen: typeof musigNonceGen;
+    musigNonceAgg: typeof musigNonceAgg;
+    musigPartialSign: typeof musigPartialSign;
+    musigPartialSigVerify: typeof musigPartialSigVerify;
+    musigSigAgg: typeof musigSigAgg;
+    musigTaggedHash: typeof musigTaggedHash;
+};
+export default _default;
+//# sourceMappingURL=musig2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"musig2.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/musig2.ts"],"names":[],"mappings":"AAiCA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAClC,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAY1C,MAAM,WAAW,kBAAkB;IAEjC,OAAO,EAAE,SAAS,EAAE,CAAA;IAGpB,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;IAG5B,gBAAgB,EAAE,SAAS,CAAA;CAC5B;AAOD,MAAM,WAAW,UAAU;IAEzB,YAAY,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAA;IAGtB,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;CAC7B;AAOD,MAAM,WAAW,oBAAoB;IAEnC,EAAE,EAAE,KAAK,CAAA;IAGT,EAAE,EAAE,KAAK,CAAA;CACV;AAOD,eAAO,MAAM,iBAAiB,gBAAgB,CAAA;AAG9C,eAAO,MAAM,sBAAsB,uBAAuB,CAAA;AAG1D,eAAO,MAAM,qBAAqB,oBAAoB,CAAA;AAMtD,eAAO,MAAM,eAAe,gBAAgB,CAAA;AAiB5C,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIjE;AAmFD,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,EAAE,GAAG,kBAAkB,CAsEpE;AA2DD,wBAAgB,aAAa,CAC3B,UAAU,EAAE,UAAU,EACtB,gBAAgB,EAAE,SAAS,EAC3B,OAAO,CAAC,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,UAAU,CAwDZ;AA4BD,wBAAgB,aAAa,CAC3B,YAAY,EAAE,KAAK,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,GAClC,oBAAoB,CAkCtB;AAyCD,wBAAgB,gBAAgB,CAC9B,WAAW,EAAE,UAAU,EACvB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,kBAAkB,EACjC,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,oBAAoB,EACrC,OAAO,EAAE,MAAM,GACd,EAAE,CA4CJ;AAqCD,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,EAAE,EACd,WAAW,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAC3B,SAAS,EAAE,SAAS,EACpB,aAAa,EAAE,kBAAkB,EACjC,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,oBAAoB,EACrC,OAAO,EAAE,MAAM,GACd,OAAO,CA4DT;AA4CD,wBAAgB,WAAW,CACzB,WAAW,EAAE,EAAE,EAAE,EACjB,eAAe,EAAE,oBAAoB,EACrC,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,SAAS,EAC3B,WAAW,CAAC,EAAE,MAAM,GACnB,SAAS,CAqDX;;;;;;;;;;AAuBD,wBAQC"}

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

@@ -0,0 +1,236 @@
+import { PublicKey } from '../publickey.js';
+import { Point } from './point.js';
+import { BN } from './bn.js';
+import { Hash } from './hash.js';
+import { Signature } from './signature.js';
+export const MUSIG_TAG_KEYSORT = 'KeyAgg list';
+export const MUSIG_TAG_KEYAGG_COEFF = 'KeyAgg coefficient';
+export const MUSIG_TAG_NONCE_COEFF = 'MuSig/noncecoef';
+const MUSIG_TAG_AUX = 'MuSig/aux';
+export const MUSIG_TAG_NONCE = 'MuSig/nonce';
+export function musigTaggedHash(tag, data) {
+    const tagHash = Hash.sha256(Buffer.from(tag, 'utf8'));
+    const combined = Buffer.concat([tagHash, tagHash, data]);
+    return Hash.sha256(combined);
+}
+function hashKeys(pubkeys) {
+    const data = Buffer.concat(pubkeys.map(pk => pk.toBuffer()));
+    return musigTaggedHash(MUSIG_TAG_KEYSORT, data);
+}
+function keyAggCoeff(L, pubkey, isSecondKey, equalsFirstKey) {
+    if (isSecondKey && equalsFirstKey) {
+        return new BN(1);
+    }
+    const data = Buffer.concat([L, pubkey.toBuffer()]);
+    const hash = musigTaggedHash(MUSIG_TAG_KEYAGG_COEFF, data);
+    return new BN(hash, 'be');
+}
+export function musigKeyAgg(pubkeys) {
+    if (pubkeys.length === 0) {
+        throw new Error('Cannot aggregate zero public keys');
+    }
+    for (const pk of pubkeys) {
+        if (!pk || !pk.point) {
+            throw new Error('Invalid public key');
+        }
+    }
+    const sortedPubkeys = [...pubkeys].sort((a, b) => {
+        const bufA = a.toBuffer();
+        const bufB = b.toBuffer();
+        return bufA.compare(bufB);
+    });
+    const L = hashKeys(sortedPubkeys);
+    const keyAggCoeffMap = new Map();
+    const firstKey = sortedPubkeys[0];
+    for (let i = 0; i < sortedPubkeys.length; i++) {
+        const isSecond = i === 1;
+        const equalsFirst = sortedPubkeys[i].toString() === firstKey.toString();
+        const coeff = keyAggCoeff(L, sortedPubkeys[i], isSecond, equalsFirst);
+        keyAggCoeffMap.set(i, coeff);
+    }
+    let Q = null;
+    const n = Point.getN();
+    for (let i = 0; i < sortedPubkeys.length; i++) {
+        const coeff = keyAggCoeffMap.get(i);
+        const pk = sortedPubkeys[i];
+        const term = pk.point.mul(coeff.umod(n));
+        if (Q === null) {
+            Q = term;
+        }
+        else {
+            Q = Q.add(term);
+        }
+    }
+    if (!Q) {
+        throw new Error('Key aggregation failed: result is null');
+    }
+    Q.validate();
+    const aggregatedPubKey = new PublicKey(Q, {
+        compressed: true,
+        network: sortedPubkeys[0].network,
+    });
+    return {
+        pubkeys: sortedPubkeys,
+        keyAggCoeff: keyAggCoeffMap,
+        aggregatedPubKey,
+    };
+}
+export function musigNonceGen(privateKey, aggregatedPubKey, message, extraInput) {
+    const G = Point.getG();
+    const n = Point.getN();
+    const sessionData = Buffer.concat([
+        privateKey.bn.toArrayLike(Buffer, 'be', 32),
+        aggregatedPubKey.toBuffer(),
+        message || Buffer.alloc(32),
+        extraInput || Buffer.alloc(32),
+    ]);
+    const auxHash = musigTaggedHash(MUSIG_TAG_AUX, sessionData);
+    const rand1 = musigTaggedHash(MUSIG_TAG_NONCE, Buffer.concat([auxHash, Buffer.from([0x01])]));
+    const rand2 = musigTaggedHash(MUSIG_TAG_NONCE, Buffer.concat([auxHash, Buffer.from([0x02])]));
+    let k1 = new BN(rand1, 'be').umod(n);
+    let k2 = new BN(rand2, 'be').umod(n);
+    if (k1.isZero()) {
+        k1 = new BN(1);
+    }
+    if (k2.isZero()) {
+        k2 = new BN(1);
+    }
+    const R1 = G.mul(k1);
+    const R2 = G.mul(k2);
+    R1.validate();
+    R2.validate();
+    return {
+        secretNonces: [k1, k2],
+        publicNonces: [R1, R2],
+    };
+}
+export function musigNonceAgg(publicNonces) {
+    if (publicNonces.length === 0) {
+        throw new Error('Cannot aggregate zero nonces');
+    }
+    for (const [R1, R2] of publicNonces) {
+        if (!R1 || !R2) {
+            throw new Error('Invalid public nonce');
+        }
+        R1.validate();
+        R2.validate();
+    }
+    let R1_agg = publicNonces[0][0];
+    for (let i = 1; i < publicNonces.length; i++) {
+        R1_agg = R1_agg.add(publicNonces[i][0]);
+    }
+    let R2_agg = publicNonces[0][1];
+    for (let i = 1; i < publicNonces.length; i++) {
+        R2_agg = R2_agg.add(publicNonces[i][1]);
+    }
+    R1_agg.validate();
+    R2_agg.validate();
+    return {
+        R1: R1_agg,
+        R2: R2_agg,
+    };
+}
+export function musigPartialSign(secretNonce, privateKey, keyAggContext, signerIndex, aggregatedNonce, message) {
+    const n = Point.getN();
+    const [k1, k2] = secretNonce.secretNonces;
+    const { R1, R2 } = aggregatedNonce;
+    const Q = keyAggContext.aggregatedPubKey;
+    const nonceCoefData = Buffer.concat([
+        Q.toBuffer(),
+        Point.pointToCompressed(R1),
+        Point.pointToCompressed(R2),
+        message,
+    ]);
+    const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+    let k = k1.add(b.mul(k2)).umod(n);
+    const R = R1.add(R2.mul(b));
+    if (!R.hasSquare()) {
+        k = n.sub(k).umod(n);
+    }
+    const R_x = R.getX().toArrayLike(Buffer, 'be', 32);
+    const Q_compressed = Point.pointToCompressed(Q.point);
+    const challengeData = Buffer.concat([R_x, Q_compressed, message]);
+    const e = new BN(Hash.sha256(challengeData), 'be').umod(n);
+    const a = keyAggContext.keyAggCoeff.get(signerIndex);
+    if (!a) {
+        throw new Error(`Invalid signer index: ${signerIndex}`);
+    }
+    const x = privateKey.bn;
+    const s = k.add(e.mul(a).mul(x)).umod(n);
+    return s;
+}
+export function musigPartialSigVerify(partialSig, publicNonce, publicKey, keyAggContext, signerIndex, aggregatedNonce, message) {
+    try {
+        const G = Point.getG();
+        const n = Point.getN();
+        const [R1_i, R2_i] = publicNonce;
+        const { R1, R2 } = aggregatedNonce;
+        const Q = keyAggContext.aggregatedPubKey;
+        const nonceCoefData = Buffer.concat([
+            Q.toBuffer(),
+            Point.pointToCompressed(R1),
+            Point.pointToCompressed(R2),
+            message,
+        ]);
+        const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+        const R_i = R1_i.add(R2_i.mul(b));
+        const R = R1.add(R2.mul(b));
+        const negated = !R.hasSquare();
+        const R_x = R.getX().toArrayLike(Buffer, 'be', 32);
+        const Q_compressed = Point.pointToCompressed(Q.point);
+        const challengeData = Buffer.concat([R_x, Q_compressed, message]);
+        const e = new BN(Hash.sha256(challengeData), 'be').umod(n);
+        const a = keyAggContext.keyAggCoeff.get(signerIndex);
+        if (!a) {
+            throw new Error(`Invalid signer index: ${signerIndex}`);
+        }
+        const lhs = G.mul(partialSig.umod(n));
+        const eaP = publicKey.point.mul(e.mul(a).umod(n));
+        const R_i_adjusted = negated ? R_i.mul(n.sub(new BN(1))) : R_i;
+        const rhs = R_i_adjusted.add(eaP);
+        return lhs.eq(rhs);
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function musigSigAgg(partialSigs, aggregatedNonce, message, aggregatedPubKey, sighashType) {
+    if (partialSigs.length === 0) {
+        throw new Error('Cannot aggregate zero partial signatures');
+    }
+    const n = Point.getN();
+    const { R1, R2 } = aggregatedNonce;
+    const nonceCoefData = Buffer.concat([
+        aggregatedPubKey.toBuffer(),
+        Point.pointToCompressed(R1),
+        Point.pointToCompressed(R2),
+        message,
+    ]);
+    const b = new BN(musigTaggedHash(MUSIG_TAG_NONCE_COEFF, nonceCoefData), 'be');
+    const R = R1.add(R2.mul(b));
+    let s = new BN(0);
+    for (const partialSig of partialSigs) {
+        s = s.add(partialSig).umod(n);
+    }
+    if (s.isZero()) {
+        throw new Error('Aggregated signature s is zero (invalid)');
+    }
+    const r = R.getX();
+    const signature = new Signature({
+        r: r,
+        s: s,
+        compressed: true,
+        isSchnorr: true,
+        nhashtype: sighashType,
+    });
+    return signature;
+}
+export default {
+    musigKeyAgg,
+    musigNonceGen,
+    musigNonceAgg,
+    musigPartialSign,
+    musigPartialSigVerify,
+    musigSigAgg,
+    musigTaggedHash,
+};

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

@@ -0,0 +1,20 @@
+import { BN } from './bn.js';
+export declare class Point {
+    private _point;
+    constructor(x: BN | string, y: BN | string, isRed?: boolean);
+    static fromX(odd: boolean, x: BN | string): Point;
+    static getG(): Point;
+    static getN(): BN;
+    getX(): BN;
+    getY(): BN;
+    validate(): Point;
+    isInfinity(): boolean;
+    add(other: Point): Point;
+    mul(scalar: BN): Point;
+    mulAdd(scalar1: BN, other: Point, scalar2: BN): Point;
+    eq(other: Point): boolean;
+    static pointToCompressed(point: Point): Buffer;
+    hasSquare(): boolean;
+    isSquare(x: BN): boolean;
+}
+//# sourceMappingURL=point.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"point.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/point.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAM5B,qBAAa,KAAK;IAChB,OAAO,CAAC,MAAM,CAA+B;gBAEjC,CAAC,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO;IAe3D,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM,GAAG,KAAK;IAsCjD,MAAM,CAAC,IAAI,IAAI,KAAK;IASpB,MAAM,CAAC,IAAI,IAAI,EAAE;IAOjB,IAAI,IAAI,EAAE;IAOV,IAAI,IAAI,EAAE;IAOV,QAAQ,IAAI,KAAK;IAgCjB,UAAU,IAAI,OAAO;IAOrB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK;IASxB,GAAG,CAAC,MAAM,EAAE,EAAE,GAAG,KAAK;IAUtB,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,GAAG,KAAK;IAYrD,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO;IAOzB,MAAM,CAAC,iBAAiB,CAAC,KAAK,EAAE,KAAK,GAAG,MAAM;IA2B9C,SAAS,IAAI,OAAO;IAkCpB,QAAQ,CAAC,CAAC,EAAE,EAAE,GAAG,OAAO;CAazB"}

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

@@ -0,0 +1,133 @@
+import elliptic from 'elliptic';
+import { BN } from './bn.js';
+const ecInstance = new elliptic.ec('secp256k1');
+const ecPoint = ecInstance.curve.point.bind(ecInstance.curve);
+const ecPointFromX = ecInstance.curve.pointFromX.bind(ecInstance.curve);
+export class Point {
+    _point;
+    constructor(x, y, isRed) {
+        try {
+            const bnX = x instanceof BN ? x.bn : new BN(x);
+            const bnY = y instanceof BN ? y.bn : new BN(y);
+            this._point = ecPoint(bnX, bnY, isRed);
+        }
+        catch (e) {
+            throw new Error('Invalid Point');
+        }
+        this.validate();
+    }
+    static fromX(odd, x) {
+        try {
+            const xStr = typeof x === 'string' ? x : x.toString();
+            let point;
+            try {
+                const bnX = x instanceof BN ? x.bn : new BN(xStr);
+                point = ecInstance.curve.pointFromX(bnX, odd);
+            }
+            catch (e1) {
+                try {
+                    const hexStr = typeof x === 'string' ? x : '0x' + x.toString(16);
+                    const bnX = new BN(hexStr);
+                    point = ecInstance.curve.pointFromX(bnX, odd);
+                }
+                catch (e2) {
+                    const xBigInt = typeof x === 'string' ? new BN(xStr) : x.bn;
+                    const y = ecInstance.curve.yFromX(xBigInt.toString(), odd);
+                    point = ecInstance.curve.point(xBigInt.toString(), y);
+                }
+            }
+            const instance = new Point(new BN(0), new BN(0));
+            instance._point = point;
+            instance.validate();
+            return instance;
+        }
+        catch (e) {
+            throw new Error('Invalid X');
+        }
+    }
+    static getG() {
+        const instance = new Point(new BN(0), new BN(0));
+        instance._point = ecInstance.curve.g;
+        return instance;
+    }
+    static getN() {
+        return new BN(ecInstance.curve.n.toArray());
+    }
+    getX() {
+        return new BN(this._point.getX().toString());
+    }
+    getY() {
+        return new BN(this._point.getY().toString());
+    }
+    validate() {
+        if (this.isInfinity()) {
+            throw new Error('Point cannot be equal to Infinity');
+        }
+        try {
+            const x = this.getX();
+            const y = this.getY();
+            if (x === undefined || y === undefined) {
+                throw new Error('Point coordinates are undefined');
+            }
+            const n = ecInstance.curve.n;
+            const infinityPoint = this._point.mul(n);
+            if (!infinityPoint.isInfinity()) {
+                throw new Error('Point is not in the correct subgroup');
+            }
+        }
+        catch (e) {
+            throw new Error('Point does not lie on the curve');
+        }
+        return this;
+    }
+    isInfinity() {
+        return this._point.isInfinity();
+    }
+    add(other) {
+        const result = new Point(new BN(0), new BN(0));
+        result._point = this._point.add(other._point);
+        return result;
+    }
+    mul(scalar) {
+        const result = new Point(new BN(0), new BN(0));
+        result._point = this._point.mul(scalar.bn);
+        return result;
+    }
+    mulAdd(scalar1, other, scalar2) {
+        const result = new Point(new BN(0), new BN(0));
+        const point1 = this._point.mul(scalar1.bn);
+        const point2 = other._point.mul(scalar2.bn);
+        result._point = point1.add(point2);
+        return result;
+    }
+    eq(other) {
+        return this._point.eq(other._point);
+    }
+    static pointToCompressed(point) {
+        const xbuf = point.getX().toArrayLike(Buffer, 'be', 32);
+        const y = point.getY();
+        const odd = y.mod(new BN(2)).isOdd();
+        const prefix = odd ? Buffer.from([0x03]) : Buffer.from([0x02]);
+        return Buffer.concat([prefix, xbuf]);
+    }
+    hasSquare() {
+        if (this.isInfinity()) {
+            return false;
+        }
+        const x = this.getX();
+        const y = this.getY();
+        const p = new BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
+        const x3 = x.mul(x).mod(p).mul(x).mod(p);
+        const c = x3.add(new BN(7)).mod(p);
+        const exp = p.add(new BN(1)).div(new BN(4));
+        const canonicalY = c.modPow(exp, p);
+        return y.eq(canonicalY);
+    }
+    isSquare(x) {
+        const p = new BN('FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F', 16);
+        const x0 = new BN(x.toString());
+        const exponent = p.sub(new BN(1)).div(new BN(2));
+        const result = x0.modPow(exponent, p);
+        return result.eq(new BN(1));
+    }
+}

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

@@ -0,0 +1,7 @@
+export declare class Random {
+    static getRandomBuffer(size: number): Buffer;
+    static getRandomBufferNode(size: number): Buffer;
+    static getRandomBufferBrowser(size: number): Buffer;
+    static getPseudoRandomBuffer(size: number): Buffer;
+}
+//# sourceMappingURL=random.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"random.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/random.ts"],"names":[],"mappings":"AASA,qBAAa,MAAM;IAKjB,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQ5C,MAAM,CAAC,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAQhD,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAOnD,MAAM,CAAC,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;CAmBnD"}

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

@@ -0,0 +1,30 @@
+import { randomBytes as nobleRandomBytes } from '@noble/hashes/utils';
+export class Random {
+    static getRandomBuffer(size) {
+        return Buffer.from(nobleRandomBytes(size));
+    }
+    static getRandomBufferNode(size) {
+        return Random.getRandomBuffer(size);
+    }
+    static getRandomBufferBrowser(size) {
+        return Random.getRandomBuffer(size);
+    }
+    static getPseudoRandomBuffer(size) {
+        const b32 = 0x100000000;
+        const b = Buffer.alloc(size);
+        let r = 0;
+        for (let i = 0; i <= size; i++) {
+            const j = Math.floor(i / 4);
+            const k = i - j * 4;
+            if (k === 0) {
+                r = Math.random() * b32;
+                b[i] = r & 0xff;
+            }
+            else {
+                r = r >>> 8;
+                b[i] = r & 0xff;
+            }
+        }
+        return b;
+    }
+}

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

@@ -0,0 +1,40 @@
+import { BN } from './bn.js';
+import { Signature } from './signature.js';
+import { PrivateKey } from '../privatekey.js';
+import { PublicKey } from '../publickey.js';
+export interface SchnorrData {
+    hashbuf?: Buffer;
+    endian?: 'little' | 'big';
+    privkey?: PrivateKey;
+    pubkey?: PublicKey;
+    sig?: Signature;
+    verified?: boolean;
+}
+export declare class Schnorr {
+    hashbuf: Buffer;
+    endian: 'little' | 'big';
+    privkey: PrivateKey;
+    pubkey: PublicKey;
+    sig: Signature;
+    verified: boolean;
+    constructor(obj?: SchnorrData);
+    set(obj: SchnorrData): Schnorr;
+    privkey2pubkey(): Schnorr;
+    toPublicKey(): PublicKey;
+    sign(): Schnorr;
+    _findSignature(d: BN, e: BN): {
+        r: BN;
+        s: BN;
+        compressed?: boolean;
+        isSchnorr?: boolean;
+    };
+    private getrBuffer;
+    private getsBuffer;
+    sigError(): boolean;
+    verify(): Schnorr;
+    nonceFunctionRFC6979(privkey: Buffer, msgbuf: Buffer): BN;
+    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=schnorr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schnorr.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/crypto/schnorr.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AAE5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,MAAM,WAAW,WAAW;IAC1B,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,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB;AAED,qBAAa,OAAO;IAClB,OAAO,EAAG,MAAM,CAAA;IAChB,MAAM,EAAG,QAAQ,GAAG,KAAK,CAAA;IACzB,OAAO,EAAG,UAAU,CAAA;IACpB,MAAM,EAAG,SAAS,CAAA;IAClB,GAAG,EAAG,SAAS,CAAA;IACf,QAAQ,EAAG,OAAO,CAAA;gBAEN,GAAG,CAAC,EAAE,WAAW;IAM7B,GAAG,CAAC,GAAG,EAAE,WAAW,GAAG,OAAO;IAc9B,cAAc,IAAI,OAAO;IAQzB,WAAW,IAAI,SAAS;IAOxB,IAAI,IAAI,OAAO;IAkCf,cAAc,CACZ,CAAC,EAAE,EAAE,EACL,CAAC,EAAE,EAAE,GACJ;QAAE,CAAC,EAAE,EAAE,CAAC;QAAC,CAAC,EAAE,EAAE,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE;IAwD9D,OAAO,CAAC,UAAU;IAWlB,OAAO,CAAC,UAAU;IAsBlB,QAAQ,IAAI,OAAO;IA4DnB,MAAM,IAAI,OAAO;IAiBjB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,EAAE;IAwDzD,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"}