@arkade-os/sdk 0.0.16

package/README.md

@@ -0,0 +1,312 @@
+# Ark Wallet SDK
+The Ark Wallet SDK is a TypeScript library for building Bitcoin wallets with support for both on-chain and off-chain transactions via Ark protocol.
+
+![v3](https://github.com/user-attachments/assets/bec6fd29-417d-46af-8216-709edc39d566)
+
+## Installation
+
+```bash
+npm install @arkade-os/sdk
+```
+
+## Usage
+
+### Creating a Wallet
+
+```typescript
+import { InMemoryKey, Wallet } from '@arkade-os/sdk'
+
+// Create a new in-memory key (or use an external signer)
+const identity = InMemoryKey.fromHex('your_private_key_hex')
+
+// Create a wallet with Ark support
+const wallet = await Wallet.create({
+  network: 'mutinynet',  // 'bitcoin', 'testnet', 'regtest', 'signet' or 'mutinynet'
+  identity: identity,
+  // Esplora API, can be left empty mempool.space API will be used
+  esploraUrl: 'https://mutinynet.com/api', 
+  // OPTIONAL Ark Server connection information
+  arkServerUrl: 'https://mutinynet.arkade.sh',
+  arkServerPublicKey: 'fa73c6e4876ffb2dfc961d763cca9abc73d4b88efcb8f5e7ff92dc55e9aa553d'
+})
+
+// Get wallet addresses
+const addresses = await wallet.getAddress()
+console.log('Bitcoin Address:', addresses.onchain)
+console.log('Ark Address:', addresses.offchain)
+console.log('Boarding Address:', addresses.boarding)
+console.log('BIP21 URI:', addresses.bip21)
+```
+
+### Sending Bitcoin
+
+```typescript
+// Send bitcoin (automatically chooses on-chain or off-chain based on the address)
+const txid = await wallet.sendBitcoin({
+  address: 'tb1qw508d6qejxtdg4y5r3zarvary0c5xw7kxpjzsx',
+  amount: 50000,  // in satoshis
+  feeRate: 1      // optional, in sats/vbyte
+})
+
+// For settling transactions
+const settleTxid = await wallet.settle({
+  inputs, // from getVtxos() or getBoardingUtxos()
+  outputs: [{
+    address: destinationAddress,
+    amount: BigInt(amount)
+  }]
+})
+```
+
+### Checking Balance
+
+```typescript
+// Get detailed balance information
+const balance = await wallet.getBalance()
+console.log('Total Onchain:', balance.onchain.total)
+console.log('Total Offchain:', balance.offchain.total)
+
+// Get virtual UTXOs (off-chain)
+const virtualCoins = await wallet.getVtxos()
+
+// Get boarding UTXOs
+const boardingUtxos = await wallet.getBoardingUtxos()
+```
+
+### Transaction History
+
+```typescript
+// Get transaction history
+const history = await wallet.getTransactionHistory()
+console.log('History:', history)
+
+// Example history entry:
+{
+  type: TxType.TxReceived, // or TxType.TxSent
+  amount: 50000,
+  settled: true,
+  key: {
+    boardingTxid: '...', // for boarding transactions
+    redeemTxid: '...'    // for regular transactions
+  }
+}
+```
+
+### Running the wallet in a service worker
+
+1. Create a service worker file
+
+```typescript
+// service-worker.ts
+import { Worker } from '@arkade-os/sdk'
+
+// Worker is a class handling the communication between the main thread and the service worker
+new Worker().start()
+```
+
+2. Instantiate the ServiceWorkerWallet
+
+```typescript
+// specify the path to the service worker file
+// this will automatically register the service worker
+const wallet = await ServiceWorkerWallet.create('/service-worker.js')
+
+// initialize the wallet
+await wallet.init({
+  network: 'mutinynet',  // 'bitcoin', 'testnet', 'regtest', 'signet' or 'mutinynet'
+  identity: identity,
+  // Esplora API, can be left empty mempool.space API will be used
+  esploraUrl: 'https://mutinynet.com/api', 
+  // OPTIONAL Ark Server connection information
+  arkServerUrl: 'https://mutinynet.arkade.sh',
+  arkServerPublicKey: 'fa73c6e4876ffb2dfc961d763cca9abc73d4b88efcb8f5e7ff92dc55e9aa553d'
+})
+```
+
+## API Reference
+
+### Wallet
+
+#### Constructor Options
+
+```typescript
+interface WalletConfig {
+  /** Network to use ('bitcoin', 'testnet', 'regtest', 'signet', or 'mutinynet') */
+  network: NetworkName;
+  /** Identity for signing transactions */
+  identity: Identity;
+  /** Optional Esplora API URL */
+  esploraUrl?: string;
+  /** Ark server URL (optional) */
+  arkServerUrl?: string;
+  /** Ark server public key (optional) */
+  arkServerPublicKey?: string;
+}
+```
+
+#### Methods
+
+```typescript
+interface IWallet {
+  /** Get wallet addresses */
+  getAddress(): Promise<{
+    onchain?: Address;
+    offchain?: Address;
+    boarding?: Address;
+    bip21?: string;
+  }>;
+
+  /** Get wallet balance */
+  getBalance(): Promise<{
+    onchain: {
+      total: number;
+      confirmed: number;
+      unconfirmed: number;
+    };
+    offchain: {
+      total: number;
+      settled: number;
+      pending: number;
+    };
+  }>;
+
+  /** Send bitcoin (on-chain or off-chain) */
+  sendBitcoin(params: {
+    address: string;
+    amount: number;
+    feeRate?: number;
+  }, onchain?: boolean): Promise<string>;
+
+  /** Get virtual UTXOs */
+  getVtxos(): Promise<VirtualCoin[]>;
+
+  /** Get boarding UTXOs */
+  getBoardingUtxos(): Promise<BoardingUtxo[]>;
+
+  /** Settle transactions */
+  settle(params: {
+    inputs: (VirtualCoin | BoardingUtxo)[];
+    outputs: {
+      address: string;
+      amount: bigint;
+    }[];
+  }): Promise<string>;
+
+  /** Get transaction history */
+  getTransactionHistory(): Promise<Transaction[]>;
+}
+
+/** Transaction types */
+enum TxType {
+  TxSent = 'sent',
+  TxReceived = 'received'
+}
+
+/** Transaction history entry */
+interface Transaction {
+  type: TxType;
+  amount: number;
+  settled: boolean;
+  key: {
+    boardingTxid?: string;
+    redeemTxid?: string;
+  };
+}
+
+/** Virtual coin (off-chain UTXO) */
+interface VirtualCoin {
+  txid: string;
+  value: number;
+  virtualStatus: {
+    state: 'pending' | 'settled';
+  };
+}
+
+/** Boarding UTXO */
+interface BoardingUtxo {
+  txid: string;
+  vout: number;
+  value: number;
+}
+```
+
+#### Identity
+
+```typescript
+export interface Identity {
+    sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
+    xOnlyPublicKey(): Uint8Array;
+    signerSession(): SignerSession;
+}
+```
+
+The SDK provides a default implementation of the `Identity` interface: `InMemoryKey` for managing private keys in memory:
+
+```typescript
+class InMemoryKey {
+  static fromPrivateKey(privateKey: Uint8Array): InMemoryKey;
+  static fromHex(privateKeyHex: string): InMemoryKey;
+}
+```
+
+## Development
+
+### Requirements
+
+- [pnpm](https://pnpm.io/) - Package manager
+- [nigiri](https://github.com/vulpemventures/nigiri) - For running integration tests with a local Bitcoin regtest network
+
+### Setup
+
+1. Install dependencies:
+
+```bash
+pnpm install
+pnpm format
+pnpm lint
+```
+
+2.Install nigiri for integration tests:
+
+```bash
+curl https://getnigiri.vulpem.com | bash
+```
+
+### Running Tests
+
+```bash
+# Run all tests
+pnpm test
+
+# Run unit tests only
+pnpm test:unit
+
+# Run integration tests (requires nigiri)
+nigiri start --ark
+pnpm test:setup      # Run setup script for integration tests
+pnpm test:integration
+nigiri stop --delete
+
+# Watch mode for development
+pnpm test:watch
+
+# Run tests with coverage
+pnpm test:coverage
+```
+
+### Releasing
+
+```bash
+# Release new version (will prompt for version patch, minor, major)
+pnpm release
+
+# You can test release process without making changes
+pnpm release:dry-run
+
+# Cleanup: checkout version commit and remove release branch
+pnpm release:cleanup
+```
+
+## License
+
+MIT

package/dist/cjs/arknote/index.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArkNote = exports.ArkNoteData = void 0;
+const base_1 = require("@scure/base");
+// ArkNoteData is the unsigned data part of a note
+class ArkNoteData {
+    constructor(id, value) {
+        this.id = id;
+        this.value = value;
+    }
+    encode() {
+        const array = new Uint8Array(12);
+        writeBigUInt64BE(array, this.id, 0);
+        writeUInt32BE(array, this.value, 8);
+        return array;
+    }
+    static decode(data) {
+        if (data.length !== 12) {
+            throw new Error(`invalid data length: expected 12 bytes, got ${data.length}`);
+        }
+        const id = readBigUInt64BE(data, 0);
+        const value = readUInt32BE(data, 8);
+        return new ArkNoteData(id, value);
+    }
+}
+exports.ArkNoteData = ArkNoteData;
+// ArkNote is a note with the issuer's signature
+class ArkNote {
+    constructor(data, signature) {
+        this.data = data;
+        this.signature = signature;
+    }
+    encode() {
+        const detailsBytes = this.data.encode();
+        const result = new Uint8Array(detailsBytes.length + this.signature.length);
+        result.set(detailsBytes);
+        result.set(this.signature, detailsBytes.length);
+        return result;
+    }
+    static decode(data) {
+        if (data.length < 12) {
+            throw new Error(`invalid data length: expected at least 12 bytes, got ${data.length}`);
+        }
+        const noteData = ArkNoteData.decode(data.subarray(0, 12));
+        const signature = data.subarray(12);
+        if (signature.length !== 64) {
+            throw new Error(`invalid signature length: expected 64 bytes, got ${signature.length}`);
+        }
+        return new ArkNote(noteData, signature);
+    }
+    static fromString(noteStr) {
+        if (!noteStr.startsWith(ArkNote.HRP)) {
+            throw new Error(`invalid human-readable part: expected ${ArkNote.HRP} prefix (note '${noteStr}')`);
+        }
+        const encoded = noteStr.slice(ArkNote.HRP.length);
+        if (encoded.length < 103 || encoded.length > 104) {
+            throw new Error(`invalid note length: expected 103 or 104 chars, got ${encoded.length}`);
+        }
+        const decoded = base_1.base58.decode(encoded);
+        if (decoded.length === 0) {
+            throw new Error("failed to decode base58 string");
+        }
+        return ArkNote.decode(new Uint8Array(decoded));
+    }
+    toString() {
+        return ArkNote.HRP + base_1.base58.encode(this.encode());
+    }
+}
+exports.ArkNote = ArkNote;
+ArkNote.HRP = "arknote";
+function writeBigUInt64BE(array, value, offset) {
+    const view = new DataView(array.buffer, array.byteOffset + offset, 8);
+    view.setBigUint64(0, value, false);
+}
+function readBigUInt64BE(array, offset) {
+    const view = new DataView(array.buffer, array.byteOffset + offset, 8);
+    return view.getBigUint64(0, false);
+}
+function writeUInt32BE(array, value, offset) {
+    const view = new DataView(array.buffer, array.byteOffset + offset, 4);
+    view.setUint32(0, value, false);
+}
+function readUInt32BE(array, offset) {
+    const view = new DataView(array.buffer, array.byteOffset + offset, 4);
+    return view.getUint32(0, false);
+}

package/dist/cjs/forfeit.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildForfeitTx = buildForfeitTx;
+const btc_signer_1 = require("@scure/btc-signer");
+function buildForfeitTx({ connectorInput, vtxoInput, vtxoAmount, connectorAmount, feeAmount, vtxoPkScript, connectorPkScript, serverPkScript, txLocktime, }) {
+    const tx = new btc_signer_1.Transaction({
+        version: 2,
+        lockTime: txLocktime,
+    });
+    // Add connector input
+    tx.addInput({
+        txid: connectorInput.txid,
+        index: connectorInput.vout,
+        witnessUtxo: {
+            script: connectorPkScript,
+            amount: connectorAmount,
+        },
+        sequence: 0xffffffff,
+    });
+    // Add VTXO input
+    tx.addInput({
+        txid: vtxoInput.txid,
+        index: vtxoInput.vout,
+        witnessUtxo: {
+            script: vtxoPkScript,
+            amount: vtxoAmount,
+        },
+        sequence: txLocktime ? 0xfffffffe : 0xffffffff, // MAX_SEQUENCE - 1 if locktime is set
+        sighashType: btc_signer_1.SigHash.DEFAULT,
+    });
+    const amount = BigInt(vtxoAmount) + BigInt(connectorAmount) - BigInt(feeAmount);
+    // Add main output to server
+    tx.addOutput({
+        script: serverPkScript,
+        amount,
+    });
+    return tx;
+}

package/dist/cjs/identity/inMemoryKey.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryKey = void 0;
+const utils_1 = require("@scure/btc-signer/utils");
+const base_1 = require("@scure/base");
+const signingSession_1 = require("../tree/signingSession");
+const ZERO_32 = new Uint8Array(32).fill(0);
+class InMemoryKey {
+    constructor(key) {
+        this.key = key || (0, utils_1.randomPrivateKeyBytes)();
+    }
+    static fromPrivateKey(privateKey) {
+        return new InMemoryKey(privateKey);
+    }
+    static fromHex(privateKeyHex) {
+        return new InMemoryKey(base_1.hex.decode(privateKeyHex));
+    }
+    async sign(tx, inputIndexes) {
+        const txCpy = tx.clone();
+        if (!inputIndexes) {
+            if (!txCpy.sign(this.key, undefined, ZERO_32)) {
+                throw new Error("Failed to sign transaction");
+            }
+            return txCpy;
+        }
+        for (const inputIndex of inputIndexes) {
+            if (!txCpy.signIdx(this.key, inputIndex, undefined, ZERO_32)) {
+                throw new Error(`Failed to sign input #${inputIndex}`);
+            }
+        }
+        return txCpy;
+    }
+    xOnlyPublicKey() {
+        return (0, utils_1.pubSchnorr)(this.key);
+    }
+    signerSession() {
+        return signingSession_1.TreeSignerSession.random();
+    }
+}
+exports.InMemoryKey = InMemoryKey;

package/dist/cjs/identity/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDBVtxoRepository = exports.networks = exports.ArkNoteData = exports.ArkNote = exports.createVirtualTx = exports.CONDITION_WITNESS_KEY_PREFIX = exports.addConditionWitness = exports.CLTVMultisigTapscript = exports.ConditionMultisigTapscript = exports.ConditionCSVMultisigTapscript = exports.CSVMultisigTapscript = exports.MultisigTapscript = exports.decodeTapscript = exports.Response = exports.Request = exports.Worker = exports.TxType = exports.VHTLC = exports.VtxoScript = exports.DefaultVtxo = exports.ArkAddress = exports.RestArkProvider = exports.EsploraProvider = exports.ESPLORA_URL = exports.InMemoryKey = exports.ServiceWorkerWallet = exports.Wallet = void 0;
+const inMemoryKey_1 = require("./identity/inMemoryKey");
+Object.defineProperty(exports, "InMemoryKey", { enumerable: true, get: function () { return inMemoryKey_1.InMemoryKey; } });
+const address_1 = require("./script/address");
+Object.defineProperty(exports, "ArkAddress", { enumerable: true, get: function () { return address_1.ArkAddress; } });
+const vhtlc_1 = require("./script/vhtlc");
+Object.defineProperty(exports, "VHTLC", { enumerable: true, get: function () { return vhtlc_1.VHTLC; } });
+const default_1 = require("./script/default");
+Object.defineProperty(exports, "DefaultVtxo", { enumerable: true, get: function () { return default_1.DefaultVtxo; } });
+const base_1 = require("./script/base");
+Object.defineProperty(exports, "VtxoScript", { enumerable: true, get: function () { return base_1.VtxoScript; } });
+const index_1 = require("./wallet/index");
+Object.defineProperty(exports, "TxType", { enumerable: true, get: function () { return index_1.TxType; } });
+const wallet_1 = require("./wallet/wallet");
+Object.defineProperty(exports, "Wallet", { enumerable: true, get: function () { return wallet_1.Wallet; } });
+const wallet_2 = require("./wallet/serviceWorker/wallet");
+Object.defineProperty(exports, "ServiceWorkerWallet", { enumerable: true, get: function () { return wallet_2.ServiceWorkerWallet; } });
+const worker_1 = require("./wallet/serviceWorker/worker");
+Object.defineProperty(exports, "Worker", { enumerable: true, get: function () { return worker_1.Worker; } });
+const request_1 = require("./wallet/serviceWorker/request");
+Object.defineProperty(exports, "Request", { enumerable: true, get: function () { return request_1.Request; } });
+const response_1 = require("./wallet/serviceWorker/response");
+Object.defineProperty(exports, "Response", { enumerable: true, get: function () { return response_1.Response; } });
+const onchain_1 = require("./providers/onchain");
+Object.defineProperty(exports, "ESPLORA_URL", { enumerable: true, get: function () { return onchain_1.ESPLORA_URL; } });
+Object.defineProperty(exports, "EsploraProvider", { enumerable: true, get: function () { return onchain_1.EsploraProvider; } });
+const ark_1 = require("./providers/ark");
+Object.defineProperty(exports, "RestArkProvider", { enumerable: true, get: function () { return ark_1.RestArkProvider; } });
+const tapscript_1 = require("./script/tapscript");
+Object.defineProperty(exports, "CLTVMultisigTapscript", { enumerable: true, get: function () { return tapscript_1.CLTVMultisigTapscript; } });
+Object.defineProperty(exports, "ConditionCSVMultisigTapscript", { enumerable: true, get: function () { return tapscript_1.ConditionCSVMultisigTapscript; } });
+Object.defineProperty(exports, "ConditionMultisigTapscript", { enumerable: true, get: function () { return tapscript_1.ConditionMultisigTapscript; } });
+Object.defineProperty(exports, "CSVMultisigTapscript", { enumerable: true, get: function () { return tapscript_1.CSVMultisigTapscript; } });
+Object.defineProperty(exports, "decodeTapscript", { enumerable: true, get: function () { return tapscript_1.decodeTapscript; } });
+Object.defineProperty(exports, "MultisigTapscript", { enumerable: true, get: function () { return tapscript_1.MultisigTapscript; } });
+const psbt_1 = require("./utils/psbt");
+Object.defineProperty(exports, "addConditionWitness", { enumerable: true, get: function () { return psbt_1.addConditionWitness; } });
+Object.defineProperty(exports, "CONDITION_WITNESS_KEY_PREFIX", { enumerable: true, get: function () { return psbt_1.CONDITION_WITNESS_KEY_PREFIX; } });
+Object.defineProperty(exports, "createVirtualTx", { enumerable: true, get: function () { return psbt_1.createVirtualTx; } });
+const arknote_1 = require("./arknote");
+Object.defineProperty(exports, "ArkNote", { enumerable: true, get: function () { return arknote_1.ArkNote; } });
+Object.defineProperty(exports, "ArkNoteData", { enumerable: true, get: function () { return arknote_1.ArkNoteData; } });
+const idb_1 = require("./wallet/serviceWorker/db/vtxo/idb");
+Object.defineProperty(exports, "IndexedDBVtxoRepository", { enumerable: true, get: function () { return idb_1.IndexedDBVtxoRepository; } });
+const networks_1 = require("./networks");
+Object.defineProperty(exports, "networks", { enumerable: true, get: function () { return networks_1.networks; } });

package/dist/cjs/musig2/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateKeys = exports.sign = exports.PartialSig = exports.generateNonces = void 0;
+var nonces_1 = require("./nonces");
+Object.defineProperty(exports, "generateNonces", { enumerable: true, get: function () { return nonces_1.generateNonces; } });
+var sign_1 = require("./sign");
+Object.defineProperty(exports, "PartialSig", { enumerable: true, get: function () { return sign_1.PartialSig; } });
+Object.defineProperty(exports, "sign", { enumerable: true, get: function () { return sign_1.sign; } });
+var keys_1 = require("./keys");
+Object.defineProperty(exports, "aggregateKeys", { enumerable: true, get: function () { return keys_1.aggregateKeys; } });

package/dist/cjs/musig2/keys.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateKeys = aggregateKeys;
+const musig = __importStar(require("@scure/btc-signer/musig2"));
+const secp256k1_1 = require("@noble/curves/secp256k1");
+// Aggregates multiple public keys according to the MuSig2 algorithm
+function aggregateKeys(publicKeys, sort, options = {}) {
+    if (sort) {
+        publicKeys = musig.sortKeys(publicKeys);
+    }
+    const { aggPublicKey: preTweakedKey } = musig.keyAggregate(publicKeys);
+    if (!options.taprootTweak) {
+        return {
+            preTweakedKey: preTweakedKey.toRawBytes(true),
+            finalKey: preTweakedKey.toRawBytes(true),
+        };
+    }
+    const tweakBytes = secp256k1_1.schnorr.utils.taggedHash("TapTweak", preTweakedKey.toRawBytes(true).subarray(1), options.taprootTweak ?? new Uint8Array(0));
+    const { aggPublicKey: finalKey } = musig.keyAggregate(publicKeys, [tweakBytes], [true]);
+    return {
+        preTweakedKey: preTweakedKey.toRawBytes(true),
+        finalKey: finalKey.toRawBytes(true),
+    };
+}

package/dist/cjs/musig2/nonces.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateNonces = generateNonces;
+const musig = __importStar(require("@scure/btc-signer/musig2"));
+/**
+ * Generates a pair of public and secret nonces for MuSig2 signing
+ */
+function generateNonces(publicKey) {
+    const nonces = musig.nonceGen(publicKey);
+    return { secNonce: nonces.secret, pubNonce: nonces.public };
+}