@bsv/sdk 1.6.11 → 1.6.14

package/docs/tutorials/advanced-transaction.md

@@ -2,6 +2,7 @@
 **Prerequisites**: Completed "Transaction Types and Data" tutorial, Node.js, basic TypeScript knowledge  
 
 ## Learning Goals
+
 - Master multi-input/multi-output transaction construction
 - Implement advanced fee calculation and optimization strategies
 - Handle change outputs efficiently
@@ -449,7 +450,6 @@ async function createTransactionChain() {
 createTransactionChain().catch(console.error)
 ```
 
-
 ## Performance Optimization Strategies
 
 For high-throughput applications, consider these optimization techniques:
@@ -546,8 +546,6 @@ async function optimizedTransactionPatterns() {
 optimizedTransactionPatterns().catch(console.error)
 ```
 
-
-
 ## Conclusion
 
 You've now mastered advanced transaction construction with the BSV TypeScript SDK's `WalletClient`. You can:
@@ -567,7 +565,6 @@ These techniques enable you to build production-ready applications that efficien
 
 - Advanced transaction construction requires robust error handling for production applications. For comprehensive coverage of error handling patterns, retry mechanisms, and recovery strategies, see the dedicated [Error Handling Tutorial](./error-handling.md).
 
-
 ## Additional Resources
 
 - [Wallet Reference](../reference/wallet.md)

package/docs/tutorials/aes-encryption.md

@@ -17,6 +17,7 @@
 Advanced Encryption Standard (AES) is a symmetric encryption algorithm where the same key is used for both encryption and decryption. The BSV TypeScript SDK provides the `SymmetricKey` class that implements AES-GCM (Galois/Counter Mode), which provides both confidentiality and authenticity.
 
 AES-GCM offers several advantages:
+
 - **Confidentiality**: Data is encrypted and unreadable without the key
 - **Authenticity**: Built-in authentication prevents tampering
 - **Performance**: Fast encryption/decryption operations
@@ -127,11 +128,13 @@ console.log('SDK decrypted from hex:', sdkDecryptedMessage)
 The `enc` parameter in the SDK's `encrypt()` and `decrypt()` methods can be confusing. Here's how it actually works:
 
 **In `encrypt(data, enc)`:**
+
 - `enc` specifies how to **interpret the input data**
 - `enc: 'hex'` means the input data is a hex string that should be converted to bytes
 - The output format is determined by the `enc` parameter (hex string if `enc: 'hex'`, byte array otherwise)
 
 **In `decrypt(data, enc)`:**
+
 - `enc` specifies the **output format**
 - `enc: 'hex'` returns the decrypted data as a hex string
 - `enc: 'utf8'` returns the decrypted data as a UTF-8 string
@@ -153,7 +156,6 @@ const finalMessage = Buffer.from(decryptedHex, 'hex').toString('utf8')
 console.log('Final message:', finalMessage) // 'Hello, World!'
 ```
 
-
 ## Complete Encryption Example
 
 Here's a comprehensive example demonstrating the full encryption workflow:

package/docs/tutorials/authfetch-tutorial.md

@@ -3,6 +3,7 @@
 **Duration**: 60 minutes  
 **Prerequisites**: Node.js, basic TypeScript knowledge, understanding of HTTP and authentication  
 **Learning Goals**:
+
 - Understand BRC-103/104 authentication protocols
 - Implement authenticated HTTP requests with AuthFetch
 - Handle peer-to-peer authentication and certificate exchange
@@ -11,6 +12,7 @@
 ## When to Use AuthFetch
 
 **Use AuthFetch when you need:**
+
 - BRC-103/104 cryptographic authentication
 - Wallet-signed HTTP requests for identity verification
 - Certificate-based peer authentication
@@ -18,6 +20,7 @@
 - APIs that require cryptographic proof of identity
 
 **For general HTTP client configuration, use [HTTP Client Configuration Guide](../guides/http-client-configuration.md) instead:**
+
 - Custom HTTP client setup (Axios, fetch, etc.)
 - Transaction broadcasting via ARC endpoints
 - Environment-specific configuration (timeouts, retries)
@@ -39,6 +42,7 @@ AuthFetch is a specialized HTTP client that implements BRC-103 and BRC-104 authe
 ## What You'll Build
 
 In this tutorial, you'll create:
+
 - Basic authenticated HTTP client
 - Peer-to-peer communication system
 - Certificate exchange mechanism
@@ -955,3 +959,28 @@ async function demonstrateErrorHandling() {
 }
 
 demonstrateErrorHandling().catch(console.error)
+```
+
+## Conclusion
+
+Congratulations! You've successfully implemented a comprehensive authenticated communication system using the BSV TypeScript SDK. In this tutorial, you've learned how to:
+
+### Core Concepts Mastered
+
+1. **AuthFetch Integration**: Implemented authentication using identity-based signing
+2. **Certificate Management**: Created and managed identity certificates for secure communication
+3. **Request Signing**: Automatically signed requests with proper identity validation
+4. **Error Handling**: Built robust error handling for authentication failures
+5. **Network Resilience**: Implemented retry logic and connectivity testing
+
+## Next Steps
+
+- Learn about [Identity Management](./identity-management.md) for advanced identity workflows
+- Explore [Authenticated API Communication](../guides/authenticated-api-communication.md) for server-side implementation
+- Understand [Security Best Practices](../guides/security-best-practices.md) for production deployments
+
+## Additional Resources
+
+- [AuthFetch API Reference](../reference/auth.md)
+- [Identity Client Documentation](../reference/identity.md)
+- [BSV Identity Protocols](https://projectbabbage.com/docs/guides/identity)

package/docs/tutorials/ecdh-key-exchange.md

@@ -4,6 +4,7 @@
 **Prerequisites**: Basic TypeScript knowledge, [Elliptic Curve Fundamentals](./elliptic-curve-fundamentals.md) tutorial completed
 
 ## Learning Goals
+
 - Understand Elliptic Curve Diffie-Hellman (ECDH) key exchange principles
 - Implement secure key exchange using the BSV TypeScript SDK
 - Create shared secrets for encrypted communication
@@ -15,6 +16,7 @@
 Elliptic Curve Diffie-Hellman (ECDH) is a key agreement protocol that allows two parties to establish a shared secret over an unsecured communication channel. Unlike traditional encryption where you need to share a secret key beforehand, ECDH allows two parties who have never met to create a shared secret that only they know.
 
 The mathematical foundation of ECDH relies on the commutative property of elliptic curve point multiplication:
+
 - Alice computes: `(Alice's private key) × (Bob's public key)`
 - Bob computes: `(Bob's private key) × (Alice's public key)`
 - Both arrive at the same shared secret point

package/docs/tutorials/elliptic-curve-fundamentals.md

@@ -6,6 +6,7 @@
 ## Learning Goals
 
 By the end of this tutorial, you will:
+
 - Understand the mathematical foundations of elliptic curves used in Bitcoin
 - Work with BigNumber for handling large integers in cryptographic operations
 - Manipulate elliptic curve points using the SDK
@@ -590,6 +591,7 @@ In this tutorial, you've learned:
 ### Next Steps
 
 Now that you understand elliptic curve fundamentals, you can explore:
+
 - **[ECDH Key Exchange](./ecdh-key-exchange.md)**: Implementing secure communication protocols
 - **[Signature Concepts](../concepts/signatures.md)**: Creating and verifying ECDSA signatures
 - **[Key Management](./key-management.md)**: Generating multiple keys from a master key
@@ -600,4 +602,5 @@ Understanding of `WalletClient` usage (for practical applications)
 While the `WalletClient` abstracts these operations for convenience, understanding the underlying mathematics helps you make informed decisions about security and implementation.
 
 ## Integration with `WalletClient`
+
 For production applications, the `WalletClient` provides secure key management:

package/docs/tutorials/error-handling.md

@@ -439,6 +439,7 @@ robustTransactionCreation().catch(console.error)
 ```
 
 This example demonstrates:
+
 - **Specific error pattern matching** for different error types
 - **Dynamic amount adjustment** for insufficient funds
 - **Wallet synchronization handling** with appropriate delays

package/docs/tutorials/first-transaction-low-level.md

@@ -4,6 +4,7 @@
 **Prerequisites**: Node.js, basic TypeScript knowledge  
 
 ## Learning Goals
+
 - Install and configure the BSV TypeScript SDK
 - Create a simple P2PKH transaction
 - Understand BSV transaction anatomy

package/docs/tutorials/first-transaction.md

@@ -4,6 +4,7 @@
 **Prerequisites**: Node.js, basic TypeScript knowledge  
 
 ## Learning Goals
+
 - Install and configure the BSV TypeScript SDK
 - Create a simple transaction using `WalletClient` interface on the mainnet network. This approach makes it easy to build transactions by abstracting away many of the low-level details. By the end, you'll understand the basic components of a BSV transaction and how to construct, sign, and broadcast one on the BSV blockchain.
 
@@ -15,7 +16,7 @@ In this tutorial, you'll learn how to create your first Bitcoin SV transactions
 
 > **💡 Try It Interactive**: Want to experiment with the code examples from this tutorial? Check out our [Interactive BSV Coding Environment](https://fast.brc.dev/) where you can run SDK code directly in your browser without any setup!
 
-## Precondition 
+## Precondition
 
 Install a BRC-100 compliant wallet such as the [MetaNet Desktop Wallet](https://metanet.bsvb.tech/). When you install it, you'll receive a small amount of funds to play with.
 
@@ -118,8 +119,8 @@ Run it as follows:
 npx ts-node step1-simple-transaction.ts
 ```
 
-
 **What's happening here:**
+
 - We connect to your BRC-100 wallet (like MetaNet Desktop)
 - Create a transaction with one output containing "Hello BSV!" data
 - The wallet automatically handles inputs, change, and fees
@@ -161,7 +162,6 @@ async function createToken() {
 createToken().catch(console.error)
 ```
 
-
 Run it as follows:
 
 ```bash
@@ -169,8 +169,8 @@ Run it as follows:
 npx ts-node step2-create-token.ts
 ```
 
-
 **What's happening here:**
+
 - We create a minimal token (1 satoshi with OP_NOP script)
 - Store it in a wallet basket called 'my-tokens' for organization
 - This creates a spendable output we can use later
@@ -225,7 +225,6 @@ async function spendToken() {
 spendToken().catch(console.error)
 ```
 
-
 Run it as follows:
 
 ```bash
@@ -233,15 +232,13 @@ Run it as follows:
 npx ts-node step3-spend-token.ts
 ```
 
-
 **What's happening here:**
+
 - We list tokens from our 'my-tokens' basket
 - Spend the first available token by providing its outpoint
 - Create a new output with proof that we spent the token
 - The BEEF (Blockchain Exchange Format) provides the transaction history
 
-
-
 ## What You've Learned
 
 Congratulations! You've successfully created your first BSV transactions. Here's what you accomplished:

package/docs/tutorials/hashes-and-hmacs.md

@@ -6,6 +6,7 @@
 ## Learning Goals
 
 By completing this tutorial, you will:
+
 - Understand cryptographic hash functions and their properties
 - Master the Hash module classes and helper functions in the BSV TypeScript SDK
 - Implement various hash algorithms (SHA-256, SHA-512, SHA-1, RIPEMD-160)
@@ -34,6 +35,7 @@ import { Hash, Utils } from '@bsv/sdk'
 ```
 
 The `Hash` module contains:
+
 - Hash function classes (`SHA256`, `SHA512`, `SHA1`, `RIPEMD160`)
 - HMAC classes (`SHA256HMAC`, `SHA512HMAC`, `SHA1HMAC`)
 - Helper functions (`sha256`, `sha512`, `hash256`, `hash160`, `sha256hmac`)
@@ -758,6 +760,7 @@ function efficientHashing(messages: string[]): string[] {
 This tutorial covered comprehensive usage of cryptographic hashing and HMACs in the BSV TypeScript SDK:
 
 **Key Concepts Learned:**
+
 - Hash function fundamentals and Bitcoin-specific applications
 - SHA-256, SHA-512, SHA-1, and RIPEMD-160 implementation
 - HMAC creation and verification for message authentication
@@ -766,6 +769,7 @@ This tutorial covered comprehensive usage of cryptographic hashing and HMACs in
 - Security best practices for key management and validation
 
 **Practical Applications:**
+
 - Data integrity verification systems
 - Message authentication protocols
 - Transaction metadata protection
@@ -773,6 +777,7 @@ This tutorial covered comprehensive usage of cryptographic hashing and HMACs in
 - Secure key derivation patterns
 
 **Security Considerations:**
+
 - Proper input validation and error handling
 - Constant-time comparison to prevent timing attacks
 - Secure key generation and storage practices
@@ -781,34 +786,3 @@ This tutorial covered comprehensive usage of cryptographic hashing and HMACs in
 The Hash module in the BSV TypeScript SDK provides both low-level control through classes and high-level convenience through helper functions, enabling developers to implement robust cryptographic solutions for Bitcoin applications.
 
 Continue exploring advanced cryptographic topics with the [ECDH Key Exchange](./ecdh-key-exchange.md) and [AES Symmetric Encryption](./aes-encryption.md) tutorials to build complete cryptographic systems.
-
-```typescript
-// Example usage
-const metadataProtector = new SecureTransactionMetadata('user_password_123')
-
-const originalMetadata: TransactionMetadata = {
-  description: 'Payment for services',
-  category: 'business',
-  tags: ['consulting', 'development'],
-  amount: 100
-}
-
-const protectedData = metadataProtector.protectMetadata(originalMetadata)
-console.log('Protected metadata:', protectedData)
-
-const extracted = metadataProtector.verifyAndExtract(protectedData)
-console.log('Extracted metadata:', extracted)
-console.log('Metadata matches:', JSON.stringify(originalMetadata) === JSON.stringify(extracted))
-```
-
-Follow these instructions to make the following change to my code document.
-
-Instruction: Update all occurrences of "WalletClient" to be formatted as inline code `WalletClient`, except in headers and when it appears in actual code blocks.
-
-Code Edit:
-```typescript
-// Understanding of `WalletClient` usage (for practical applications)
-While the `WalletClient` provides high-level transaction operations, understanding hashes and HMACs enables you to build sophisticated cryptographic applications and secure data verification systems.
-
-## Integration with `WalletClient`
-For production applications, the `WalletClient` provides secure hash operations:

package/docs/tutorials/identity-management.md

@@ -3,6 +3,7 @@
 **Duration**: 90 minutes  
 **Prerequisites**: Node.js, basic TypeScript knowledge, understanding of digital certificates  
 **Learning Goals**:
+
 - Understand decentralized identity concepts
 - Use IdentityClient for certificate management
 - Implement identity verification systems
@@ -700,3 +701,29 @@ async function demonstrateVerificationService() {
 }
 
 demonstrateVerificationService().catch(console.error)
+```
+
+## Conclusion
+
+Congratulations! You've successfully built a comprehensive identity management system using the BSV TypeScript SDK. In this tutorial, you've learned how to create, manage, and verify digital identities on the BSV blockchain.
+
+### Core Concepts Mastered
+
+1. **Identity Creation**: Generated unique BSV identities using cryptographic key pairs
+2. **Certificate Management**: Created and managed identity certificates for enhanced trust
+3. **Identity Resolution**: Implemented identity lookup and verification services
+4. **Trust Scoring**: Built systems to calculate and evaluate identity trustworthiness
+5. **Batch Processing**: Optimized identity operations for handling multiple identities efficiently
+
+## Next Steps
+
+- Learn about [AuthFetch Integration](./authfetch-tutorial.md) to use identities for API authentication
+- Explore [Identity Verification Systems](../guides/identity-verification-systems.md) for advanced verification patterns
+- Understand [Security Best Practices](../guides/security-best-practices.md) for production identity systems
+
+## Additional Resources
+
+- [Identity Client API Reference](../reference/identity.md)
+- [Certificate Management Guide](../concepts/identity-certificates.md)
+- [Decentralized Identity Concepts](../concepts/decentralized-identity.md)
+- [BSV Identity Standards](https://projectbabbage.com/docs/guides/identity)

package/docs/tutorials/index.md

@@ -9,174 +9,211 @@ Before diving into the tutorials, you can experiment with many of these concepts
 ## Getting Started Track
 
 ### [Your First BSV Transaction](./first-transaction.md)
+
 - **Duration**: 30 minutes
 - **Prerequisites**: Node.js, basic TypeScript knowledge
 - **Learning Goals**:
-  - Install and configure the SDK
-  - Create a simple P2PKH transaction
-  - Understand BSV transaction anatomy
+
+    - Install and configure the SDK
+    - Create a simple P2PKH transaction
+    - Understand BSV transaction anatomy
 
 ### [Transaction Types and Data](./transaction-types.md)
+
 - **Duration**: 30 minutes
 - **Prerequisites**: Completed "Your First BSV Transaction" tutorial
 - **Learning Goals**:
-  - Create transactions with multiple outputs
-  - Add data to transactions
-  - Work with different output types
-  - Use advanced `WalletClient` features
+
+    - Create transactions with multiple outputs
+    - Add data to transactions
+    - Work with different output types
+    - Use advanced `WalletClient` features
 
 ### [Key Management and Cryptography](./key-management.md)
+
 - **Duration**: 45 minutes
 - **Prerequisites**: Completed "Your First BSV Transaction" tutorial
 - **Learning Goals**:
-  - Generate and manage private/public keys
-  - Understand ECDSA signatures
-  - Create and verify digital signatures
+
+    - Generate and manage private/public keys
+    - Understand ECDSA signatures
+    - Create and verify digital signatures
 
 ### [Transaction Broadcasting](./transaction-broadcasting.md)
+
 - **Duration**: 25 minutes
 - **Prerequisites**: Completed "Your First BSV Transaction" tutorial, Node.js, basic TypeScript knowledge
 - **Learning Goals**:
-  - Understand `WalletClient` vs direct broadcasting approaches
-  - Configure broadcasting for testnet vs mainnet
-  - Implement custom broadcasters (ARC, WhatsOnChain)
-  - Handle broadcasting errors and implement retry logic
-  - Monitor and verify transaction acceptance
+
+    - Understand `WalletClient` vs direct broadcasting approaches
+    - Configure broadcasting for testnet vs mainnet
+    - Implement custom broadcasters (ARC, WhatsOnChain)
+    - Handle broadcasting errors and implement retry logic
+    - Monitor and verify transaction acceptance
 
 ## Intermediate Development Track
 
 ### [Working with ProtoWallet for Development](./protowallet-development.md)
+
 - **Duration**: 45 minutes
 - **Prerequisites**: Basic TypeScript knowledge, understanding of cryptographic concepts
 - **Learning Goals**:
-  - Create and configure ProtoWallet instances
-  - Perform key derivation and management
-  - Implement signing, encryption, and HMAC operations
-  - Build development toolkits and testing environments
+
+    - Create and configure ProtoWallet instances
+    - Perform key derivation and management
+    - Implement signing, encryption, and HMAC operations
+    - Build development toolkits and testing environments
 
 ### [Authenticated HTTP Requests with AuthFetch](./authfetch-tutorial.md)
+
 - **Duration**: 60 minutes
 - **Prerequisites**: Understanding of HTTP protocols, basic cryptography knowledge
 - **Learning Goals**:
-  - Implement BRC-103/104 authentication protocols
-  - Set up certificate exchange and peer authentication
-  - Build secure API clients with cryptographic request signing
-  - Handle authentication errors and implement retry logic
+
+    - Implement BRC-103/104 authentication protocols
+    - Set up certificate exchange and peer authentication
+    - Build secure API clients with cryptographic request signing
+    - Handle authentication errors and implement retry logic
 
 ### [Decentralized File Storage with UHRP](./uhrp-storage.md)
+
 - **Duration**: 75 minutes
 - **Prerequisites**: Understanding of content-addressed storage concepts
 - **Learning Goals**:
-  - Upload and download files using UHRP protocol
-  - Implement file integrity verification
-  - Manage file retention and renewal
-  - Build batch file operations and management systems
+
+    - Upload and download files using UHRP protocol
+    - Implement file integrity verification
+    - Manage file retention and renewal
+    - Build batch file operations and management systems
 
 ### [Identity Management and Certificates](./identity-management.md)
+
 - **Duration**: 90 minutes
 - **Prerequisites**: Understanding of PKI and certificate concepts
 - **Learning Goals**:
-  - Work with decentralized identity systems
-  - Resolve identities by keys and attributes
-  - Manage identity certificates and verification
-  - Build identity-based authentication services
+
+    - Work with decentralized identity systems
+    - Resolve identities by keys and attributes
+    - Manage identity certificates and verification
+    - Build identity-based authentication services
 
 ### [Advanced Transaction Construction](./advanced-transaction.md)
+
 - **Duration**: 75 minutes
 - **Learning Goals**:
-  - Multi-input/multi-output transactions
-  - Fee calculation and optimization
-  - Change output handling
+
+    - Multi-input/multi-output transactions
+    - Fee calculation and optimization
+    - Change output handling
 
 ### [Script Construction and Custom Logic](./script-construction.md)
+
 - **Duration**: 90 minutes
 - **Learning Goals**:
-  - Understand Bitcoin Script basics
-  - Create custom locking scripts
-  - Implement unlocking logic
+
+    - Understand Bitcoin Script basics
+    - Create custom locking scripts
+    - Implement unlocking logic
 
 ### [SPV and Merkle Proof Verification](./spv-merkle-proofs.md)
+
 - **Duration**: 90 minutes
 - **Learning Goals**:
-  - Understand SPV principles
-  - Verify Merkle proofs
-  - Implement lightweight verification
+
+    - Understand SPV principles
+    - Verify Merkle proofs
+    - Implement lightweight verification
 
 ### [Error Handling and Edge Cases](./error-handling.md)
+
 - **Duration**: 60 minutes
 - **Learning Goals**:
-  - Robust error handling patterns
-  - Network failure recovery
-  - Transaction validation edge cases
+
+    - Robust error handling patterns
+    - Network failure recovery
+    - Transaction validation edge cases
 
 ## Low-Level Cryptography Track
 
 ### [Elliptic Curve Fundamentals: Numbers & Points](./elliptic-curve-fundamentals.md)
+
 - **Duration**: 90 minutes
 - **Learning Goals**:
-  - Understand the mathematical foundations of elliptic curves
-  - Work with BigInteger numbers in the SDK
-  - Manipulate elliptic curve points
-  - Implement point addition and scalar multiplication
+
+    - Understand the mathematical foundations of elliptic curves
+    - Work with BigInteger numbers in the SDK
+    - Manipulate elliptic curve points
+    - Implement point addition and scalar multiplication
 
 ### [ECDH Key Exchange](./ecdh-key-exchange.md)
+
 - **Duration**: 75 minutes
 - **Learning Goals**:
-  - Understand Elliptic Curve Diffie-Hellman (ECDH) key exchange principles
-  - Implement secure key exchange using the SDK
-  - Create shared secrets for encrypted communication
-  - Apply ECDH in practical Bitcoin applications
+
+    - Understand Elliptic Curve Diffie-Hellman (ECDH) key exchange principles
+    - Implement secure key exchange using the SDK
+    - Create shared secrets for encrypted communication
+    - Apply ECDH in practical Bitcoin applications
 
 ### [AES Symmetric Encryption](./aes-encryption.md)
+
 - **Duration**: 60 minutes
 - **Learning Goals**:
-  - Understand AES-GCM symmetric encryption principles
-  - Use the `SymmetricKey` class for encryption and decryption
-  - Implement secure key generation and management
-  - Apply AES encryption in practical Bitcoin applications
-  - Combine AES with ECDH for secure communication
-  - Handle different data formats and encoding
+
+    - Understand AES-GCM symmetric encryption principles
+    - Use the `SymmetricKey` class for encryption and decryption
+    - Implement secure key generation and management
+    - Apply AES encryption in practical Bitcoin applications
+    - Combine AES with ECDH for secure communication
+    - Handle different data formats and encoding
 
 ### [Hashes and HMACs](./hashes-and-hmacs.md)
+
 - **Duration**: 75 minutes
 - **Learning Goals**:
-  - Understand cryptographic hash functions and their properties
-  - Master the Hash module classes and helper functions in the BSV TypeScript SDK
-  - Implement various hash algorithms (SHA-256, SHA-512, SHA-1, RIPEMD-160)
-  - Create and verify HMACs for message authentication
-  - Apply Bitcoin-specific hashing patterns (hash256, hash160)
-  - Build practical applications using hashing for data integrity and authentication
-  - Understand performance considerations and security best practices
+
+    - Understand cryptographic hash functions and their properties
+    - Master the Hash module classes and helper functions in the BSV TypeScript SDK
+    - Implement various hash algorithms (SHA-256, SHA-512, SHA-1, RIPEMD-160)
+    - Create and verify HMACs for message authentication
+    - Apply Bitcoin-specific hashing patterns (hash256, hash160)
+    - Build practical applications using hashing for data integrity and authentication
+    - Understand performance considerations and security best practices
 
 ### [Type-42 Key Derivation](./type-42.md)
+
 - **Duration**: 75 minutes
 - **Prerequisites**: Basic TypeScript knowledge, Elliptic Curve Fundamentals tutorial completed, ECDH Key Exchange tutorial completed
 - **Learning Goals**:
-  - Understand Type-42 key derivation protocol and its use cases
-  - Implement Type-42 operations with the BSV TypeScript SDK
-  - Create shared key universes between two parties
-  - Apply Type-42 in practical Bitcoin applications like message signing and encryption
-  - Understand the "anyone key" concept and its applications
 
+    - Understand Type-42 key derivation protocol and its use cases
+    - Implement Type-42 operations with the BSV TypeScript SDK
+    - Create shared key universes between two parties
+    - Apply Type-42 in practical Bitcoin applications like message signing and encryption
+    - Understand the "anyone key" concept and its applications
 
 ## Alternative Low-Level Transaction API Track
 
 These tutorials demonstrate how to use the lower-level APIs of the BSV TypeScript SDK for more direct control over transaction creation and management.
 
 ### [Your First BSV Transaction (Low-level API)](./first-transaction-low-level.md)
+
 - **Duration**: 45 minutes
 - **Prerequisites**: Node.js, basic TypeScript knowledge
 - **Learning Goals**:
-  - Work with low-level transaction APIs
-  - Create transactions without WalletClient abstraction
-  - Understand transaction construction internals
-  - Manually manage inputs, outputs, and signing
+
+    - Work with low-level transaction APIs
+    - Create transactions without WalletClient abstraction
+    - Understand transaction construction internals
+    - Manually manage inputs, outputs, and signing
 
 ### [Working with Testnet Transactions (Low-level API)](./testnet-transactions-low-level.md)
+
 - **Duration**: 60 minutes
 - **Prerequisites**: Completed "Your First BSV Transaction (Low-level API)" tutorial
 - **Learning Goals**:
-  - Set up a BSV testnet environment with low-level APIs
-  - Manually handle testnet transactions
-  - Understand UTXO management without WalletClient
-  - Implement custom transaction workflows
+
+    - Set up a BSV testnet environment with low-level APIs
+    - Manually handle testnet transactions
+    - Understand UTXO management without WalletClient
+    - Implement custom transaction workflows