@bsv/sdk 1.6.8 → 1.6.10

package/docs/tutorials/uhrp-storage.md

@@ -0,0 +1,579 @@
+# Decentralized File Storage with UHRP
+
+**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
+- Handle file integrity verification and expiration
+
+## Introduction
+
+UHRP (Universal Hash Resource Protocol) is a decentralized file storage system that uses content hashing for addressing and retrieval. The BSV SDK provides `StorageUploader` and `StorageDownloader` classes for seamless integration with UHRP storage networks.
+
+## 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)
+- **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
+
+**Performance Note**: UHRP storage operations may take time to complete as they involve blockchain transactions and network propagation. Upload operations can take 10-30 seconds or more depending on network conditions.
+
+**Network Propagation**: After uploading, files typically take 30-60 seconds to propagate across the UHRP network before they become available for download. This is normal behavior for decentralized storage systems and ensures content integrity verification.
+
+## Key Features
+
+- **Content-Addressed Storage**: Files identified by their hash
+- **Decentralized Retrieval**: Multiple storage providers
+- **Integrity Verification**: Automatic hash validation
+- **Expiration Management**: Time-based file retention
+- **Authenticated Upload**: Wallet-based authentication
+
+## What You'll Build
+
+- File upload system with UHRP
+- Decentralized file retrieval
+- File management dashboard
+- Integrity verification system
+
+## Setting Up UHRP Storage
+
+### Basic File Upload
+
+```typescript
+import { StorageUploader, WalletClient } from '@bsv/sdk'
+
+async function basicFileUpload() {
+  const wallet = new WalletClient('auto', 'localhost')
+  
+  const uploader = new StorageUploader({
+    storageURL: 'https://nanostore.babbage.systems',
+    wallet
+  })
+  
+  // Create sample file
+  const fileData = new TextEncoder().encode('Hello, UHRP storage!')
+  const file = {
+    data: Array.from(fileData),
+    type: 'text/plain'
+  }
+  
+  try {
+    const result = await uploader.publishFile({
+      file,
+      retentionPeriod: 60 * 24 * 7 // 7 days in minutes
+    })
+    
+    console.log('File uploaded successfully!')
+    console.log('UHRP URL:', result.uhrpURL)
+    console.log('Published:', result.published)
+    
+    return result
+  } catch (error) {
+    console.error('Upload failed:', error)
+    throw error
+  }
+}
+
+basicFileUpload().catch(console.error)
+```
+
+### File Download and Verification
+
+```typescript
+import { StorageDownloader } from '@bsv/sdk'
+
+async function basicFileDownload(uhrpUrl: string) {
+  const downloader = new StorageDownloader({
+    networkPreset: 'mainnet'
+  })
+  
+  try {
+    console.log('Downloading file:', uhrpUrl)
+    
+    const result = await downloader.download(uhrpUrl)
+    
+    console.log('File downloaded successfully!')
+    console.log('MIME Type:', result.mimeType)
+    console.log('Content length:', result.data.length, 'bytes')
+    
+    // Convert to string if text file
+    if (result.mimeType?.startsWith('text/')) {
+      const content = new TextDecoder().decode(new Uint8Array(result.data))
+      console.log('Content:', content)
+    }
+    
+    return result
+  } catch (error) {
+    console.error('Download failed:', error)
+    throw error
+  }
+}
+
+// Example usage (replace with actual UHRP URL)
+// basicFileDownload('uhrp://abc123...').catch(console.error)
+```
+
+## Complete File Management System
+
+### File Manager Class
+
+```typescript
+import { StorageUploader, StorageDownloader, WalletClient } from '@bsv/sdk'
+
+interface FileMetadata {
+  uhrpUrl: string
+  originalName: string
+  mimeType: string
+  size: number
+  uploadDate: Date
+  expiryDate: Date
+  tags: string[]
+}
+
+class UHRPFileManager {
+  private uploader: StorageUploader
+  private downloader: StorageDownloader
+  private fileRegistry: Map<string, FileMetadata> = new Map()
+  
+  constructor(storageURL: string, wallet?: WalletClient) {
+    this.uploader = new StorageUploader({
+      storageURL,
+      wallet: wallet || new WalletClient('auto', 'localhost')
+    })
+    
+    this.downloader = new StorageDownloader({
+      networkPreset: 'mainnet'
+    })
+  }
+  
+  async uploadFile(
+    fileData: Uint8Array,
+    fileName: string,
+    mimeType: string,
+    retentionDays: number = 30,
+    tags: string[] = []
+  ): Promise<FileMetadata> {
+    const file = {
+      data: Array.from(fileData),
+      type: mimeType
+    }
+    
+    const retentionMinutes = retentionDays * 24 * 60
+    
+    try {
+      const result = await this.uploader.publishFile({
+        file,
+        retentionPeriod: retentionMinutes
+      })
+      
+      const metadata: FileMetadata = {
+        uhrpUrl: result.uhrpURL,
+        originalName: fileName,
+        mimeType,
+        size: fileData.length,
+        uploadDate: new Date(),
+        expiryDate: new Date(Date.now() + retentionDays * 24 * 60 * 60 * 1000),
+        tags
+      }
+      
+      this.fileRegistry.set(result.uhrpURL, metadata)
+      
+      console.log(`File "${fileName}" uploaded successfully`)
+      console.log('UHRP URL:', result.uhrpURL)
+      
+      return metadata
+    } catch (error) {
+      console.error(`Failed to upload "${fileName}":`, error)
+      throw error
+    }
+  }
+  
+  async downloadFile(uhrpUrl: string): Promise<{
+    data: Uint8Array
+    metadata: FileMetadata | null
+  }> {
+    try {
+      const result = await this.downloader.download(uhrpUrl)
+      const metadata = this.fileRegistry.get(uhrpUrl) || null
+      
+      console.log('File downloaded:', uhrpUrl)
+      
+      return {
+        data: new Uint8Array(result.data),
+        metadata
+      }
+    } catch (error) {
+      console.error('Download failed:', error)
+      throw error
+    }
+  }
+  
+  async getFileInfo(uhrpUrl: string): Promise<any> {
+    try {
+      return await this.uploader.findFile(uhrpUrl)
+    } catch (error) {
+      console.error('Failed to get file info:', error)
+      throw error
+    }
+  }
+  
+  async renewFile(uhrpUrl: string, additionalDays: number): Promise<any> {
+    const additionalMinutes = additionalDays * 24 * 60
+    
+    try {
+      const result = await this.uploader.renewFile(uhrpUrl, additionalMinutes)
+      
+      // Update local metadata if exists
+      const metadata = this.fileRegistry.get(uhrpUrl)
+      if (metadata) {
+        metadata.expiryDate = new Date(Date.now() + additionalDays * 24 * 60 * 60 * 1000)
+        this.fileRegistry.set(uhrpUrl, metadata)
+      }
+      
+      console.log(`File renewed for ${additionalDays} days`)
+      return result
+    } catch (error) {
+      console.error('Failed to renew file:', error)
+      throw error
+    }
+  }
+  
+  listFiles(tag?: string): FileMetadata[] {
+    const files = Array.from(this.fileRegistry.values())
+    
+    if (tag) {
+      return files.filter(file => file.tags.includes(tag))
+    }
+    
+    return files
+  }
+  
+  getExpiringFiles(daysAhead: number = 7): FileMetadata[] {
+    const cutoffDate = new Date(Date.now() + daysAhead * 24 * 60 * 60 * 1000)
+    
+    return Array.from(this.fileRegistry.values())
+      .filter(file => file.expiryDate <= cutoffDate)
+      .sort((a, b) => a.expiryDate.getTime() - b.expiryDate.getTime())
+  }
+}
+
+async function demonstrateFileManager() {
+  const fileManager = new UHRPFileManager('https://nanostore.babbage.systems')
+  
+  console.log('=== UHRP File Manager Demo ===')
+  
+  // Upload different types of files
+  const textData = new TextEncoder().encode('This is a text document for UHRP storage.')
+  const jsonData = new TextEncoder().encode(JSON.stringify({
+    message: 'Hello from UHRP',
+    timestamp: new Date().toISOString(),
+    data: [1, 2, 3, 4, 5]
+  }))
+  
+  try {
+    // Upload text file
+    const textFile = await fileManager.uploadFile(
+      textData,
+      'document.txt',
+      'text/plain',
+      30,
+      ['document', 'text']
+    )
+    
+    // Upload JSON file
+    const jsonFile = await fileManager.uploadFile(
+      jsonData,
+      'data.json',
+      'application/json',
+      60,
+      ['data', 'json']
+    )
+    
+    console.log('\n=== File Registry ===')
+    const allFiles = fileManager.listFiles()
+    allFiles.forEach(file => {
+      console.log(`${file.originalName}: ${file.uhrpUrl}`)
+    })
+    
+    // Test download
+    console.log('\n=== Testing Download ===')
+    const downloadResult = await fileManager.downloadFile(textFile.uhrpUrl)
+    const content = new TextDecoder().decode(downloadResult.data)
+    console.log('Downloaded content:', content)
+    
+    // Check expiring files
+    console.log('\n=== Expiring Files ===')
+    const expiringFiles = fileManager.getExpiringFiles(365) // Next year
+    expiringFiles.forEach(file => {
+      console.log(`${file.originalName} expires: ${file.expiryDate.toISOString()}`)
+    })
+    
+    return { textFile, jsonFile, allFiles }
+  } catch (error) {
+    console.error('Demo failed:', error)
+  }
+}
+
+demonstrateFileManager().catch(console.error)
+
+## Advanced Features
+
+### Batch Operations
+
+```typescript
+import { StorageUploader, StorageDownloader, WalletClient } from '@bsv/sdk'
+
+class BatchFileOperations {
+  private uploader: StorageUploader
+  private downloader: StorageDownloader
+  
+  constructor(storageURL: string, wallet?: WalletClient) {
+    this.uploader = new StorageUploader({
+      storageURL,
+      wallet: wallet || new WalletClient('auto', 'localhost')
+    })
+    
+    this.downloader = new StorageDownloader()
+  }
+  
+  async batchUpload(files: Array<{
+    data: Uint8Array
+    name: string
+    type: string
+    retention?: number
+  }>): Promise<Array<{
+    success: boolean
+    file: string
+    uhrpUrl?: string
+    error?: string
+  }>> {
+    console.log(`Starting batch upload of ${files.length} files...`)
+    
+    const results = await Promise.allSettled(
+      files.map(async (file) => {
+        const fileObj = {
+          data: Array.from(file.data),
+          type: file.type
+        }
+        
+        const result = await this.uploader.publishFile({
+          file: fileObj,
+          retentionPeriod: (file.retention || 30) * 24 * 60
+        })
+        
+        return { file: file.name, result }
+      })
+    )
+    
+    return results.map((result, index) => {
+      const fileName = files[index].name
+      
+      if (result.status === 'fulfilled') {
+        return {
+          success: true,
+          file: fileName,
+          uhrpUrl: result.value.result.uhrpURL
+        }
+      } else {
+        return {
+          success: false,
+          file: fileName,
+          error: result.reason.message
+        }
+      }
+    })
+  }
+  
+  async batchDownload(uhrpUrls: string[]): Promise<Array<{
+    success: boolean
+    url: string
+    data?: Uint8Array
+    error?: string
+  }>> {
+    console.log(`Starting batch download of ${uhrpUrls.length} files...`)
+    
+    const results = await Promise.allSettled(
+      uhrpUrls.map(url => this.downloader.download(url))
+    )
+    
+    return results.map((result, index) => {
+      const url = uhrpUrls[index]
+      
+      if (result.status === 'fulfilled') {
+        return {
+          success: true,
+          url,
+          data: new Uint8Array(result.value.data)
+        }
+      } else {
+        return {
+          success: false,
+          url,
+          error: result.reason.message
+        }
+      }
+    })
+  }
+}
+
+async function demonstrateBatchOperations() {
+  const batchOps = new BatchFileOperations('https://nanostore.babbage.systems')
+  
+  // Prepare test files
+  const testFiles = [
+    {
+      data: new TextEncoder().encode('File 1 content'),
+      name: 'file1.txt',
+      type: 'text/plain'
+    },
+    {
+      data: new TextEncoder().encode('File 2 content'),
+      name: 'file2.txt',
+      type: 'text/plain'
+    },
+    {
+      data: new TextEncoder().encode(JSON.stringify({ test: 'data' })),
+      name: 'data.json',
+      type: 'application/json'
+    }
+  ]
+  
+  console.log('=== Batch Upload Demo ===')
+  const uploadResults = await batchOps.batchUpload(testFiles)
+  
+  uploadResults.forEach(result => {
+    if (result.success) {
+      console.log(`✅ ${result.file}: ${result.uhrpUrl}`)
+    } else {
+      console.log(`❌ ${result.file}: ${result.error}`)
+    }
+  })
+  
+  // Extract successful URLs for download test
+  const successfulUrls = uploadResults
+    .filter(r => r.success && r.uhrpUrl)
+    .map(r => r.uhrpUrl!)
+  
+  if (successfulUrls.length > 0) {
+    console.log('\n=== Batch Download Demo ===')
+    const downloadResults = await batchOps.batchDownload(successfulUrls)
+    
+    downloadResults.forEach(result => {
+      if (result.success) {
+        console.log(`✅ Downloaded: ${result.url} (${result.data?.length} bytes)`)
+      } else {
+        console.log(`❌ Failed: ${result.url} - ${result.error}`)
+      }
+    })
+  }
+  
+  return { uploadResults, downloadResults: [] }
+}
+
+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**: 
+- Install and run a BRC-100 compliant wallet (e.g., MetaNet Desktop Wallet)
+- 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
+
+## 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
+
+## Summary
+
+In this tutorial, you learned how to:
+
+✅ **Upload files to UHRP storage** with StorageUploader  
+✅ **Download and verify files** with StorageDownloader  
+✅ **Build file management systems** with metadata tracking  
+✅ **Implement batch operations** for multiple files  
+✅ **Handle file expiration** and renewal  
+
+UHRP provides a robust foundation for decentralized file storage with content addressing and integrity verification.
+
+## Next Steps
+
+- Learn about [Identity Management and Certificates](./identity-management.md)
+- Explore [AuthFetch for Authenticated HTTP Requests](./authfetch-tutorial.md)
+- Review [Security Best Practices](../guides/security-best-practices.md)
+
+UHRP provides a robust foundation for decentralized file storage with content addressing and integrity verification.
+
+The `WalletClient` provides the authentication and payment capabilities needed for UHRP operations.
+
+## Setting Up UHRP with `WalletClient`
+
+The `WalletClient` handles authentication automatically when you create `StorageUploader` and `StorageDownloader` instances.
+
+### How `WalletClient` Enables UHRP
+
+When you use UHRP with `WalletClient`:
+
+- You can upload files to decentralized storage networks.
+- You can download files from decentralized storage networks.
+- You can manage file metadata and track file expiration.
+- You can implement batch operations for multiple files.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.6.8",
+  "version": "1.6.10",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",
@@ -219,11 +219,13 @@
     "build:umd": "webpack --config webpack.config.js",
     "dev": "tsc -b -w",
     "prepublish": "npm run build",
