@bsv/sdk 1.6.11 → 1.6.14

package/docs/tutorials/key-management.md

@@ -4,6 +4,7 @@
 **Prerequisites**: Completed "Your First BSV Transaction" tutorial, Node.js, basic TypeScript knowledge  
 
 ## Learning Goals
+
 - Generate and manage private/public keys
 - Understand ECDSA signatures
 - Create and verify digital signatures
@@ -373,7 +374,6 @@ Run the script:
 npx ts-node signatures-low-level.ts
 ```
 
-
 ### Key Benefits of `WalletClient` for Signatures
 
 1. **Enhanced Security**: Private keys never leave the wallet environment
@@ -383,7 +383,7 @@ npx ts-node signatures-low-level.ts
 
 ## Step 5: Practical Application: Signing Transactions with `WalletClient`
 
-Let's put our knowledge to practical use by creating and signing a Bitcoin transaction using the `WalletClient`. 
+Let's put our knowledge to practical use by creating and signing a Bitcoin transaction using the `WalletClient`.
 
 Create a file called `wallet-transaction-signing.ts`:
 
@@ -502,6 +502,7 @@ npx ts-node wallet-transaction-signing.ts
 ```
 
 This example demonstrates:
+
 1. Creating a transaction with inputs and outputs
 2. Getting the transaction hash that needs to be signed
 3. How the `WalletClient` would sign this hash securely
@@ -525,7 +526,8 @@ Congratulations! You've learned the fundamentals of key management and cryptogra
 
 These cryptographic concepts form the foundation of Bitcoin and blockchain technology. By understanding how keys and signatures work, you're well-equipped to build secure and robust applications using the BSV TypeScript SDK.
 
-For more advanced techniques like different signature hash types (SIGHASH flags), manual signature creation, and multi-signature transactions, refer to the [Advanced Transaction Signing guide](../guides/advanced-transaction-signing.md).
+For more advanced techniques like different signature hash types (SIGHASH flags), manual signature creation, and multi-signature transactions, refer to the following documents:
+
 - [Advanced Transaction Signing](../guides/advanced-transaction-signing.md) (How-To Guide)
 - [Transaction Signatures Reference](../reference/transaction-signatures.md) (Technical Reference)
 

package/docs/tutorials/protowallet-development.md

@@ -3,6 +3,7 @@
 **Duration**: 45 minutes  
 **Prerequisites**: Node.js, basic TypeScript knowledge, completed "Your First BSV Transaction" tutorial  
 **Learning Goals**:
+
 - Understand ProtoWallet's role in development and testing
 - Implement cryptographic operations without blockchain interaction
 - Use ProtoWallet for key derivation and signing
@@ -20,6 +21,7 @@ ProtoWallet is a lightweight wallet implementation designed for development and
 ## What You'll Build
 
 In this tutorial, you'll create a development toolkit using ProtoWallet that includes:
+
 - Key generation and management
 - Message signing and verification
 - Symmetric encryption/decryption
@@ -714,3 +716,28 @@ async function runTestSuite() {
 }
 
 runTestSuite().catch(console.error)
