xpi-ts 0.2.0

package/dist/lib/bitcore/mnemonic/words/index.d.ts

@@ -0,0 +1,4 @@
+export declare const Words: {
+    ENGLISH: string[];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/bitcore/mnemonic/words/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/bitcore/mnemonic/words/index.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,KAAK;;CAQjB,CAAA"}

package/dist/lib/bitcore/mnemonic/words/index.js

@@ -0,0 +1,4 @@
+import { english } from './english.js';
+export const Words = {
+    ENGLISH: english,
+};

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

@@ -0,0 +1,3 @@
+export { MuSig2Signer, createMuSig2Signer, type MuSig2SignerConfig, type MuSig2PrepareResult, type MuSig2SignResult, type MuSig2TaprootSignResult, } from './signer.js';
+export { MuSigSessionManager, MuSigSessionPhase, type MuSigSession, } from './session.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/musig2/index.ts"],"names":[],"mappings":"AAgBA,OAAO,EACL,YAAY,EACZ,kBAAkB,EAClB,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,GAC7B,MAAM,aAAa,CAAA;AAEpB,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,KAAK,YAAY,GAClB,MAAM,cAAc,CAAA"}

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

@@ -0,0 +1,2 @@
+export { MuSig2Signer, createMuSig2Signer, } from './signer.js';
+export { MuSigSessionManager, MuSigSessionPhase, } from './session.js';

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

@@ -0,0 +1,79 @@
+import { PublicKey } from '../publickey.js';
+import { PrivateKey } from '../privatekey.js';
+import { Point, BN, Signature } from '../crypto/index.js';
+import { type MuSigKeyAggContext, type MuSigNonce, type MuSigAggregatedNonce } from '../crypto/musig2.js';
+export declare enum MuSigSessionPhase {
+    INIT = "init",
+    NONCE_EXCHANGE = "nonce-exchange",
+    PARTIAL_SIG_EXCHANGE = "partial-sig-exchange",
+    COMPLETE = "complete",
+    ABORTED = "aborted"
+}
+export interface SessionManagerResult {
+    shouldTransitionTo?: MuSigSessionPhase;
+    shouldRevealNonces?: boolean;
+    broadcastNonces?: [Point, Point];
+    shouldCreatePartialSig?: boolean;
+    shouldBroadcastPartialSig?: boolean;
+    broadcastPartialSig?: BN;
+    shouldFinalize?: boolean;
+    finalSignature?: Signature;
+    error?: string;
+}
+export interface MuSigSession {
+    sessionId: string;
+    signers: PublicKey[];
+    myIndex: number;
+    keyAggContext: MuSigKeyAggContext;
+    message: Buffer;
+    metadata?: Record<string, unknown>;
+    mySecretNonce?: MuSigNonce;
+    myPublicNonce?: [Point, Point];
+    receivedPublicNonces: Map<number, [Point, Point]>;
+    aggregatedNonce?: MuSigAggregatedNonce;
+    myPartialSig?: BN;
+    receivedPartialSigs: Map<number, BN>;
+    finalSignature?: Signature;
+    phase: MuSigSessionPhase;
+    createdAt: number;
+    updatedAt: number;
+    abortReason?: string;
+    electionMethod?: string;
+    coordinatorIndex?: number;
+    electionProof?: string;
+    backupCoordinators?: number[];
+}
+export declare class MuSigSessionManager {
+    createSession(signers: PublicKey[], myPrivateKey: PrivateKey, message: Buffer, metadata?: Record<string, unknown>): MuSigSession;
+    generateNonces(session: MuSigSession, privateKey: PrivateKey, extraInput?: Buffer): [Point, Point];
+    receiveNonces(session: MuSigSession, signerIndex: number, publicNonces: [Point, Point]): void;
+    createPartialSignature(session: MuSigSession, privateKey: PrivateKey): BN;
+    receivePartialSignature(session: MuSigSession, signerIndex: number, partialSig: BN): void;
+    getFinalSignature(session: MuSigSession): Signature;
+    abortSession(session: MuSigSession, reason: string): void;
+    getSessionStatus(session: MuSigSession): {
+        phase: MuSigSessionPhase;
+        noncesCollected: number;
+        noncesTotal: number;
+        partialSigsCollected: number;
+        partialSigsTotal: number;
+        isComplete: boolean;
+        isAborted: boolean;
+        abortReason?: string;
+    };
+    private _generateSessionId;
+    regenerateSessionId(session: MuSigSession): string;
+    _transitionPhaseForTesting(session: MuSigSession, newPhase: MuSigSessionPhase): void;
+    private _aggregateNonces;
+    private _finalizeSignature;
+    private _clearSecretNonce;
+    private _abortSession;
+    hasAllNonces(session: MuSigSession): boolean;
+    hasAllPartialSignatures(session: MuSigSession): boolean;
+    isCoordinator(session: MuSigSession): boolean;
+    validateBIP327Compliance(session: MuSigSession): void;
+    private areKeysSorted;
+    private validateMuSig2Rounds;
+    initiateRound1(session: MuSigSession, privateKey: PrivateKey): SessionManagerResult;
+}
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/musig2/session.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,346 @@
+import { Signature, Random, Hash } from '../crypto/index.js';
+import { musigKeyAgg, musigNonceGen, musigNonceAgg, musigPartialSign, musigPartialSigVerify, musigSigAgg, } from '../crypto/musig2.js';
+import { verifyTaprootKeyPathMuSigPartial } from '../taproot/musig2.js';
+import { calculateTapTweak, tweakPublicKey } from '../taproot.js';
+export var MuSigSessionPhase;
+(function (MuSigSessionPhase) {
+    MuSigSessionPhase["INIT"] = "init";
+    MuSigSessionPhase["NONCE_EXCHANGE"] = "nonce-exchange";
+    MuSigSessionPhase["PARTIAL_SIG_EXCHANGE"] = "partial-sig-exchange";
+    MuSigSessionPhase["COMPLETE"] = "complete";
+    MuSigSessionPhase["ABORTED"] = "aborted";
+})(MuSigSessionPhase || (MuSigSessionPhase = {}));
+export class MuSigSessionManager {
+    createSession(signers, myPrivateKey, message, metadata) {
+        if (signers.length === 0) {
+            throw new Error('Cannot create MuSig2 session with zero signers');
+        }
+        if (!message || message.length === 0) {
+            throw new Error('Cannot create MuSig2 session with empty message');
+        }
+        const keyAggContext = musigKeyAgg(signers);
+        const myPubKey = myPrivateKey.publicKey;
+        const myIndex = keyAggContext.pubkeys.findIndex(signer => signer.toString() === myPubKey.toString());
+        if (myIndex === -1) {
+            throw new Error('Private key does not correspond to any signer in the session');
+        }
+        const sessionId = this._generateSessionId(keyAggContext.pubkeys, message);
+        const now = Date.now();
+        const session = {
+            sessionId,
+            signers: keyAggContext.pubkeys,
+            myIndex,
+            keyAggContext,
+            message,
+            metadata,
+            receivedPublicNonces: new Map(),
+            receivedPartialSigs: new Map(),
+            phase: MuSigSessionPhase.INIT,
+            createdAt: now,
+            updatedAt: now,
+        };
+        return session;
+    }
+    generateNonces(session, privateKey, extraInput) {
+        if (session.phase !== MuSigSessionPhase.INIT) {
+            throw new Error(`Cannot generate nonces in phase ${session.phase}. Must be in INIT phase.`);
+        }
+        if (session.mySecretNonce || session.myPublicNonce) {
+            throw new Error('Nonces already generated for this session. NEVER reuse nonces!');
+        }
+        const entropy = extraInput !== undefined ? extraInput : Random.getRandomBuffer(32);
+        const nonce = musigNonceGen(privateKey, session.keyAggContext.aggregatedPubKey, session.message, entropy);
+        session.mySecretNonce = nonce;
+        session.myPublicNonce = nonce.publicNonces;
+        session.phase = MuSigSessionPhase.NONCE_EXCHANGE;
+        session.updatedAt = Date.now();
+        if (this.hasAllNonces(session)) {
+            this._aggregateNonces(session);
+        }
+        return nonce.publicNonces;
+    }
+    receiveNonces(session, signerIndex, publicNonces) {
+        if (session.phase !== MuSigSessionPhase.NONCE_EXCHANGE &&
+            session.phase !== MuSigSessionPhase.INIT) {
+            throw new Error(`Cannot receive nonces in phase ${session.phase}. Must be in INIT or NONCE_EXCHANGE phase.`);
+        }
+        if (signerIndex < 0 || signerIndex >= session.signers.length) {
+            throw new Error(`Invalid signer index: ${signerIndex}`);
+        }
+        if (signerIndex === session.myIndex) {
+            throw new Error('Cannot receive nonce from self');
+        }
+        if (session.receivedPublicNonces.has(signerIndex)) {
+            throw new Error(`Already received nonce from signer ${signerIndex}. Possible equivocation!`);
+        }
+        try {
+            publicNonces[0].validate();
+            publicNonces[1].validate();
+        }
+        catch (error) {
+            throw new Error(`Invalid public nonce from signer ${signerIndex}: ${error}`);
+        }
+        session.receivedPublicNonces.set(signerIndex, publicNonces);
+        session.updatedAt = Date.now();
+        if (this.hasAllNonces(session)) {
+            this._aggregateNonces(session);
+        }
+    }
+    createPartialSignature(session, privateKey) {
+        if (!session.aggregatedNonce) {
+            throw new Error('Cannot create partial signature: nonces not yet aggregated. Wait for all nonces.');
+        }
+        if (!session.mySecretNonce) {
+            throw new Error('Cannot create partial signature: secret nonce not found');
+        }
+        if (session.phase !== MuSigSessionPhase.NONCE_EXCHANGE &&
+            session.phase !== MuSigSessionPhase.PARTIAL_SIG_EXCHANGE) {
+            throw new Error(`Cannot create partial signature in phase ${session.phase}. Must be in NONCE_EXCHANGE or PARTIAL_SIG_EXCHANGE.`);
+        }
+        const partialSig = musigPartialSign(session.mySecretNonce, privateKey, session.keyAggContext, session.myIndex, session.aggregatedNonce, session.message);
+        session.myPartialSig = partialSig;
+        session.phase = MuSigSessionPhase.PARTIAL_SIG_EXCHANGE;
+        session.updatedAt = Date.now();
+        this._clearSecretNonce(session);
+        return partialSig;
+    }
+    receivePartialSignature(session, signerIndex, partialSig) {
+        if (session.phase !== MuSigSessionPhase.PARTIAL_SIG_EXCHANGE) {
+            throw new Error(`Cannot receive partial signatures in phase ${session.phase}`);
+        }
+        if (signerIndex < 0 || signerIndex >= session.signers.length) {
+            throw new Error(`Invalid signer index: ${signerIndex}`);
+        }
+        if (signerIndex === session.myIndex) {
+            throw new Error('Cannot receive partial signature from self');
+        }
+        if (session.receivedPartialSigs.has(signerIndex)) {
+            throw new Error(`Already received partial signature from signer ${signerIndex}`);
+        }
+        const publicNonce = session.receivedPublicNonces.get(signerIndex);
+        if (!publicNonce) {
+            throw new Error(`No public nonce found for signer ${signerIndex}. Cannot verify.`);
+        }
+        let isValid;
+        if (session.metadata?.inputScriptType === 'taproot') {
+            const merkleRoot = Buffer.alloc(32);
+            const tweak = calculateTapTweak(session.keyAggContext.aggregatedPubKey, merkleRoot);
+            isValid = verifyTaprootKeyPathMuSigPartial(partialSig, publicNonce, session.signers[signerIndex], session.keyAggContext, signerIndex, session.aggregatedNonce, session.message, tweak);
+        }
+        else {
+            isValid = musigPartialSigVerify(partialSig, publicNonce, session.signers[signerIndex], session.keyAggContext, signerIndex, session.aggregatedNonce, session.message);
+        }
+        if (!isValid) {
+            this._abortSession(session, `Invalid partial signature from signer ${signerIndex}`);
+            throw new Error(`Invalid partial signature from signer ${signerIndex}. Session aborted.`);
+        }
+        session.receivedPartialSigs.set(signerIndex, partialSig);
+        session.updatedAt = Date.now();
+        if (this.hasAllPartialSignatures(session)) {
+            this._finalizeSignature(session);
+        }
+    }
+    getFinalSignature(session) {
+        if (session.phase !== MuSigSessionPhase.COMPLETE) {
+            throw new Error(`Cannot get final signature: session is in phase ${session.phase}`);
+        }
+        if (!session.finalSignature) {
+            throw new Error('Final signature not found');
+        }
+        return session.finalSignature;
+    }
+    abortSession(session, reason) {
+        this._abortSession(session, reason);
+    }
+    getSessionStatus(session) {
+        const noncesTotal = session.signers.length;
+        const noncesCollected = session.receivedPublicNonces.size + (session.myPublicNonce ? 1 : 0);
+        const partialSigsTotal = session.signers.length;
+        const partialSigsCollected = session.receivedPartialSigs.size + (session.myPartialSig ? 1 : 0);
+        return {
+            phase: session.phase,
+            noncesCollected,
+            noncesTotal,
+            partialSigsCollected,
+            partialSigsTotal,
+            isComplete: session.phase === MuSigSessionPhase.COMPLETE,
+            isAborted: session.phase === MuSigSessionPhase.ABORTED,
+            abortReason: session.abortReason,
+        };
+    }
+    _generateSessionId(signers, message, createdAt = Date.now(), entropy = Random.getRandomBuffer(16)) {
+        const signersHash = Hash.sha256(Buffer.concat(signers.map(s => s.toBuffer())));
+        const messageHash = Hash.sha256(message);
+        const timestampBuffer = Buffer.alloc(8);
+        timestampBuffer.writeBigInt64BE(BigInt(createdAt));
+        const combined = Buffer.concat([
+            signersHash,
+            messageHash,
+            timestampBuffer,
+            entropy,
+        ]);
+        return Hash.sha256(combined).toString('hex').slice(0, 32);
+    }
+    regenerateSessionId(session) {
+        return this._generateSessionId(session.signers, session.message, session.createdAt, Random.getRandomBuffer(16));
+    }
+    _transitionPhaseForTesting(session, newPhase) {
+        session.phase = newPhase;
+        session.updatedAt = Date.now();
+    }
+    _aggregateNonces(session) {
+        if (!session.myPublicNonce) {
+            throw new Error('My public nonce not set');
+        }
+        const allNonces = [];
+        for (let i = 0; i < session.signers.length; i++) {
+            if (i === session.myIndex) {
+                allNonces.push(session.myPublicNonce);
+            }
+            else {
+                const nonce = session.receivedPublicNonces.get(i);
+                if (!nonce) {
+                    throw new Error(`Missing nonce from signer ${i}`);
+                }
+                allNonces.push(nonce);
+            }
+        }
+        session.aggregatedNonce = musigNonceAgg(allNonces);
+        session.updatedAt = Date.now();
+    }
+    _finalizeSignature(session) {
+        if (!session.myPartialSig) {
+            throw new Error('My partial signature not set');
+        }
+        if (!session.aggregatedNonce) {
+            throw new Error('Aggregated nonce not set');
+        }
+        const allPartialSigs = [];
+        for (let i = 0; i < session.signers.length; i++) {
+            if (i === session.myIndex) {
+                allPartialSigs.push(session.myPartialSig);
+            }
+            else {
+                const partialSig = session.receivedPartialSigs.get(i);
+                if (!partialSig) {
+                    throw new Error(`Missing partial signature from signer ${i}`);
+                }
+                allPartialSigs.push(partialSig);
+            }
+        }
+        let pubKeyForAggregation = session.keyAggContext.aggregatedPubKey;
+        if (session.metadata?.inputScriptType === 'taproot') {
+            const merkleRoot = Buffer.alloc(32);
+            pubKeyForAggregation = tweakPublicKey(session.keyAggContext.aggregatedPubKey, merkleRoot);
+        }
+        const sighashType = session.metadata?.sighashType
+            ? session.metadata.sighashType
+            : session.metadata?.inputScriptType === 'taproot'
+                ? Signature.SIGHASH_ALL | Signature.SIGHASH_LOTUS
+                : undefined;
+        session.finalSignature = musigSigAgg(allPartialSigs, session.aggregatedNonce, session.message, pubKeyForAggregation, sighashType);
+        session.phase = MuSigSessionPhase.COMPLETE;
+        session.updatedAt = Date.now();
+    }
+    _clearSecretNonce(session) {
+        if (session.mySecretNonce) {
+            const [k1, k2] = session.mySecretNonce.secretNonces;
+            session.mySecretNonce = undefined;
+        }
+    }
+    _abortSession(session, reason) {
+        session.phase = MuSigSessionPhase.ABORTED;
+        session.abortReason = reason;
+        session.updatedAt = Date.now();
+        this._clearSecretNonce(session);
+    }
+    hasAllNonces(session) {
+        if (!session.receivedPublicNonces)
+            return false;
+        return session.receivedPublicNonces.size === session.signers.length - 1;
+    }
+    hasAllPartialSignatures(session) {
+        if (!session.receivedPartialSigs)
+            return false;
+        return session.receivedPartialSigs.size === session.signers.length - 1;
+    }
+    isCoordinator(session) {
+        if (session.coordinatorIndex === undefined)
+            return false;
+        return session.myIndex === session.coordinatorIndex;
+    }
+    validateBIP327Compliance(session) {
+        if (!this.areKeysSorted(session.signers)) {
+            throw new Error('Signers must be sorted lexicographically (BIP327 requirement)');
+        }
+        if (!session.keyAggContext) {
+            throw new Error('Key aggregation context required (BIP327)');
+        }
+        this.validateMuSig2Rounds(session);
+    }
+    areKeysSorted(signers) {
+        if (signers.length <= 1)
+            return true;
+        for (let i = 0; i < signers.length - 1; i++) {
+            const current = signers[i].toBuffer();
+            const next = signers[i + 1].toBuffer();
+            if (current.compare(next) > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    validateMuSig2Rounds(session) {
+        const validPhases = [
+            MuSigSessionPhase.INIT,
+            MuSigSessionPhase.NONCE_EXCHANGE,
+            MuSigSessionPhase.PARTIAL_SIG_EXCHANGE,
+            MuSigSessionPhase.COMPLETE,
+            MuSigSessionPhase.ABORTED,
+        ];
+        if (!validPhases.includes(session.phase)) {
+            throw new Error(`Invalid session phase: ${session.phase}`);
+        }
+        switch (session.phase) {
+            case MuSigSessionPhase.NONCE_EXCHANGE:
+                if (!session.myPublicNonce && !session.mySecretNonce) {
+                    throw new Error('NONCE_EXCHANGE phase requires nonces to be generated');
+                }
+                break;
+            case MuSigSessionPhase.PARTIAL_SIG_EXCHANGE:
+                if (!session.aggregatedNonce) {
+                    throw new Error('PARTIAL_SIG_EXCHANGE phase requires aggregated nonce');
+                }
+                break;
+            case MuSigSessionPhase.COMPLETE:
+                if (!session.finalSignature) {
+                    throw new Error('COMPLETE phase requires final signature');
+                }
+                break;
+            case MuSigSessionPhase.ABORTED:
+                if (!session.abortReason) {
+                    throw new Error('ABORTED phase requires abort reason');
+                }
+                break;
+        }
+    }
+    initiateRound1(session, privateKey) {
+        try {
+            this.validateBIP327Compliance(session);
+            if (session.phase !== MuSigSessionPhase.INIT) {
+                return {
+                    error: `Cannot start Round 1 in phase ${session.phase}. Must be in INIT phase.`,
+                };
+            }
+            const publicNonces = this.generateNonces(session, privateKey);
+            return {
+                shouldTransitionTo: MuSigSessionPhase.NONCE_EXCHANGE,
+                shouldRevealNonces: true,
+                broadcastNonces: publicNonces,
+            };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    }
+}

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

@@ -0,0 +1,61 @@
+import { PrivateKey } from '../privatekey.js';
+import { PublicKey } from '../publickey.js';
+import { Signature } from '../crypto/signature.js';
+import { Point } from '../crypto/point.js';
+import { Script } from '../script.js';
+import { Address } from '../address.js';
+import { type MuSigKeyAggContext } from '../crypto/musig2.js';
+import { MuSigSessionManager, type MuSigSession } from './session.js';
+import { type MuSigTaprootKeyResult } from '../taproot/musig2.js';
+import { Transaction } from '../transaction/transaction.js';
+import { BN } from '../crypto/bn.js';
+export interface MuSig2SignerConfig {
+    signers: PublicKey[];
+    myPrivateKey: PrivateKey;
+    extraInput?: Buffer;
+}
+export interface MuSig2PrepareResult {
+    keyAggContext: MuSigKeyAggContext;
+    myPublicNonces: [Point, Point];
+    mySecretNonces: [BN, BN];
+    myIndex: number;
+    sessionId?: string;
+}
+export interface MuSig2SignResult {
+    signature: Signature;
+    aggregatedPubKey: PublicKey;
+    isAggregator: boolean;
+}
+export interface MuSig2TaprootSignResult extends MuSig2SignResult {
+    commitment: PublicKey;
+    script: Script;
+    address: Address;
+}
+export declare class MuSig2Signer {
+    private config;
+    private sessionManager?;
+    constructor(config: MuSig2SignerConfig);
+    prepare(message: Buffer | string, useSession?: boolean): MuSig2PrepareResult;
+    createPartialSignature(prepare: MuSig2PrepareResult, allPublicNonces: Array<[Point, Point]>, message: Buffer | string): BN;
+    verifyPartialSignature(partialSig: BN, publicNonce: [Point, Point], publicKey: PublicKey, signerIndex: number, prepare: MuSig2PrepareResult, allPublicNonces: Array<[Point, Point]>, message: Buffer | string): boolean;
+    sign(prepare: MuSig2PrepareResult, allPublicNonces: Array<[Point, Point]>, message: Buffer | string, allPartialSigs: BN[]): MuSig2SignResult;
+    prepareTaproot(state?: Buffer): MuSigTaprootKeyResult & {
+        keyAggContext: MuSigKeyAggContext;
+    };
+    signTaprootInput(prepare: MuSigTaprootKeyResult & {
+        keyAggContext: MuSigKeyAggContext;
+    }, allPublicNonces: Array<[Point, Point]>, transaction: Transaction, inputIndex: number, amount: number, sighashType?: number): BN;
+    completeTaprootSigning(prepare: MuSigTaprootKeyResult & {
+        keyAggContext: MuSigKeyAggContext;
+    }, allPublicNonces: Array<[Point, Point]>, allPartialSigs: BN[], transaction: Transaction, inputIndex: number, amount: number, sighashType?: number): Signature;
+    createSession(message: Buffer | string, metadata?: Record<string, unknown>): {
+        manager: MuSigSessionManager;
+        session: MuSigSession;
+    };
+    get myPublicKey(): PublicKey;
+    get allSigners(): PublicKey[];
+    get myIndex(): number;
+    private _normalizeMessage;
+}
+export declare function createMuSig2Signer(signers: PublicKey[], myPrivateKey: PrivateKey): MuSig2Signer;
+//# sourceMappingURL=signer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../../../lib/bitcore/musig2/signer.ts"],"names":[],"mappings":"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"}