@arkade-os/sdk 0.4.27 → 0.4.29

package/dist/esm/identity/singleKey.js

@@ -1,121 +0,0 @@
-import { pubECDSA, pubSchnorr, randomPrivateKeyBytes, } from "@scure/btc-signer/utils.js";
-import { SigHash } from "@scure/btc-signer";
-import { hex } from "@scure/base";
-import { TreeSignerSession } from "../tree/signingSession.js";
-import { schnorr, signAsync } from "@noble/secp256k1";
-const ALL_SIGHASH = Object.values(SigHash).filter((x) => typeof x === "number");
-/**
- * In-memory single key implementation for Bitcoin transaction signing.
- *
- * @example
- * ```typescript
- * // Create from hex string
- * const key = SingleKey.fromHex('your_private_key_hex');
- *
- * // Create from raw bytes
- * const key = SingleKey.fromPrivateKey(privateKeyBytes);
- *
- * // Create random key
- * const randomKey = SingleKey.fromRandomBytes();
- *
- * // Sign a transaction
- * const signedTx = await key.sign(transaction);
- * ```
- */
-export class SingleKey {
-    constructor(key) {
-        this.key = key || randomPrivateKeyBytes();
-    }
-    /** Create a signing identity from raw private key bytes. */
-    static fromPrivateKey(privateKey) {
-        return new SingleKey(privateKey);
-    }
-    /** Create a signing identity from a hex-encoded private key. */
-    static fromHex(privateKeyHex) {
-        return new SingleKey(hex.decode(privateKeyHex));
-    }
-    /** Create a signing identity with a freshly generated random private key. */
-    static fromRandomBytes() {
-        return new SingleKey(randomPrivateKeyBytes());
-    }
-    /**
-     * Export the private key as a hex string.
-     *
-     * @returns The private key as a hex string
-     */
-    toHex() {
-        return hex.encode(this.key);
-    }
-    async sign(tx, inputIndexes) {
-        const txCpy = tx.clone();
-        if (!inputIndexes) {
-            try {
-                if (!txCpy.sign(this.key, ALL_SIGHASH)) {
-                    throw new Error("Failed to sign transaction");
-                }
-            }
-            catch (e) {
-                if (e instanceof Error &&
-                    e.message.includes("No inputs signed")) {
-                    // ignore
-                }
-                else {
-                    throw e;
-                }
-            }
-            return txCpy;
-        }
-        for (const inputIndex of inputIndexes) {
-            if (!txCpy.signIdx(this.key, inputIndex, ALL_SIGHASH)) {
-                throw new Error(`Failed to sign input #${inputIndex}`);
-            }
-        }
-        return txCpy;
-    }
-    compressedPublicKey() {
-        return Promise.resolve(pubECDSA(this.key, true));
-    }
-    xOnlyPublicKey() {
-        return Promise.resolve(pubSchnorr(this.key));
-    }
-    signerSession() {
-        return TreeSignerSession.random();
-    }
-    async signMessage(message, signatureType = "schnorr") {
-        if (signatureType === "ecdsa")
-            return signAsync(message, this.key, { prehash: false });
-        return schnorr.signAsync(message, this.key);
-    }
-    async toReadonly() {
-        return new ReadonlySingleKey(await this.compressedPublicKey());
-    }
-}
-export class ReadonlySingleKey {
-    /** Create a readonly identity from a compressed public key. */
-    constructor(publicKey) {
-        this.publicKey = publicKey;
-        if (publicKey.length !== 33) {
-            throw new Error("Invalid public key length");
-        }
-    }
-    /**
-     * Create a ReadonlySingleKey from a compressed public key.
-     *
-     * @param publicKey - 33-byte compressed public key (02/03 prefix + 32-byte x coordinate)
-     * @returns A new ReadonlySingleKey instance
-     * @example
-     * ```typescript
-     * const pubkey = new Uint8Array(33); // your compressed public key
-     * const readonlyKey = ReadonlySingleKey.fromPublicKey(pubkey);
-     * ```
-     */
-    static fromPublicKey(publicKey) {
-        return new ReadonlySingleKey(publicKey);
-    }
-    xOnlyPublicKey() {
-        return Promise.resolve(this.publicKey.slice(1));
-    }
-    compressedPublicKey() {
-        return Promise.resolve(this.publicKey);
-    }
-}