+```
+
+## Conclusion
+
+Congratulations! You've successfully built a comprehensive ProtoWallet development framework using the BSV TypeScript SDK. In this tutorial, you've learned how to create, test, and manage prototype wallet implementations for rapid development and testing.
+
+### Core Concepts Mastered
+
+1. **ProtoWallet Architecture**: Implemented lightweight wallet prototypes for development and testing
+2. **Key Management**: Created deterministic key generation and management systems
+3. **Cryptographic Operations**: Implemented signing, encryption, and HMAC operations
+4. **Protocol Integration**: Built protocol-specific wallet functionality with proper key derivation
+5. **Testing Framework**: Developed comprehensive testing utilities for wallet validation
+
+## Next Steps
+
+- Learn about [Development Wallet Setup](../guides/development-wallet-setup.md) for production-ready wallet implementation
+- Explore [Key Management](./key-management.md) for advanced cryptographic key handling
+- Understand [Security Best Practices](../guides/security-best-practices.md) for secure wallet development
+
+## Additional Resources
+
+- [Wallet API Reference](../reference/wallet.md)
+- [Key Management Concepts](../concepts/key-management.md)
+- [BSV Wallet Standards](https://projectbabbage.com/docs/guides/wallet/)

package/docs/tutorials/spv-merkle-proofs.md

@@ -5,6 +5,7 @@
 Simplified Payment Verification (SPV) is a method for verifying Bitcoin transactions without downloading the entire blockchain. Instead of storing all transaction data, SPV clients only need block headers and merkle proofs to verify that specific transactions are included in the blockchain.
 
 This tutorial covers:
+
 - Understanding SPV principles and merkle trees
 - Working with merkle proofs using the `MerklePath` class
 - Verifying transactions with the `Transaction.verify()` method
@@ -85,6 +86,7 @@ runMerkleExample().catch(console.error)
 The example above demonstrates the fundamental concepts using a simplified 2-transaction block. In real BSV blockchain scenarios, blocks contain hundreds or thousands of transactions, creating much deeper merkle trees.
 
 **Our Working Example:**
+
 - **Block Height**: 850000 (arbitrary example height)
 - **Transaction ID**: `ffeff11c25cde7c06d407490d81ef4d0db64aad6ab3d14393530701561a465ef` (from BSV Technical Standards)
 - **Sibling Hash**: `b9ef07a62553ef8b0898a79c291b92c60f7932260888bde0dab2dd2610d8668e` (from BSV Technical Standards)
@@ -92,6 +94,7 @@ The example above demonstrates the fundamental concepts using a simplified 2-tra
 
 **Real-World Complexity:**
 In actual BSV blocks, a transaction at index 12 (like in the BSV Technical Standards example) would require a merkle path with multiple levels:
+
 - **5 proof levels** for a block with ~32 transactions
 - **10 proof levels** for a block with ~1024 transactions  
 - **20 proof levels** for a block with ~1 million transactions
@@ -116,10 +119,12 @@ The SDK handles the complex offset calculations automatically when parsing from
 The BSV TypeScript SDK uses an internal object format for MerklePath construction, while the [BSV Technical Standards](https://tsc.bsvblockchain.org/standards/merkle-proof-standardised-format/) define a binary serialization format. The SDK handles the conversion between these formats internally.
 
 **Internal Format (used above):**
+
 - Array of levels, each containing leaf objects with `offset`, `hash`, `txid`, and `duplicate` properties
 - Direct construction allows for clear understanding of the merkle tree structure
 
 **Binary Format (from standards):**
+
 - Compact binary representation for network transmission and storage
 - Can be parsed using `MerklePath.fromHex()` when properly formatted
 
@@ -149,6 +154,7 @@ console.log('Merkle root matches expected:', merkleRoot === '6f0a2a566d54512576b
 The merkle root computation follows a specific mathematical process:
 
 **For a 2-transaction block (our example):**
+
 ```
 Level 0 (Leaves):    [Transaction A]  [Transaction B]
                            |              |
@@ -156,12 +162,14 @@ Level 1 (Root):           [Hash(A + B)]
 ```
 
 **Step-by-step process:**
+
 1. **Start with transaction IDs** (already hashed)
 2. **Concatenate them**: `ffeff11c...465ef` + `b9ef07a6...8668e`
 3. **Double SHA256**: `SHA256(SHA256(concatenated_data))`
 4. **Result**: The merkle root that represents the entire block
 
 **For larger blocks (e.g., 4 transactions):**
+
 ```
 Level 0:    [Tx A]  [Tx B]  [Tx C]  [Tx D]
               |       |       |       |
