@sequence0/sdk 1.0.3 → 1.1.2

package/README.md

@@ -30,6 +30,74 @@ const txHash = await wallet.sendTransaction({
 console.log('TX Hash:', txHash);
 ```
 
+## What's New in v1.1.0
+
+### Bitcoin Taproot (P2TR) Support
+
+Full Bitcoin Taproot transaction lifecycle: address derivation, UTXO management, transaction building, FROST Schnorr signing, and broadcast. FROST-secp256k1 produces BIP-340 compatible Schnorr signatures that are native to Taproot key-path spends.
+
+```typescript
+import { BitcoinTaprootAdapter } from '@sequence0/sdk';
+
+const btc = new BitcoinTaprootAdapter({ network: 'mainnet' });
+
+// Derive a Taproot address from a FROST group public key
+const addr = btc.deriveAddress('02abcdef...');
+console.log(addr.address); // bc1p...
+
+// Get balance and UTXOs
+const balance = await btc.getBalance('bc1p...');
+const utxos = await btc.getUTXOs('bc1p...');
+
+// Build a transaction
+const unsignedTx = await btc.buildTransaction(
+  { to: 'bc1p...recipient', amount: 50000, feeRate: 15 },
+  'bc1p...sender'
+);
+
+// Or use via the Wallet class for automatic signing
+const wallet = await s0.createWallet({ chain: 'bitcoin' });
+const txHash = await wallet.sendTransaction({
+  to: 'bc1p...recipient',
+  amount: 50000,
+  feeRate: 15,
+});
+```
+
+### ERC-4337 Account Abstraction
+
+Smart accounts backed by FROST threshold signing. Enables gas-sponsored transactions, batch calls, and programmable transaction validation.
+
+```typescript
+import { Sequence0Account } from '@sequence0/sdk';
+
+// Create a new AA wallet backed by FROST
+const account = await Sequence0Account.create({
+  threshold: 16,
+  committeeSize: 24,
+  chain: 'ethereum',
+  ownerPrivateKey: '0x...',
+  bundlerUrl: 'https://api.pimlico.io/v2/1/rpc?apikey=YOUR_KEY',
+});
+
+console.log('Smart Account:', account.getAddress());
+
+// Send a single transaction
+const txHash = await account.sendTransaction({
+  to: '0xRecipient',
+  value: BigInt('1000000000000000000'),
+});
+
+// Batch multiple calls
+const txHash2 = await account.sendBatchTransaction([
+  { to: '0xTokenA', data: '0xa9059cbb...' },
+  { to: '0xTokenB', data: '0xa9059cbb...' },
+]);
+
+// Sign messages
+const sig = await account.signMessage('Hello from Sequence0 AA!');
+```
+
 ## Features
 
 | Feature | Description |
@@ -37,22 +105,27 @@ console.log('TX Hash:', txHash);
 | **Multi-Chain** | Ethereum, Bitcoin, Solana, Polygon, Arbitrum, Base, and 60+ more (67 total) |
 | **Threshold Signing** | FROST (t-of-n) — no single point of failure |
 | **No Private Keys** | Keys are sharded across the agent network |
+| **Bitcoin Taproot** | Native P2TR support with BIP-340 Schnorr signatures |
+| **Account Abstraction** | ERC-4337 smart accounts with batched transactions |
 | **Real-Time Events** | WebSocket subscriptions for signing progress |
 | **Chain Adapters** | Auto-builds chain-native transactions |
 
 ## Supported Chains
 
 ### EVM (secp256k1)
-Ethereum, Polygon, Arbitrum, Optimism, Base, BSC, Avalanche
+Ethereum, Polygon, Arbitrum, Optimism, Base, BSC, Avalanche, and 40+ more
 
-### Non-EVM
-Bitcoin (Schnorr/Taproot), Solana (Ed25519)
+### Bitcoin (Taproot/Schnorr)
+Full P2TR lifecycle: address derivation, UTXO selection, transaction building, Schnorr signing, and broadcast via the `BitcoinTaprootAdapter`.
 
-> **Note:** Bitcoin, Dogecoin, and Litecoin support wallet creation and raw message signing via `sign()`. However, `sendTransaction()` is not yet supported for UTXO chains — full transaction serialization requires `bitcoinjs-lib`. Use `sign()` to get the Schnorr signature and construct the raw transaction externally.
+### Solana (Ed25519)
+Native SOL transfers with versioned transactions.
+
+> **Note:** Dogecoin and Litecoin support wallet creation and raw message signing via `sign()`. Full `sendTransaction()` support for these UTXO chains is coming soon.
 
 ## API Reference
 
-### `Sequence0` — Main Client
+### `Sequence0` -- Main Client
 
 ```typescript
 const s0 = new Sequence0({
@@ -105,7 +178,7 @@ const wallet = await s0.createWallet({
 | `subscribe(walletId?)` | `Promise<WsClient>` | Subscribe to real-time events |
 | `refreshKeys(walletId)` | `Promise<void>` | Proactive key rotation |
 
-### `Wallet` — Threshold Wallet
+### `Wallet` -- Threshold Wallet
 
 ```typescript
 const wallet = await s0.createWallet({
@@ -127,15 +200,69 @@ const wallet = await s0.createWallet({
 | `getBalance()` | `Promise<string>` | Get native token balance |
 | `info()` | `Record<string, unknown>` | Get wallet summary |
 
+### `BitcoinTaprootAdapter` -- Bitcoin P2TR
+
+```typescript
+import { BitcoinTaprootAdapter } from '@sequence0/sdk';
+
+const btc = new BitcoinTaprootAdapter({ network: 'mainnet' });
+```
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `deriveAddress(pubkeyHex)` | `TaprootAddressInfo` | Derive bc1p... address from FROST public key |
+| `getBalance(address)` | `Promise<string>` | Get balance in satoshis |
+| `getUTXOs(address)` | `Promise<TaprootUtxo[]>` | Fetch unspent outputs |
+| `getFeeRates()` | `Promise<FeeRateEstimate>` | Get recommended fee rates |
+| `buildTransaction(tx, from)` | `Promise<string>` | Build unsigned transaction |
+| `buildUnsignedTx(inputs, outputs, feeRate)` | `UnsignedTaprootTx` | Build with explicit inputs/outputs |
+| `attachSignature(unsignedTx, sig)` | `Promise<string>` | Attach FROST Schnorr signature |
+| `broadcast(signedTx)` | `Promise<string>` | Broadcast to Bitcoin network |
+| `getTransaction(txid)` | `Promise<any>` | Get transaction details |
+| `getBlockHeight()` | `Promise<number>` | Get current block height |
+
+### `Sequence0Account` -- ERC-4337 Smart Account
+
+```typescript
+import { Sequence0Account } from '@sequence0/sdk';
+
+const account = await Sequence0Account.create({
+  threshold: 16,
+  committeeSize: 24,
+  chain: 'ethereum',
+  ownerPrivateKey: '0x...',
+  bundlerUrl: 'https://bundler.example.com',
+});
+```
+
+| Method | Returns | Description |
+|--------|---------|-------------|
+| `Sequence0Account.create(options)` | `Promise<Sequence0Account>` | Create new AA wallet via DKG |
+| `Sequence0Account.fromExisting(walletId, pubkey, options)` | `Promise<Sequence0Account>` | Reconnect to existing wallet |
+| `getAddress()` | `string` | Get smart account address |
+| `sendTransaction(tx)` | `Promise<string>` | Build, sign, submit UserOperation |
+| `sendBatchTransaction(txs)` | `Promise<string>` | Batch multiple calls |
+| `signMessage(message)` | `Promise<string>` | Sign with EIP-191 prefix |
+| `buildUserOp(callData)` | `Promise<PackedUserOperation>` | Build unsigned UserOp |
+| `submitUserOp(userOp, bundlerUrl?)` | `Promise<string>` | Submit to bundler |
+| `estimateUserOpGas(userOp)` | `Promise<UserOperationGasEstimate>` | Estimate gas |
+| `waitForUserOp(hash, timeout?)` | `Promise<UserOperationReceipt>` | Wait for inclusion |
+| `getBalance()` | `Promise<string>` | Get native token balance |
+| `isDeployed()` | `boolean` | Check if deployed on-chain |
+
 ### Chain Adapters
 
 Use chain adapters directly for advanced control:
 
 ```typescript
-import { EthereumAdapter, BitcoinAdapter, SolanaAdapter } from '@sequence0/sdk';
+import {
+  EthereumAdapter,
+  BitcoinTaprootAdapter,
+  SolanaAdapter,
+} from '@sequence0/sdk';
 
 const eth = new EthereumAdapter('ethereum', 'https://eth.llamarpc.com');
-const btc = new BitcoinAdapter('mainnet');
+const btc = new BitcoinTaprootAdapter({ network: 'mainnet' });
 const sol = new SolanaAdapter('mainnet');
 ```
 
@@ -169,7 +296,7 @@ try {
 
 ## Any Language (REST API)
 
-This SDK wraps a plain **HTTP + JSON** REST API exposed by every agent node. You can integrate from **any language** — Python, Go, Rust, Java, etc. — by calling the API directly:
+This SDK wraps a plain **HTTP + JSON** REST API exposed by every agent node. You can integrate from **any language** -- Python, Go, Rust, Java, etc. -- by calling the API directly:
 
 ```bash
 # Health check
@@ -208,4 +335,4 @@ Signing fees are always paid in **ETH on the Sequence0 chain** (chain 800801). F
 
 ## License
 
-MIT © Sequence0 Network
+MIT (c) Sequence0 Network

package/dist/chains/bitcoin-taproot.d.ts

@@ -0,0 +1,371 @@
+/**
+ * Bitcoin Taproot (P2TR) Chain Adapter
+ *
+ * Full Taproot transaction lifecycle: address derivation, UTXO management,
+ * transaction building, FROST Schnorr signing, and broadcast.
+ *
+ * FROST-secp256k1 produces BIP-340 compatible Schnorr signatures that are
+ * NATIVE to Taproot key-path spends -- no signature format conversion needed.
+ *
+ * Key features:
+ * - **Real secp256k1 EC point arithmetic** for BIP-341 key tweaking
+ *   (lift_x, point_add, scalar_mul -- no external crypto dependencies)
+ * - **Per-input sighash computation** for multi-input transactions
+ *   (each input gets its own BIP-341 sighash for independent FROST signing)
+ * - **Full transaction serialization** with proper segwit witness structure
+ * - **Broadcast via Mempool.space API** (mainnet, testnet, signet, regtest)
+ *
+ * No external dependencies beyond Node.js crypto (SHA-256).
+ *
+ * @example
+ * ```typescript
+ * import { BitcoinTaprootAdapter } from '@sequence0/sdk';
+ *
+ * const btc = new BitcoinTaprootAdapter({ network: 'mainnet' });
+ *
+ * // Derive a Taproot address from a FROST group public key
+ * const addr = btc.deriveAddress('02abcdef...');
+ * console.log(addr.address); // bc1p...
+ *
+ * // Get balance and UTXOs
+ * const balance = await btc.getBalance('bc1p...');
+ * const utxos = await btc.getUTXOs('bc1p...');
+ *
+ * // Build, sign, and broadcast
+ * const unsignedTx = await btc.buildTransaction(
+ *   { to: 'bc1p...recipient', amount: 50000, feeRate: 15 },
+ *   'bc1p...sender'
+ * );
+ * // ... sign via FROST ...
+ * const txid = await btc.broadcast(signedTxHex);
+ * ```
+ */
+import { ChainAdapter, BtcTransaction } from '../core/types';
+/** Bitcoin network type */
+export type BitcoinNetwork = 'mainnet' | 'testnet' | 'signet' | 'regtest';
+/** UTXO from the indexer API */
+export interface TaprootUtxo {
+    /** Transaction hash (big-endian hex, 64 chars) */
+    txid: string;
+    /** Output index */
+    vout: number;
+    /** Value in satoshis */
+    value: number;
+    /** ScriptPubKey (hex-encoded) */
+    scriptPubkey: string;
+    /** Confirmation status */
+    status: {
+        confirmed: boolean;
+        blockHeight?: number;
+        blockHash?: string;
+        blockTime?: number;
+    };
+}
+/** Taproot address metadata returned by deriveAddress */
+export interface TaprootAddressInfo {
+    /** Bech32m-encoded Taproot address (bc1p... / tb1p...) */
+    address: string;
+    /** X-only internal public key (64-char hex) */
+    xOnlyPubkey: string;
+    /** X-only output key after tweak (64-char hex) */
+    outputKey: string;
+    /** ScriptPubKey (hex-encoded, OP_1 <32-byte output key>) */
+    scriptPubkey: string;
+    /**
+     * Taproot tweak scalar (64-char hex).
+     * This must be applied to the FROST group private key during signing:
+     *   tweaked_privkey = privkey + tweak (mod n)
+     * The FROST signing request should include this tweak so agents can
+     * adjust their secret shares before producing partial signatures.
+     */
+    tapTweak: string;
+    /** Network */
+    network: BitcoinNetwork;
+}
+/** Unsigned Taproot transaction ready for FROST signing */
+export interface UnsignedTaprootTx {
+    /**
+     * Sighash for the first input (32 bytes, hex-encoded).
+     * For single-input transactions this is all you need.
+     * For multi-input transactions, use `sighashes` instead.
+     */
+    sighash: string;
+    /**
+     * Per-input sighashes (32 bytes each, hex-encoded).
+     * Each input has its own BIP-341 sighash that must be independently
+     * signed via FROST. The same key signs all inputs, but each sighash
+     * includes the input index and produces a different message.
+     */
+    sighashes: string[];
+    /** Serialized unsigned transaction (hex-encoded) */
+    rawUnsigned: string;
+    /** Transaction inputs */
+    inputs: TaprootTxInput[];
+    /** Transaction outputs */
+    outputs: TaprootTxOutput[];
+    /** Estimated virtual size in vbytes */
+    estimatedVsize: number;
+    /** Estimated fee in satoshis */
+    estimatedFee: number;
+}
+/** Signed Taproot transaction */
+export interface SignedTaprootTx {
+    /** Serialized signed transaction (hex-encoded), ready for broadcast */
+    rawSigned: string;
+    /** Transaction ID */
+    txid: string;
+    /** Virtual size in vbytes */
+    vsize: number;
+}
+/** Transaction input (a UTXO being spent) */
+export interface TaprootTxInput {
+    txid: string;
+    vout: number;
+    value: number;
+    scriptPubkey: string;
+}
+/** Transaction output */
+export interface TaprootTxOutput {
+    address: string;
+    value: number;
+}
+/** Options for creating the adapter */
+export interface BitcoinTaprootOptions {
+    /** Bitcoin network (default: 'mainnet') */
+    network?: BitcoinNetwork;
+    /** Custom Mempool/Blockstream API URL for UTXO queries and broadcast */
+    apiUrl?: string;
+    /** Custom Electrum RPC URL (alternative to HTTP API) */
+    electrumUrl?: string;
+}
+/** Fee rate estimates from the mempool */
+export interface FeeRateEstimate {
+    /** Fee rate for next block confirmation (sat/vB) */
+    fastest: number;
+    /** Fee rate for confirmation within 30 minutes (sat/vB) */
+    halfHour: number;
+    /** Fee rate for confirmation within 1 hour (sat/vB) */
+    hour: number;
+    /** Fee rate for economy confirmation (sat/vB) */
+    economy: number;
+    /** Minimum relay fee (sat/vB) */
+    minimum: number;
+}
+export declare class BitcoinTaprootAdapter implements ChainAdapter {
+    private network;
+    private apiUrl;
+    constructor(options?: BitcoinTaprootOptions);
+    getRpcUrl(): string;
+    /**
+     * Derive a Taproot (P2TR) address from a FROST group public key.
+     *
+     * The FROST group verifying key is a secp256k1 point. For Taproot:
+     * 1. Extract the x-only public key (32 bytes)
+     * 2. Compute the Taproot tweak: t = hash_TapTweak(x_only_pubkey)
+     * 3. Compute the output key: Q = P + t*G
+     * 4. Encode as Bech32m with witness version 1
+     *
+     * @param groupPubkeyHex - Hex-encoded FROST group verifying key (33 bytes compressed or 32 bytes x-only)
+     * @returns TaprootAddressInfo with address, keys, and scriptPubkey
+     */
+    deriveAddress(groupPubkeyHex: string): TaprootAddressInfo;
+    /**
+     * Compute the Taproot tweak for a FROST group public key.
+     *
+     * The FROST signing protocol must apply this tweak to the group private key
+     * before signing. This ensures the Schnorr signature verifies against the
+     * tweaked output key (which is what the scriptPubKey commits to).
+     *
+     * The tweak scalar t = hash_TapTweak(internal_key) is returned as hex.
+     * During FROST signing, the group's secret share is tweaked:
+     *   tweaked_share = share + t  (mod n)
+     *
+     * @param groupPubkeyHex - Hex-encoded FROST group verifying key (33 or 32 bytes)
+     * @returns Hex-encoded 32-byte tweak scalar
+     */
+    getTapTweak(groupPubkeyHex: string): string;
+    /**
+     * Fetch unspent transaction outputs (UTXOs) for a Taproot address.
+     *
+     * @param address - Bech32m Taproot address (bc1p... / tb1p...)
+     * @returns Array of UTXOs sorted by value (largest first)
+     */
+    getUTXOs(address: string): Promise<TaprootUtxo[]>;
+    /**
+     * Get the balance of a Bitcoin address in satoshis.
+     * Includes both confirmed and unconfirmed (mempool) balances.
+     *
+     * @param address - Taproot address
+     * @returns Balance in satoshis as a string
+     */
+    getBalance(address: string): Promise<string>;
+    /**
+     * Get the confirmed balance only (excluding mempool transactions).
+     *
+     * @param address - Taproot address
+     * @returns Confirmed balance in satoshis as a string
+     */
+    getConfirmedBalance(address: string): Promise<string>;
+    /**
+     * Get recommended fee rates from the mempool.
+     *
+     * @returns Fee rate estimates in sat/vB
+     */
+    getFeeRates(): Promise<FeeRateEstimate>;
+    /**
+     * Estimate the fee for a transaction with the given number of inputs and outputs.
+     *
+     * @param inputCount - Number of Taproot inputs
+     * @param outputCount - Number of outputs (including change)
+     * @param feeRate - Fee rate in sat/vB
+     * @returns Estimated fee in satoshis
+     */
+    estimateFee(inputCount: number, outputCount: number, feeRate: number): number;
+    /**
+     * Build an unsigned Bitcoin Taproot transaction.
+     *
+     * Fetches UTXOs, selects inputs using a largest-first strategy,
+     * constructs outputs (recipient + change), computes the BIP-341
+     * sighash, and returns the serialized unsigned transaction.
+     *
+     * The returned sighash is what gets passed to the FROST signing
+     * protocol. The resulting 64-byte Schnorr signature is directly
+     * usable as the Taproot witness.
+     *
+     * @param tx - Transaction parameters (to, amount, feeRate)
+     * @param fromAddress - Sender's Taproot address
+     * @returns Hex-encoded unsigned transaction data (JSON-encoded internally)
+     */
+    buildTransaction(tx: BtcTransaction, fromAddress: string): Promise<string>;
+    /**
+     * Build an unsigned Taproot transaction with explicit control over inputs and outputs.
+     *
+     * For advanced usage when you want to manually select UTXOs and construct
+     * the transaction outputs.
+     *
+     * @param inputs - UTXOs to spend
+     * @param outputs - Transaction outputs
+     * @param xOnlyInternalKey - 32-byte x-only internal key (hex-encoded)
+     * @param feeRate - Fee rate in sat/vB
+     * @returns UnsignedTaprootTx ready for FROST signing
+     */
+    buildUnsignedTx(inputs: TaprootTxInput[], outputs: TaprootTxOutput[], feeRate: number): UnsignedTaprootTx;
+    /**
+     * Attach FROST Schnorr signature(s) to an unsigned Taproot transaction.
+     *
+     * The FROST signing protocol produces 64-byte BIP-340 Schnorr signatures
+     * (R_x || s) that are directly used as Taproot witness for key-path spends.
+     *
+     * For single-input transactions: pass a single 128-char hex signature.
+     * For multi-input transactions: pass signatures separated by commas, or
+     * a single signature that will be applied to all inputs (if all inputs
+     * share the same signing key and the caller signs each sighash separately).
+     *
+     * @param unsignedTxHex - Hex-encoded unsigned transaction (from buildTransaction)
+     * @param signatureHex - 64-byte FROST Schnorr signature(s). For multi-input
+     *   transactions, separate per-input signatures with commas.
+     * @returns Hex-encoded signed transaction ready for broadcast
+     */
+    attachSignature(unsignedTxHex: string, signatureHex: string): Promise<string>;
+    /**
+     * Attach FROST Schnorr signature(s) with full output (returns structured data).
+     *
+     * @param unsignedTx - The UnsignedTaprootTx from buildUnsignedTx
+     * @param signatureHex - 64-byte FROST Schnorr signature(s) (hex). For multi-input
+     *   transactions, pass an array of per-input signatures or a comma-separated string.
+     * @returns SignedTaprootTx with raw_signed, txid, and vsize
+     */
+    attachSignatureToTx(unsignedTx: UnsignedTaprootTx, signatureHex: string | string[]): SignedTaprootTx;
+    /**
+     * Parse signature hex into per-input signatures.
+     * Supports: single sig (applied to all inputs), comma-separated, or concatenated.
+     */
+    private parseSignatures;
+    /**
+     * Broadcast a signed Taproot transaction to the Bitcoin network.
+     *
+     * Accepts either a raw Bitcoin transaction hex or the hex-encoded JSON
+     * format from attachSignature().
+     *
+     * @param signedTx - Hex-encoded signed transaction
+     * @returns Transaction ID (txid)
+     */
+    broadcast(signedTx: string): Promise<string>;
+    /**
+     * Get transaction details by txid.
+     *
+     * @param txid - Transaction ID
+     * @returns Transaction data or null if not found
+     */
+    getTransaction(txid: string): Promise<any | null>;
+    /**
+     * Get the current block height.
+     */
+    getBlockHeight(): Promise<number>;
+    /**
+     * Check if an address is a valid Taproot (P2TR) address.
+     */
+    isTaprootAddress(address: string): boolean;
+    /**
+     * Convert a Taproot address to its scriptPubKey.
+     * P2TR scriptPubKey: OP_1 (0x51) + PUSH32 (0x20) + <32-byte witness program>
+     */
+    addressToScriptPubkey(address: string): string;
+    private selectUTXOs;
+    /**
+     * Serialize an unsigned Taproot transaction.
+     *
+     * Bitcoin transaction format (segwit):
+     * - Version (4 bytes LE)
+     * - Marker + Flag (00 01 for segwit)
+     * - Input count (varint)
+     * - Inputs (outpoint + empty scriptSig + sequence)
+     * - Output count (varint)
+     * - Outputs (value + scriptPubkey)
+     * - Witness (placeholder for signing)
+     * - Locktime (4 bytes LE)
+     */
+    private serializeUnsignedTx;
+    /**
+     * Serialize a signed Taproot transaction with per-input signatures.
+     *
+     * @param unsignedTx - The unsigned transaction data
+     * @param signatures - Array of per-input signature hex strings (128 chars each)
+     */
+    private serializeSignedTx;
+    /**
+     * Compute the BIP-341 Taproot sighash for key-path spend.
+     *
+     * The sighash message for SIGHASH_DEFAULT (0x00) includes:
+     * - Epoch (0x00)
+     * - Sighash type (0x00)
+     * - Transaction version (4 bytes LE)
+     * - Locktime (4 bytes LE)
+     * - SHA-256 of prevouts
+     * - SHA-256 of amounts
+     * - SHA-256 of scriptPubKeys
+     * - SHA-256 of sequences
+     * - SHA-256 of outputs
+     * - Spend type (0x00 for key-path, no annex)
+     * - Input index (4 bytes LE)
+     */
+    /**
+     * Compute all per-input BIP-341 sighashes for the transaction.
+     *
+     * Each input has its own sighash because the input_index field differs.
+     * The common transaction-level hashes (prevouts, amounts, scripts, sequences,
+     * outputs) are precomputed once and reused across all inputs.
+     *
+     * @returns Array of hex-encoded sighashes, one per input
+     */
+    private computeAllSighashes;
+}
+/**
+ * Create a Bitcoin Taproot adapter for mainnet.
+ */
+export declare function createBitcoinTaprootAdapter(options?: Omit<BitcoinTaprootOptions, 'network'>): BitcoinTaprootAdapter;
+/**
+ * Create a Bitcoin Taproot adapter for testnet.
+ */
+export declare function createBitcoinTestnetTaprootAdapter(options?: Omit<BitcoinTaprootOptions, 'network'>): BitcoinTaprootAdapter;
+//# sourceMappingURL=bitcoin-taproot.d.ts.map

package/dist/chains/bitcoin-taproot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitcoin-taproot.d.ts","sourceRoot":"","sources":["../../src/chains/bitcoin-taproot.ts"],"names":[],"mappings":"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"}