package/dist/esm/identity/staticDescriptorProvider.js

@@ -1,61 +0,0 @@
-import { hex } from "@scure/base";
-import { isBatchSignable } from "./index.js";
-import { normalizeToDescriptor, extractPubKey } from "./descriptor.js";
-/**
- * Wraps a legacy Identity (single-key) as a DescriptorProvider.
- * The descriptor is always a simple tr(pubkey) format.
- */
-export class StaticDescriptorProvider {
-    constructor(identity, pubKeyHex) {
-        this.identity = identity;
-        this.pubKeyHex = pubKeyHex;
-        this.descriptor = `tr(${pubKeyHex})`;
-    }
-    static async create(identity) {
-        const pubKey = await identity.xOnlyPublicKey();
-        return new StaticDescriptorProvider(identity, hex.encode(pubKey));
-    }
-    async getNextSigningDescriptor() {
-        return this.descriptor;
-    }
-    isOurs(descriptor) {
-        try {
-            const normalized = normalizeToDescriptor(descriptor);
-            const pubKey = extractPubKey(normalized);
-            return pubKey.toLowerCase() === this.pubKeyHex.toLowerCase();
-        }
-        catch {
-            return false;
-        }
-    }
-    async signWithDescriptor(requests) {
-        for (const request of requests) {
-            if (!this.isOurs(request.descriptor)) {
-                throw new Error(`Descriptor ${request.descriptor} does not belong to this provider`);
-            }
-        }
-        // Use batch signing when the identity supports it (fewer confirmation popups)
-        if (isBatchSignable(this.identity)) {
-            const signed = await this.identity.signMultiple(requests.map((r) => ({
-                tx: r.tx,
-                inputIndexes: r.inputIndexes,
-            })));
-            if (signed.length !== requests.length) {
-                throw new Error(`signMultiple returned ${signed.length} transactions, expected ${requests.length}`);
-            }
-            return signed;
-        }
-        const results = [];
-        for (const request of requests) {
-            const signed = await this.identity.sign(request.tx, request.inputIndexes);
-            results.push(signed);
-        }
-        return results;
-    }
-    async signMessageWithDescriptor(descriptor, message, type = "schnorr") {
-        if (!this.isOurs(descriptor)) {
-            throw new Error(`Descriptor ${descriptor} does not belong to this provider`);
-        }
-        return this.identity.signMessage(message, type);
-    }
-}

package/dist/esm/index.js