@@ -653,6 +661,7 @@ SPV and merkle proof verification enable lightweight Bitcoin clients to verify t
 - **BEEF**: Efficient SPV data structures
 
 Key takeaways:
+
 - SPV trades storage for bandwidth and computation
 - Merkle proofs provide cryptographic inclusion proofs
 - Chain trackers ensure merkle roots are valid
@@ -674,9 +683,3 @@ Understanding of `WalletClient` usage is also important for building robust appl
 | **Security** | High | High | High |
 
 The `WalletClient` approach is recommended for most applications, while SPV verification is valuable for specialized lightweight applications.
-
-```typescript
-// Example usage
-const walletClient = new WalletClient('main')
-const isValid = await walletClient.verifyTransaction(beefHex)
-console.log('Transaction valid:', isValid)

package/docs/tutorials/testnet-transactions-low-level.md

@@ -4,6 +4,7 @@
 **Prerequisites**: Completed "Your First BSV Transaction" tutorial, Node.js, basic TypeScript knowledge  
 
 ## Learning Goals
+
 - Set up a BSV testnet environment
 - Obtain and manage testnet coins
 - Create and broadcast real transactions on the testnet
@@ -136,14 +137,17 @@ After requesting coins from a faucet, you'll need to verify that you received th
 6. Click on the transaction ID (txid) to view the full transaction details
 
 7. On the transaction details page, find the following information:
-   - **Transaction ID (txid)**: This is the long hexadecimal string at the top of the page (e.g., `7f4e6ea49a847f557fccd9bf99d4a07ac103e5e8cb3464abb852af552516317e`)
-   - **Output Index**: In the "Outputs" section, find your address and note its index number (0-based). If your address is the first output, the index is 0.
-   - **Output Amount**: Note the amount sent to your address in this specific output. WhatsOnChain displays amounts in BSV (e.g., 0.00010000 BSV), but our code needs satoshis. To convert:
-     * 1 BSV = 100,000,000 satoshis
-     * Example: 0.00010000 BSV = 10,000 satoshis (multiply by 100,000,000)
-     * You can use a calculator or simply move the decimal point 8 places to the right
+
+    - **Transaction ID (txid)**: This is the long hexadecimal string at the top of the page (e.g., `7f4e6ea49a847f557fccd9bf99d4a07ac103e5e8cb3464abb852af552516317e`)
+    - **Output Index**: In the "Outputs" section, find your address and note its index number (0-based). If your address is the first output, the index is 0.
+    - **Output Amount**: Note the amount sent to your address in this specific output. WhatsOnChain displays amounts in BSV (e.g., 0.00010000 BSV), but our code needs satoshis. To convert:
+
+        - 1 BSV = 100,000,000 satoshis
+        - Example: 0.00010000 BSV = 10,000 satoshis (multiply by 100,000,000)
+        - You can use a calculator or simply move the decimal point 8 places to the right
 
 8. Write down or copy these three pieces of information:
+
    ```
    Transaction ID (txid): [your transaction id]
    Output Index: [your output index, usually 0]
@@ -165,9 +169,10 @@ In the same way, when creating a Bitcoin transaction:
 
 1. **You spend the entire UTXO** (even if you only want to send a portion of it)
 2. **You specify how to distribute those funds**:
-   - Some goes to the recipient (the payment)
-   - Some goes to the miners (the transaction fee)
-   - The remainder comes back to you (the change)
+
+    - Some goes to the recipient (the payment)
+    - Some goes to the miners (the transaction fee)
+    - The remainder comes back to you (the change)
 
 ### Prerequisites
 