-    "doc": "ts2md"
+    "doc": "ts2md",
+    "docs:serve": "mkdocs serve",
+    "docs:build": "mkdocs build"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/bitcoin-sv/ts-sdk.git"
+    "url": "git+https://github.com/bsv-blockchain/ts-sdk.git"
   },
   "keywords": [
     "BSV",
@@ -235,9 +237,9 @@
   "author": "BSV Blockchain Association",
   "license": "SEE LICENSE IN LICENSE.txt",
   "bugs": {
-    "url": "https://github.com/bitcoin-sv/ts-sdk/issues"
+    "url": "https://github.com/bsv-blockchain/ts-sdk/issues"
   },
-  "homepage": "https://github.com/bitcoin-sv/ts-sdk#readme",
+  "homepage": "https://github.com/bsv-blockchain/ts-sdk#readme",
   "devDependencies": {
     "@eslint/js": "^9.23.0",
     "@jest/globals": "^29.7.0",

package/src/transaction/__tests/Transaction.test.ts

@@ -806,7 +806,7 @@ describe('Transaction', () => {
         expect(beef).toEqual(BRC62Hex)
       })
       it('Does not double-encode transactions', () => {
-        // Source: https://github.com/bitcoin-sv/ts-sdk/issues/77
+        // Source: https://github.com/bsv-blockchain/ts-sdk/issues/77
         const incorrect =
           '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'
         const correct =

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -36,6 +36,7 @@ import {
   VersionString7To30Bytes,
 } from '../Wallet.interfaces.js'
 import { WERR_REVIEW_ACTIONS } from '../WERR_REVIEW_ACTIONS.js'
+import { toOriginHeader } from './utils/toOriginHeader.js'
 
 export default class HTTPWalletJSON implements WalletInterface {
   baseUrl: string
@@ -52,14 +53,23 @@ export default class HTTPWalletJSON implements WalletInterface {
     this.originator = originator
     this.httpClient = httpClient
 
+    // Detect if we're in a browser environment
+    const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined'
+
     this.api = async (call: string, args: object) => {
+      // In browser environments, let the browser handle Origin header automatically
+      // In Node.js environments, we need to set it manually if originator is provided
+      const origin = !isBrowser && this.originator
+        ? toOriginHeader(this.originator, 'http')
+        : undefined
+
       const res = await (
         await httpClient(`${this.baseUrl}/${call}`, {
           method: 'POST',
           headers: {
             Accept: 'application/json',
             'Content-Type': 'application/json',
-            Originator: this.originator ?? ''
+            ...(origin ? { Origin: origin } : {}),
           },
           body: JSON.stringify(args)
         })

package/src/wallet/substrates/WalletWireProcessor.ts

@@ -2094,7 +2094,7 @@ export default class WalletWireProcessor implements WalletWire {
         cert.certifier,
         cert.revocationOutpoint,
         cert.fields,
-        cert.signaturre
+        cert.signature
       )
       const certBin = certificate.toBinary()