@@ -1,87 +0,0 @@
-import { Transaction } from "./utils/transaction.js";
-import { SingleKey, ReadonlySingleKey } from "./identity/singleKey.js";
-import { SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, } from "./identity/seedIdentity.js";
-import { isBatchSignable, } from "./identity/index.js";
-import { ArkAddress } from "./script/address.js";
-import { VHTLC } from "./script/vhtlc.js";
-import { DefaultVtxo } from "./script/default.js";
-import { DelegateVtxo } from "./script/delegate.js";
-import { MessageBus, } from "./worker/messageBus.js";
-import { VtxoScript, TapTreeCoder, getSequence, } from "./script/base.js";
-import { TxType, isSpendable, isSubdust, isRecoverable, isExpired, } from "./wallet/index.js";
-import { Batch } from "./wallet/batch.js";
-import { Wallet, ReadonlyWallet, waitForIncomingFunds, DescriptorSigningProviderMissingError, MissingSigningDescriptorError, } from "./wallet/wallet.js";
-import { TxTree } from "./tree/txTree.js";
-import { Ramps } from "./wallet/ramps.js";
-import { HDDescriptorProvider } from "./wallet/hdDescriptorProvider.js";
-import { isVtxoExpiringSoon, VtxoManager } from "./wallet/vtxo-manager.js";
-import { ServiceWorkerWallet, ServiceWorkerReadonlyWallet, DEFAULT_MESSAGE_TIMEOUTS, } from "./wallet/serviceWorker/wallet.js";
-import { OnchainWallet } from "./wallet/onchain.js";
-import { setupServiceWorker } from "./worker/browser/utils.js";
-import { ESPLORA_URL, EsploraProvider, } from "./providers/onchain.js";
-import { ELECTRUM_TCP_HOST, ELECTRUM_WS_URL, ElectrumOnchainProvider, WsElectrumChainSource, } from "./providers/electrum.js";
-import { RestArkProvider, SettlementEventType, } from "./providers/ark.js";
-import { RestDelegatorProvider, } from "./providers/delegator.js";
-import { CLTVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CSVMultisigTapscript, decodeTapscript, MultisigTapscript, } from "./script/tapscript.js";
-import { hasBoardingTxExpired, buildOffchainTx, verifyTapscriptSignatures, combineTapscriptSigs, isValidArkAddress, } from "./utils/arkTransaction.js";
-import { VtxoTaprootTree, ConditionWitness, getArkPsbtFields, setArkPsbtField, ArkPsbtFieldKey, ArkPsbtFieldKeyType, CosignerPublicKey, VtxoTreeExpiry, } from "./utils/unknownFields.js";
-import { Intent } from "./intent/index.js";
-import { BIP322 } from "./bip322/index.js";
-import { ArkNote } from "./arknote/index.js";
-import { networks } from "./networks.js";
-import { RestIndexerProvider, IndexerTxType, ChainTxType, } from "./providers/indexer.js";
-import { P2A } from "./utils/anchor.js";
-import { TxWeightEstimator } from "./utils/txSizeEstimator.js";
-import { Unroll } from "./wallet/unroll.js";
-import { ArkError, maybeArkError } from "./providers/errors.js";
-import { validateVtxoTxGraph, validateConnectorsTxGraph, } from "./tree/validation.js";
-import { buildForfeitTx } from "./forfeit.js";
-import { IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, } from "./repositories/index.js";
-import { DelegatorManagerImpl } from "./wallet/delegator.js";
-export * from "./arkfee/index.js";
-export * as asset from "./extension/asset/index.js";
-// Contracts
-import { ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, } from "./contracts/index.js";
-import { timelockToSequence, sequenceToTimelock } from "./utils/timelock.js";
-import { closeDatabase, openDatabase } from "./repositories/indexedDB/manager.js";
-import { WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, } from "./wallet/serviceWorker/wallet-message-handler.js";
-import { MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, } from "./worker/errors.js";
-export { 
-// Wallets
-Wallet, ReadonlyWallet, SingleKey, ReadonlySingleKey, SeedIdentity, MnemonicIdentity, ReadonlyDescriptorIdentity, isBatchSignable, OnchainWallet, Ramps, VtxoManager, HDDescriptorProvider, DelegatorManagerImpl, RestDelegatorProvider, 
-// Providers
-ESPLORA_URL, EsploraProvider, ELECTRUM_WS_URL, ELECTRUM_TCP_HOST, ElectrumOnchainProvider, WsElectrumChainSource, RestArkProvider, RestIndexerProvider, 
-// Script-related
-ArkAddress, DefaultVtxo, DelegateVtxo, VtxoScript, VHTLC, 
-// Enums
-TxType, IndexerTxType, ChainTxType, SettlementEventType, 
-// Service Worker
-setupServiceWorker, MessageBus, WalletMessageHandler, WalletNotInitializedError, ReadonlyWalletError, DelegatorNotConfiguredError, MESSAGE_BUS_NOT_INITIALIZED, MessageBusNotInitializedError, ServiceWorkerTimeoutError, ServiceWorkerWallet, ServiceWorkerReadonlyWallet, DEFAULT_MESSAGE_TIMEOUTS, 
-// Tapscript
-decodeTapscript, MultisigTapscript, CSVMultisigTapscript, ConditionCSVMultisigTapscript, ConditionMultisigTapscript, CLTVMultisigTapscript, TapTreeCoder, 
-// Arkade PSBT fields
-ArkPsbtFieldKey, ArkPsbtFieldKeyType, setArkPsbtField, getArkPsbtFields, CosignerPublicKey, VtxoTreeExpiry, VtxoTaprootTree, ConditionWitness, 
-// Utils
-buildOffchainTx, verifyTapscriptSignatures, waitForIncomingFunds, hasBoardingTxExpired, combineTapscriptSigs, isVtxoExpiringSoon, isValidArkAddress, 
-// Arknote
-ArkNote, 
-// Network
-networks, 
-// DB
-closeDatabase, openDatabase, 
-// Repositories
-IndexedDBWalletRepository, IndexedDBContractRepository, InMemoryWalletRepository, InMemoryContractRepository, MIGRATION_KEY, migrateWalletRepository, requiresMigration, getMigrationStatus, rollbackMigration, WalletRepositoryImpl, ContractRepositoryImpl, 
-// Intent proof
-Intent, 
-// BIP-322 message signing
-BIP322, 
-// TxTree
-TxTree, 
-// Anchor
-P2A, Unroll, Transaction, TxWeightEstimator, timelockToSequence, sequenceToTimelock, 
-// Errors
-ArkError, maybeArkError, DescriptorSigningProviderMissingError, MissingSigningDescriptorError, 
-// Batch session
-Batch, validateVtxoTxGraph, validateConnectorsTxGraph, buildForfeitTx, isRecoverable, isSpendable, isSubdust, isExpired, getSequence, 
-// Contracts
-ContractManager, ContractWatcher, contractHandlers, DefaultContractHandler, DelegateContractHandler, VHTLCContractHandler, encodeArkContract, decodeArkContract, contractFromArkContract, contractFromArkContractWithAddress, isArkContract, };