@@ -190,21 +195,21 @@ import https from 'https'
 
 async function main() {
   try {
-    // 1. Set up your wallet
+    // Step 1: Set up your wallet
     const privateKey = PrivateKey.fromWif('your_testnet_private_key_here')
     const myAddress = privateKey.toAddress([0x6f]) // 0x6f is the testnet prefix
     const recipientAddress = 'testnet_address_to_send_coins_to'
 
-    // 2. Fetch the full transaction hex
+    // Step 2: Fetch the full transaction hex
     const txid = 'source_transaction_id_here'
     const response = await fetch(`https://api.whatsonchain.com/v1/bsv/test/tx/${txid}/hex`)
     const sourceTxHex = await response.text()
     console.log(`Retrieved transaction hex (first 50 chars): ${sourceTxHex.substring(0, 50)}...`)
     
-    // 3. Create a transaction
+    // Step 3: Create a transaction
     const tx = new Transaction()
     
-    // 4. Add the input
+    // Step 4: Add the input
     // For testnet, we need the hex of the transaction that contains our UTXO
     tx.addInput({
       sourceTransaction: Transaction.fromHex(sourceTxHex),
@@ -212,23 +217,23 @@ async function main() {
       unlockingScriptTemplate: new P2PKH().unlock(privateKey)
     })
     
-    // 5. Add the recipient output
+    // Step 5: Add the recipient output
     tx.addOutput({
       lockingScript: new P2PKH().lock(recipientAddress),
       satoshis: 100 // Amount to send (must be less than input amount)
     })
     
-    // 6. Add the change output back to our address
+    // Step 6: Add the change output back to our address
       tx.addOutput({
         lockingScript: new P2PKH().lock(myAddress),
       change: true // SDK will automatically calculate the change amount
       })
     
-    // 7. Calculate fee and sign the transaction
+    // Step 7: Calculate fee and sign the transaction
     await tx.fee()
     await tx.sign()
     
-    // 8. Broadcast the transaction to the testnet using ARC
+    // Step 8: Broadcast the transaction to the testnet using ARC
     // You need to provide your Taal API key here
     // Get it by signing up at https://console.taal.com
     const apiKey = 'your_taal_api_key_here' // Replace with your actual API key
@@ -246,7 +251,7 @@ async function main() {
     const result = await tx.broadcast(arc)
     console.log('ARC Response:', JSON.stringify(result, null, 2)) // Log the full response for debugging
     
-    // 9. Display the transaction ID
+    // Step 9: Display the transaction ID
     console.log(`Transaction ID: ${Buffer.from(tx.id()).toString('hex')}`)
     console.log(`View on explorer: https://test.whatsonchain.com/tx/${Buffer.from(tx.id()).toString('hex')}`)
     console.log('Transaction broadcast successfully!')
@@ -295,11 +300,13 @@ await tx.fee()
 ```
 
 This method automatically calculates the appropriate fee based on:
+
 - The size of your transaction (in bytes)
 - Current network fee rates
 - Number of inputs and outputs
 
 The `change: true` parameter in our change output works with the fee calculation to:
+
 1. Calculate the appropriate fee amount
 2. Subtract that fee from the total input amount
 3. Allocate the remaining balance to the change address

package/docs/tutorials/transaction-broadcasting.md

@@ -4,6 +4,7 @@
 **Prerequisites**: Completed "Your First BSV Transaction" tutorial, Node.js, basic TypeScript knowledge  
 
 ## Learning Goals
+
 - Understand how transaction broadcasting works in BSV
 - Learn the difference between `WalletClient` and direct broadcasting approaches
 - Configure broadcasting for testnet vs mainnet
@@ -32,11 +33,12 @@ Your App → WalletClient → Wallet → Mining Services → BSV Network
 ```
 
 The Wallet acts as a proxy that:
-- Manages your broadcasting preferences 
+
+- Manages your broadcasting preferences
 - Handles fallback logic between different services
 - Provides a consistent API regardless of the underlying service
 
-Due to its simplicity, this is the recommended approach. 
+Due to its simplicity, this is the recommended approach.
 
 ### Direct Broadcasting Flow
 
@@ -47,6 +49,7 @@ Your App → Custom Broadcaster → Mining Service API → BSV Network
 ```
 
 This approach gives you:
+
 - Full control over which service to use
 - Direct error handling and response processing
 - Ability to implement custom retry logic
@@ -56,7 +59,7 @@ Due to its complexity and need to handle the low-level details of the broadcasti
 
 ## Step 1: WalletClient Broadcasting
 
-Let's start with the `WalletClient` approach, which is the simplest for most applications. This is the same approach we have seen in the previous tutorials, where we used the `WalletClient` to create and broadcast transactions. 
+Let's start with the `WalletClient` approach, which is the simplest for most applications. This is the same approach we have seen in the previous tutorials, where we used the `WalletClient` to create and broadcast transactions.
 
 ### Basic WalletClient Setup
 
@@ -184,12 +187,11 @@ When you use `WalletClient`:
 5. **Response**: You receive either a transaction ID (success) or an error message
 
 The key advantage is that **you don't control the broadcasting directly** - the BRC-100 wallet handles it based on its configuration. This means:
+
 - ✅ Easy to use - no need to manage API keys or endpoints
 - ✅ Fallback logic built-in
 - ✅ User can configure preferred services through the wallet UI
 
-
-
 ## Step 2: Direct Broadcasting with Custom Broadcasters
 
 The `WalletClient` approach in step 1 is the recommended approach. However, if you need more control, you can broadcast transactions directly using custom broadcaster implementations. We will demonstrate the main broadcaster implementations in the SDK: ARC and WhatsOnChain.
@@ -203,6 +205,7 @@ The `WalletClient` approach in step 1 is the recommended approach. However, if y
 3. **Manual broadcast**: Use your chosen broadcaster to submit the transaction
 
 This approach is useful when you need to:
+
 - Use a specific broadcasting service (ARC, WhatsOnChain, etc.)
 - Implement custom retry logic or error handling
 - Broadcast to multiple services for redundancy
@@ -511,19 +514,19 @@ monitoringExample('your-transaction-id-here')
 In this tutorial, you learned about the two main approaches to transaction broadcasting in BSV:
 
 ### `WalletClient` Approach
+
 - ✅ **Simple**: Easy to use with BRC-100 wallets
 - ✅ **Managed**: Wallet handles service selection and fallbacks
 - ✅ **User Control**: Users can configure preferred services
 
-
 ### Direct Broadcasting Approach
+
 - ✅ **Full Control**: Choose exactly which service to use
 - ✅ **No Dependencies**: Works without external wallet software
 - ✅ **Custom Logic**: Implement your own retry and fallback logic
 - ✅ **Error Handling**: Direct access to service responses
 - ❌ **More Complex**: Requires more setup and configuration
 
-
 ### Next Steps
 
 - Experiment with different broadcaster configurations

package/docs/tutorials/transaction-types.md

@@ -4,6 +4,7 @@
 **Prerequisites**: Completed "Your First BSV Transaction" tutorial, Node.js, basic TypeScript knowledge  
 
 ## Learning Goals
+
 - Create transactions with multiple outputs
 - Add data to transactions
 - Work with different output types
@@ -314,10 +315,10 @@ In the BSV SDK, "baskets" are a powerful UTXO management concept that allows you
 
 Baskets help with:
 
-* **UTXO organization**: Group outputs for different purposes or applications
-* **Transaction optimization**: Control which UTXOs are used for specific transaction types
-* **Privacy enhancement**: Segregate UTXOs from different sources or uses
-* **Application-specific management**: Maintain dedicated UTXOs for particular applications
+- **UTXO organization**: Group outputs for different purposes or applications
+- **Transaction optimization**: Control which UTXOs are used for specific transaction types
+- **Privacy enhancement**: Segregate UTXOs from different sources or uses
+- **Application-specific management**: Maintain dedicated UTXOs for particular applications
 
 The `WalletClient` provides methods for working with baskets to give you fine-grained control over your UTXO management:
 

package/docs/tutorials/type-42.md

@@ -566,17 +566,3 @@ Type-42 enables sophisticated cryptographic protocols while maintaining the secu
 - [Elliptic Curve Fundamentals Tutorial](./elliptic-curve-fundamentals.md)
 - [BSV Type-42 Documentation](https://docs.bsvblockchain.org/guides/sdks/ts/low-level/type_42)
 - [Messages Reference](../reference/messages.md)
-
-## Integration with `WalletClient`
-
-For production applications, the `WalletClient` provides secure key management for Type-42 operations:
-
-```typescript
-// Usage example
-const walletClient = new WalletClient('https://api.bsvwallet.com/v1')
-const alice = walletClient.getPrivateKey('alice')
-const bob = walletClient.getPrivateKey('bob')
-const invoiceNumber = '2-secure-operation-001'
-
-const derivedKey = alice.deriveChild(bob.toPublicKey(), invoiceNumber)
-console.log('Derived key:', derivedKey.toHex().substring(0, 16) + '...')

package/docs/tutorials/uhrp-storage.md

@@ -3,6 +3,7 @@
 **Duration**: 75 minutes  
 **Prerequisites**: Node.js, basic TypeScript knowledge, understanding of decentralized storage and `WalletClient` usage  
 **Learning Goals**:
+
 - Understand UHRP (Universal Hash Resource Protocol)
 - Upload and download files using StorageUploader/StorageDownloader
 - Implement decentralized file management systems
@@ -15,17 +16,21 @@ UHRP (Universal Hash Resource Protocol) is a decentralized file storage system t
 ## Prerequisites
 
 ### For Upload Operations
+
 - **BRC-100 compliant wallet** (such as MetaNet Desktop Wallet) must be installed and running
-- **Wallet connection** accessible via JSON API (typically http://localhost:3321)
+- **Wallet connection** accessible via JSON API (typically <http://localhost:3321>)
 - **Sufficient wallet balance** for transaction fees and storage costs
 - **UHRP storage service** - This tutorial uses `https://nanostore.babbage.systems`
 
 ### For Download Operations Only
+
 - **No wallet connection required** - downloads work independently
 - **Network access** to resolve UHRP URLs via lookup services
 
 ### Service Availability
+
 **Important Note**: This tutorial uses `https://nanostore.babbage.systems`, which is a working UHRP storage service. The examples demonstrate correct SDK usage patterns and will work with:
+
 - A running BRC-100 compliant wallet (such as MetaNet Desktop Wallet)
 - Sufficient wallet balance for storage fees
 
@@ -328,6 +333,7 @@ async function demonstrateFileManager() {
 }
 
 demonstrateFileManager().catch(console.error)
+```
 
 ## Advanced Features
 
@@ -484,39 +490,49 @@ async function demonstrateBatchOperations() {
 }
 
 demonstrateBatchOperations().catch(console.error)
+```
 
 ## Troubleshooting
 
 ### Common Issues and Solutions
 
 #### "No wallet available" Error
+
 **Problem**: StorageUploader fails with "No wallet available over any communication substrate"
-**Solution**: 
+**Solution**:
+
 - Install and run a BRC-100 compliant wallet (e.g., MetaNet Desktop Wallet)
-- Ensure wallet is accessible at http://localhost:3321
+- Ensure wallet is accessible at <http://localhost:3321>
 - Verify wallet is fully synced and has sufficient balance
 
 #### "401 Unauthorized" Error
+
 **Problem**: Upload operations fail with HTTP 401 errors
 **Solution**:
+
 - Verify your wallet is properly authenticated
 - Check that the UHRP storage service is available
 - Ensure your wallet has sufficient balance for storage fees
 
 #### "Invalid parameter UHRP url" Error
+
 **Problem**: Download operations fail with invalid URL error
 **Solution**:
+
 - Verify the UHRP URL format (should start with `uhrp://`)
 - Check that the file hasn’t expired
 - Ensure network connectivity for UHRP lookup services
 
 #### Download Works but Upload Fails
+
 **Problem**: StorageDownloader works but StorageUploader fails
 **Solution**: This is expected behavior without a wallet connection. StorageDownloader works independently, while StorageUploader requires wallet authentication.
 
 #### Service Unavailable
+
 **Problem**: UHRP storage service returns errors or is unreachable
 **Solution**:
+
 - Try alternative UHRP storage services
 - Check service status and availability
 - Consider setting up your own UHRP storage infrastructure
@@ -524,21 +540,25 @@ demonstrateBatchOperations().catch(console.error)
 ## Best Practices
 
 ### 1. File Management
+
 - Use meaningful file names and metadata
 - Implement proper retention policies
 - Tag files for easy organization and retrieval
 
 ### 2. Error Handling
+
 - Always validate file integrity after download
 - Implement retry logic for network failures
 - Handle storage quota and payment requirements
 
 ### 3. Performance
+
 - Use batch operations for multiple files
 - Implement caching for frequently accessed files
 - Monitor file expiration and renewal needs
 
 ### 4. Security
+
 - Encrypt sensitive files before upload
 - Use authenticated storage endpoints
 - Validate file types and sizes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.6.11",
+  "version": "1.6.14",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/identity/README.md

@@ -90,4 +90,3 @@ export default IdentityDisplay
 ## License
 
 Open BSV License
-

package/src/primitives/__tests/SymmetricKey.test.ts

@@ -1,4 +1,5 @@
 import SymmetricKey from '../../primitives/SymmetricKey'
+import PrivateKey from '../../primitives/PrivateKey'
 import vectors from './SymmetricKey.vectors'
 
 const KEYS: SymmetricKey[] = [
@@ -58,4 +59,48 @@ describe('SymmetricKey', () => {
       expect(result).toEqual(Buffer.from(vector.plaintext).toString('hex'))
     })
   })
+
+  describe('31-byte and 32-byte key encryption', () => {
+    it('encrypts and decrypts with 31-byte key', () => {
+      // Use a private key that generates a 31-byte X coordinate
+      const privKey = PrivateKey.fromWif('L4B2postXdaP7TiUrUBYs53Fqzheu7WhSoQVPuY8qBdoBeEwbmZx')
+      const pubKey = privKey.toPublicKey()
+
+      expect(pubKey.x).toBeTruthy()
+      const keyArray = pubKey.x!.toArray()
+
+      // Verify this is indeed a 31-byte key
+      expect(keyArray.length).toBe(31)
+
+      const symKey = new SymmetricKey(keyArray)
+      const plaintext = 'test message'
+
+      // Test encryption and decryption
+      const ciphertext = symKey.encrypt(plaintext)
+      const decrypted = symKey.decrypt(ciphertext, 'utf8')
+
+      expect(decrypted).toBe(plaintext)
+    })
+
+    it('encrypts and decrypts with 32-byte key', () => {
+      // Use a private key that generates a 32-byte X coordinate
+      const privKey = PrivateKey.fromWif('KyLGEhYicSoGchHKmVC2fUx2MRrHzWqvwBFLLT4DZB93Nv5DxVR9')
+      const pubKey = privKey.toPublicKey()
+
+      expect(pubKey.x).toBeTruthy()
+      const keyArray = pubKey.x!.toArray()
+
+      // Verify this is indeed a 32-byte key
+      expect(keyArray.length).toBe(32)
+
+      const symKey = new SymmetricKey(keyArray)
+      const plaintext = 'test message'
+
+      // Test encryption and decryption
+      const ciphertext = symKey.encrypt(plaintext)
+      const decrypted = symKey.decrypt(ciphertext, 'utf8')
+
+      expect(decrypted).toBe(plaintext)
+    })
+  })
 })