@bsv/sdk 1.6.25 → 1.7.0

package/src/storage/StorageUploader.ts

@@ -8,7 +8,7 @@ export interface UploaderConfig {
 }
 
 export interface UploadableFile {
-  data: number[]
+  data: Uint8Array | number[]
   type: string
 }
 
@@ -108,7 +108,7 @@ export class StorageUploader {
     file: UploadableFile,
     requiredHeaders: Record<string, string>
   ): Promise<UploadFileResult> {
-    const body = Uint8Array.from(file.data)
+    const body = file.data instanceof Uint8Array ? file.data : Uint8Array.from(file.data)
 
     const response = await fetch(uploadURL, {
       method: 'PUT',
@@ -122,7 +122,7 @@ export class StorageUploader {
       throw new Error(`File upload failed: HTTP ${response.status}`)
     }
 
-    const uhrpURL = await StorageUtils.getURLForFile(file.data)
+    const uhrpURL = StorageUtils.getURLForFile(body)
     return {
       published: true,
       uhrpURL
@@ -148,10 +148,11 @@ export class StorageUploader {
     retentionPeriod: number
   }): Promise<UploadFileResult> {
     const { file, retentionPeriod } = params
-    const fileSize = file.data.length
+    const data = file.data instanceof Uint8Array ? file.data : Uint8Array.from(file.data)
+    const fileSize = data.byteLength
 
     const { uploadURL, requiredHeaders } = await this.getUploadInfo(fileSize, retentionPeriod)
-    return await this.uploadFile(uploadURL, file, requiredHeaders)
+    return await this.uploadFile(uploadURL, { data, type: file.type }, requiredHeaders)
   }
 
   /**

package/src/storage/StorageUtils.ts

@@ -1,5 +1,5 @@
-import { sha256 } from '../primitives/Hash.js'
 import { toHex, fromBase58Check, toBase58Check, toArray } from '../primitives/utils.js'
+import { Hash } from '../primitives/index.js'
 
 /**
  * Takes a UHRP URL and removes any prefixes.
@@ -26,11 +26,19 @@ export const getURLForHash = (hash: number[]): string => {
 
 /**
  * Generates a UHRP URL for a given file.
- * @param {number[] | string} file - File content as number array or string.
+ * Uses a streaming hash to avoid excessive memory usage with large files.
+ * @param {Uint8Array | number[]} file - File content as a typed array or number array.
  * @returns {string} - Base58Check encoded URL.
  */
-export const getURLForFile = (file: number[]): string => {
-  const hash = sha256(file)
+export const getURLForFile = (file: Uint8Array | number[]): string => {
+  const data = file instanceof Uint8Array ? file : Uint8Array.from(file)
+  const hasher = new Hash.SHA256()
+  const chunkSize = 1024 * 1024
+  for (let i = 0; i < data.length; i += chunkSize) {
+    const chunk = data.subarray(i, i + chunkSize)
+    hasher.update(Array.from(chunk))
+  }
+  const hash = hasher.digest()
   return getURLForHash(hash)
 }
 

package/src/storage/__tests/StorageDownloader.test.ts

@@ -3,8 +3,9 @@ import { StorageUtils } from '../index.js'
 import { LookupResolver } from '../../overlay-tools/index.js'
 import Transaction from '../../transaction/Transaction.js'
 import PushDrop from '../../script/templates/PushDrop.js'
-import { Hash, PublicKey } from '../../primitives/index.js'
+import { PublicKey } from '../../primitives/index.js'
 import { Utils } from '../../primitives/index.js'
+import { ReadableStream } from 'stream/web'
 
 beforeEach(() => {
     jest.restoreAllMocks()
@@ -125,7 +126,7 @@ describe('StorageDownloader', () => {
             const result = await downloader.download('validUrl')
             expect(fetchSpy).toHaveBeenCalledTimes(2)
             expect(result).toEqual({
-                data: new Array(32).fill(0),
+                data: new Uint8Array(32).fill(0),
                 mimeType: 'application/test'
             })
         })
@@ -200,5 +201,36 @@ describe('StorageDownloader', () => {
                 .resolves
                 .toEqual(["", ""])
         })
+
+        it.skip('downloads and verifies large streamed content', async () => {
+            const size = 5 * 1024 * 1024
+            const data = new Uint8Array(size)
+            for (let i = 0; i < size; i++) data[i] = i % 256
+            const uhrpUrl = StorageUtils.getURLForFile(data)
+
+            jest.spyOn(downloader, 'resolve').mockResolvedValue(['http://large-file'])
+
+            const chunkSize = 64 * 1024
+            const stream = new ReadableStream<Uint8Array>({
+                start (controller) {
+                    for (let offset = 0; offset < data.length; offset += chunkSize) {
+                        controller.enqueue(data.subarray(offset, offset + chunkSize))
+                    }
+                    controller.close()
+                }
+            })
+
+            jest.spyOn(global, 'fetch').mockResolvedValue(
+                new Response(stream as any, {
+                    status: 200,
+                    headers: { 'Content-Type': 'application/octet-stream' }
+                })
+            )
+
+            const result = await downloader.download(uhrpUrl)
+            expect(result.mimeType).toBe('application/octet-stream')
+            expect(result.data.length).toBe(size)
+            expect(result.data).toEqual(data)
+        })
     })
 })

package/src/storage/__tests/StorageUploader.test.ts

@@ -1,6 +1,7 @@
 import { StorageUploader } from '../StorageUploader.js'
 import * as StorageUtils from '../StorageUtils.js'
 import WalletClient from '../../wallet/WalletClient.js'
+import { createHash } from 'crypto'
 
 /**
  * A helper for converting a string to a number[] of UTF-8 bytes
@@ -66,6 +67,25 @@ describe('StorageUploader Tests', () => {
     expect(firstFour).toHaveLength(8)
   })
 
+  it('should handle large file uploads efficiently', async () => {
+    const size = 5 * 1024 * 1024
+    const data = new Uint8Array(size)
+    for (let i = 0; i < size; i++) data[i] = i % 256
+
+    jest.spyOn(uploader as any, 'getUploadInfo').mockResolvedValue({
+      uploadURL: 'https://example-upload.com/put'
+    })
+
+    const result = await uploader.publishFile({
+      file: { data, type: 'application/octet-stream' },
+      retentionPeriod: 7
+    })
+
+    const expectedHash = createHash('sha256').update(data).digest()
+    const urlHash = StorageUtils.getHashFromURL(result.uhrpURL)
+    expect(Buffer.from(urlHash)).toEqual(expectedHash)
+  })
+
   it('should throw if the upload fails with HTTP 500', async () => {
     // Force the direct upload (global fetch) to fail
     globalFetchSpy.mockResolvedValueOnce(new Response(null, { status: 500 }))