package/dist/esm/intent/index.js

@@ -1,255 +0,0 @@
-import { OP, Script, SigHash } from "@scure/btc-signer";
-import { schnorr } from "@noble/curves/secp256k1.js";
-import { Transaction } from "../utils/transaction.js";
-import { ConditionWitness, VtxoTaprootTree } from "../utils/unknownFields.js";
-import { hex } from "@scure/base";
-import { getSequence, VtxoScript } from "../script/base.js";
-/**
- * Intent proof implementation for Bitcoin message signing.
- *
- * Intent proof defines a standard for signing Bitcoin messages as well as proving
- * ownership of outputs.
- *
- * This namespace provides utilities for creating and validating Intent proof.
- *
- * It is greatly inspired by BIP322.
- * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
- *
- * @example
- * ```typescript
- * // Create a Intent proof
- * const proof = Intent.create(
- *   "Hello Bitcoin!",
- *   [input],
- *   [output]
- * );
- *
- * // Sign the proof
- * const signedProof = await identity.sign(proof);
- *
- */
-export var Intent;
-(function (Intent) {
-    /**
-     * Creates a new Intent proof unsigned transaction.
-     *
-     * This function constructs a special transaction that can be signed to prove
-     * ownership of onchain and virtual outputs. The proof includes the message to be
-     * signed and the inputs/outputs that demonstrate ownership.
-     *
-     * @param message - The Intent message to be signed, either raw string of Message object
-     * @param ins - Array of transaction inputs to prove ownership of
-     * @param outputs - Optional array of transaction outputs
-     * @returns An unsigned Intent proof transaction
-     */
-    function create(message, ins, outputs = []) {
-        if (typeof message !== "string") {
-            message = encodeMessage(message);
-        }
-        if (ins.length == 0)
-            throw new Error("intent proof requires at least one input");
-        const inputs = ins.map(prepareCoinAsIntentProofInput);
-        if (!validateInputs(inputs))
-            throw new Error("invalid inputs");
-        if (!validateOutputs(outputs))
-            throw new Error("invalid outputs");
-        // Create the initial transaction to spend.
-        const toSpend = craftToSpendTx(message, inputs[0].witnessUtxo.script);
-        // Create the transaction to sign.
-        return craftToSignTx(toSpend, inputs, outputs);
-    }
-    Intent.create = create;
-    /**
-     * Compute the fee paid by an intent proof transaction.
-     *
-     * @param proof - Intent proof transaction
-     * @returns The fee in satoshis
-     */
-    function fee(proof) {
-        let sumOfInputs = 0n;
-        for (let i = 0; i < proof.inputsLength; i++) {
-            const input = proof.getInput(i);
-            if (input.witnessUtxo === undefined)
-                throw new Error("intent proof input requires witness utxo");
-            sumOfInputs += input.witnessUtxo.amount;
-        }
-        let sumOfOutputs = 0n;
-        for (let i = 0; i < proof.outputsLength; i++) {
-            const output = proof.getOutput(i);
-            if (output.amount === undefined)
-                throw new Error("intent proof output requires amount");
-            sumOfOutputs += output.amount;
-        }
-        if (sumOfOutputs > sumOfInputs) {
-            throw new Error(`intent proof output amount is greater than input amount: ${sumOfOutputs} > ${sumOfInputs}`);
-        }
-        return Number(sumOfInputs - sumOfOutputs);
-    }
-    Intent.fee = fee;
-    /**
-     * Serialize an intent message to the canonical JSON string used for signing.
-     *
-     * @param message - Intent message payload
-     * @returns Canonical string form of the message
-     */
-    function encodeMessage(message) {
-        switch (message.type) {
-            case "register":
-                return JSON.stringify({
-                    type: "register",
-                    onchain_output_indexes: message.onchain_output_indexes,
-                    valid_at: message.valid_at,
-                    expire_at: message.expire_at,
-                    cosigners_public_keys: message.cosigners_public_keys,
-                });
-            case "delete":
-                return JSON.stringify({
-                    type: "delete",
-                    expire_at: message.expire_at,
-                });
-            case "get-pending-tx":
-                return JSON.stringify({
-                    type: "get-pending-tx",
-                    expire_at: message.expire_at,
-                });
-        }
-    }
-    Intent.encodeMessage = encodeMessage;
-})(Intent || (Intent = {}));
-export const OP_RETURN_EMPTY_PKSCRIPT = new Uint8Array([OP.RETURN]);
-const ZERO_32 = new Uint8Array(32).fill(0);
-const MAX_INDEX = 0xffffffff;
-export const TAG_INTENT_PROOF = "ark-intent-proof-message";
-function validateInput(input) {
-    if (input.index === undefined)
-        throw new Error("intent proof input requires index");
-    if (input.txid === undefined)
-        throw new Error("intent proof input requires txid");
-    if (input.witnessUtxo === undefined)
-        throw new Error("intent proof input requires witness utxo");
-    return true;
-}
-function validateInputs(inputs) {
-    inputs.forEach(validateInput);
-    return true;
-}
-function validateOutput(output) {
-    if (output.amount === undefined)
-        throw new Error("intent proof output requires amount");
-    if (output.script === undefined)
-        throw new Error("intent proof output requires script");
-    return true;
-}
-function validateOutputs(outputs) {
-    outputs.forEach(validateOutput);
-    return true;
-}
-/**
- * Creates the "to_spend" transaction used by both intent proofs and BIP-322.
- *
- * The message is hashed with the given tagged-hash tag before being placed
- * into the scriptSig as `OP_0 <hash>`.
- *
- * @param message - The message to embed
- * @param pkScript - The scriptPubKey of the signer's address
- * @param tag - Tagged-hash tag (defaults to the Arkade intent proof tag)
- */
-export function craftToSpendTx(message, pkScript, tag = TAG_INTENT_PROOF) {
-    const messageHash = hashMessage(message, tag);
-    const tx = new Transaction({
-        version: 0,
-    });
-    // add input with zero hash and max index
-    tx.addInput({
-        txid: ZERO_32, // zero hash
-        index: MAX_INDEX,
-        sequence: 0,
-    });
-    // add output with zero value and provided pkScript
-    tx.addOutput({
-        amount: 0n,
-        script: pkScript,
-    });
-    tx.updateInput(0, {
-        finalScriptSig: Script.encode(["OP_0", messageHash]),
-    });
-    return tx;
-}
-// craftToSignTx creates the transaction that will be signed for the proof
-function craftToSignTx(toSpend, inputs, outputs) {
-    const firstInput = inputs[0];
-    // Proof tx is never broadcast onchain — toSpend references a zero-hash
-    // outpoint (see BIP-322). The tx exists only as a sighash commitment
-    // the server verifies signatures against; nLockTime and nSequence carry
-    // no consensus meaning here, they only need to match between signer and
-    // verifier. Use lockTime = 0 (BIP-322 convention) and leave each input's
-    // nSequence untouched.
-    const tx = new Transaction({
-        version: 2,
-        lockTime: 0,
-    });
-    // add the first "toSpend" input
-    tx.addInput({
-        ...firstInput,
-        txid: toSpend.id,
-        index: 0,
-        witnessUtxo: {
-            script: firstInput.witnessUtxo.script,
-            amount: 0n,
-        },
-        sighashType: SigHash.ALL,
-    });
-    // add other inputs
-    for (const [i, input] of inputs.entries()) {
-        tx.addInput({
-            ...input,
-            sighashType: SigHash.ALL,
-        });
-        if (input.unknown?.length) {
-            tx.updateInput(i + 1, {
-                unknown: input.unknown,
-            });
-        }
-    }
-    // add the special OP_RETURN output if no outputs are provided
-    if (outputs.length === 0) {
-        outputs = [
-            {
-                amount: 0n,
-                script: OP_RETURN_EMPTY_PKSCRIPT,
-            },
-        ];
-    }
-    for (const output of outputs) {
-        tx.addOutput({
-            amount: output.amount,
-            script: output.script,
-        });
-    }
-    return tx;
-}
-function hashMessage(message, tag = TAG_INTENT_PROOF) {
-    return schnorr.utils.taggedHash(tag, new TextEncoder().encode(message));
-}
-function prepareCoinAsIntentProofInput(coin) {
-    if (!("tapTree" in coin)) {
-        return coin;
-    }
-    const vtxoScript = VtxoScript.decode(coin.tapTree);
-    const sequence = getSequence(coin.intentTapLeafScript);
-    const unknown = [VtxoTaprootTree.encode(coin.tapTree)];
-    if (coin.extraWitness) {
-        unknown.push(ConditionWitness.encode(coin.extraWitness));
-    }
-    return {
-        txid: hex.decode(coin.txid),
-        index: coin.vout,
-        witnessUtxo: {
-            amount: BigInt(coin.value),
-            script: vtxoScript.pkScript,
-        },
-        sequence,
-        tapLeafScript: [coin.intentTapLeafScript],
-        unknown,
-    };
-}

package/dist/esm/musig2/index.js

@@ -1,3 +0,0 @@
-export { generateNonces, aggregateNonces } from "./nonces.js";
-export { PartialSig, sign } from "./sign.js";
-export { aggregateKeys } from "./keys.js";

package/dist/esm/musig2/keys.js

@@ -1,21 +0,0 @@
-import * as musig from "@scure/btc-signer/musig2.js";
-import { schnorr } from "@noble/curves/secp256k1.js";
-// Aggregates multiple public keys according to the MuSig2 algorithm
-export function aggregateKeys(publicKeys, sort, options = {}) {
-    if (sort) {
-        publicKeys = musig.sortKeys(publicKeys);
-    }
-    const { aggPublicKey: preTweakedKey } = musig.keyAggregate(publicKeys);
-    if (!options.taprootTweak) {
-        return {
-            preTweakedKey: preTweakedKey.toBytes(true),
-            finalKey: preTweakedKey.toBytes(true),
-        };
-    }
-    const tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.toBytes(true).subarray(1), options.taprootTweak ?? new Uint8Array(0));
-    const { aggPublicKey: finalKey } = musig.keyAggregate(publicKeys, [tweakBytes], [true]);
-    return {
-        preTweakedKey: preTweakedKey.toBytes(true),
-        finalKey: finalKey.toBytes(true),
-    };
-}

package/dist/esm/musig2/nonces.js

@@ -1,11 +0,0 @@
-import * as musig from "@scure/btc-signer/musig2.js";
-/**
- * Generates a pair of public and secret nonces for MuSig2 signing
- */
-export function generateNonces(publicKey) {
-    const nonces = musig.nonceGen(publicKey);
-    return { secNonce: nonces.secret, pubNonce: nonces.public };
-}
-export function aggregateNonces(pubNonces) {
-    return musig.nonceAggregate(pubNonces);
-}

package/dist/esm/musig2/sign.js

@@ -1,63 +0,0 @@
-import * as musig from "@scure/btc-signer/musig2.js";
-import { bytesToNumberBE } from "@noble/curves/utils.js";
-import { Point } from "@noble/secp256k1";
-import { aggregateKeys } from "./keys.js";
-import { schnorr } from "@noble/curves/secp256k1.js";
-// Add this error type for decode failures
-export class PartialSignatureError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "PartialSignatureError";
-    }
-}
-// Implement a concrete class for PartialSignature
-export class PartialSig {
-    constructor(s, R) {
-        this.s = s;
-        this.R = R;
-        if (s.length !== 32) {
-            throw new PartialSignatureError("Invalid s length");
-        }
-        if (R.length !== 33) {
-            throw new PartialSignatureError("Invalid R length");
-        }
-    }
-    /**
-     * Encodes the partial signature into bytes
-     * Returns a 32-byte array containing just the s value
-     */
-    encode() {
-        // Return copy of s bytes
-        return new Uint8Array(this.s);
-    }
-    /**
-     * Decodes a partial signature from bytes
-     * @param bytes - 32-byte array containing s value
-     */
-    static decode(bytes) {
-        if (bytes.length !== 32) {
-            throw new PartialSignatureError("Invalid partial signature length");
-        }
-        // Verify s is less than curve order
-        const s = bytesToNumberBE(bytes);
-        if (s >= Point.CURVE().n) {
-            throw new PartialSignatureError("s value overflows curve order");
-        }
-        // For decode we don't have R, so we'll need to compute it later
-        const R = new Uint8Array(33); // Zero R for now
-        return new PartialSig(bytes, R);
-    }
-}
-/**
- * Generates a MuSig2 partial signature
- */
-export function sign(secNonce, privateKey, combinedNonce, publicKeys, message, options) {
-    let tweakBytes;
-    if (options?.taprootTweak !== undefined) {
-        const { preTweakedKey } = aggregateKeys(options?.sortKeys ? musig.sortKeys(publicKeys) : publicKeys, true);
-        tweakBytes = schnorr.utils.taggedHash("TapTweak", preTweakedKey.subarray(1), options.taprootTweak);
-    }
-    const session = new musig.Session(combinedNonce, options?.sortKeys ? musig.sortKeys(publicKeys) : publicKeys, message, tweakBytes ? [tweakBytes] : undefined, tweakBytes ? [true] : undefined);
-    const partialSig = session.sign(secNonce, privateKey);
-    return PartialSig.decode(partialSig);
-}

package/dist/esm/networks.js

@@ -1,22 +0,0 @@
-import { NETWORK, TEST_NETWORK } from "@scure/btc-signer/utils.js";
-export const getNetwork = (network) => {
-    return networks[network];
-};
-export const networks = {
-    bitcoin: withArkPrefix(NETWORK, "ark"),
-    testnet: withArkPrefix(TEST_NETWORK, "tark"),
-    signet: withArkPrefix(TEST_NETWORK, "tark"),
-    mutinynet: withArkPrefix(TEST_NETWORK, "tark"),
-    regtest: withArkPrefix({
-        ...TEST_NETWORK,
-        bech32: "bcrt",
-        pubKeyHash: 0x6f,
-        scriptHash: 0xc4,
-    }, "tark"),
-};
-function withArkPrefix(network, prefix) {
-    return {
-        ...network,
-        hrp: prefix,
-    };
-}

package/dist/esm/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}