@bsv/wallet-toolbox 1.7.13 → 1.7.15

package/mobile/node_modules/@bsv/sdk/src/storage/StorageUtils.ts

@@ -0,0 +1,74 @@
+import { toHex, fromBase58Check, toBase58Check, toArray } from '../primitives/utils.js'
+import { Hash } from '../primitives/index.js'
+
+/**
+ * Takes a UHRP URL and removes any prefixes.
+ * @param {string} URL - The UHRP URL.
+ * @returns {string} - Normalized URL.
+ */
+export const normalizeURL = (URL: string): string => {
+  if (URL.toLowerCase().startsWith('uhrp:')) URL = URL.slice(5)
+  if (URL.startsWith('//')) URL = URL.slice(2)
+  return URL
+}
+
+/**
+ * Generates a UHRP URL from a given SHA-256 hash.
+ * @param {number[]} hash - 32-byte SHA-256 hash.
+ * @returns {string} - Base58Check encoded URL.
+ */
+export const getURLForHash = (hash: number[]): string => {
+  if (hash.length !== 32) {
+    throw new Error('Hash length must be 32 bytes (sha256)')
+  }
+  return toBase58Check(hash, toArray('ce00', 'hex'))
+}
+
+/**
+ * Generates a UHRP URL for a given file.
+ * 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: 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)
+}
+
+/**
+ * Extracts the hash from a UHRP URL.
+ * @param {string} URL - UHRP URL.
+ * @returns {number[]} - Extracted SHA-256 hash.
+ */
+export const getHashFromURL = (URL: string): number[] => {
+  URL = normalizeURL(URL)
+  const { data, prefix } = fromBase58Check(URL, undefined, 2)
+  if (data.length !== 32) {
+    throw new Error('Invalid length!')
+  }
+  if (toHex(prefix as number[]) !== 'ce00') {
+    throw new Error('Bad prefix')
+  }
+  return data as number[]
+}
+
+/**
+ * Checks if a URL is a valid UHRP URL.
+ * @param {string} URL - The URL to validate.
+ * @returns {boolean} - True if valid, false otherwise.
+ */
+export const isValidURL = (URL: string): boolean => {
+  try {
+    getHashFromURL(URL)
+    return true
+  } catch (e) {
+    return false
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/storage/__tests/StorageDownloader.test.ts

@@ -0,0 +1,236 @@
+import { StorageDownloader } from '../StorageDownloader.js'
+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 { PublicKey } from '../../primitives/index.js'
+import { Utils } from '../../primitives/index.js'
+import { ReadableStream } from 'stream/web'
+
+beforeEach(() => {
+    jest.restoreAllMocks()
+})
+
+describe('StorageDownloader', () => {
+    let downloader: StorageDownloader
+
+    beforeEach(() => {
+        // Create a fresh instance
+        downloader = new StorageDownloader()
+    })
+
+    describe('resolve()', () => {
+        it('throws if the lookup response is not "output-list"', async () => {
+            // Mock the LookupResolver to return something invalid
+            jest.spyOn(LookupResolver.prototype, 'query').mockResolvedValue({
+                type: 'something-else',
+                outputs: []
+            } as any)
+
+            await expect(downloader.resolve('fakeUhrpUrl'))
+                .rejects
+                .toThrow('Lookup answer must be an output list')
+        })
+
+        it('decodes each output with Transaction.fromBEEF and PushDrop.decode', async () => {
+            // 1) Mock lookup response
+            jest.spyOn(LookupResolver.prototype, 'query').mockResolvedValue({
+                type: 'output-list',
+                outputs: [
+                    { beef: 'fake-beef-a', outputIndex: 0 },
+                    { beef: 'fake-beef-b', outputIndex: 1 }
+                ]
+            } as any)
+
+            // 2) Mock Transaction.fromBEEF -> returns a dummy transaction
+            jest.spyOn(Transaction, 'fromBEEF').mockImplementation(() => {
+                // Each transaction might have multiple outputs; we only care about `outputIndex`
+                return {
+                    outputs: [
+                        { lockingScript: {} }, // index 0
+                        { lockingScript: {} }  // index 1
+                    ]
+                } as any
+            })
+
+            // 3) Mock PushDrop.decode -> returns { fields: number[][] }
+            jest.spyOn(PushDrop, 'decode').mockImplementation(() => {
+                // The decode function returns an object with `fields`,
+                return {
+                    lockingPublicKey: {} as PublicKey,
+                    fields: [
+                        [11],
+                        [22],
+                        [104, 116, 116, 112, 58, 47, 47, 97, 46, 99, 111, 109]
+                    ]
+                }
+            })
+
+            // 4) Mock Utils.toUTF8 to convert that number[] to a string
+            jest.spyOn(Utils, 'toUTF8').mockReturnValue('http://a.com')
+
+            const resolved = await downloader.resolve('fakeUhrpUrl')
+            expect(resolved).toEqual(['http://a.com', 'http://a.com'])
+        })
+
+
+    })
+
+    describe('download()', () => {
+        it('throws if UHRP URL is invalid', async () => {
+            jest.spyOn(StorageUtils, 'isValidURL').mockReturnValue(false)
+
+            await expect(downloader.download('invalidUrl'))
+                .rejects
+                .toThrow('Invalid parameter UHRP url')
+        })
+
+        it('throws if no hosts are found', async () => {
+            // Valid UHRP URL
+            jest.spyOn(StorageUtils, 'isValidURL').mockReturnValue(true)
+            // Return some random 32-byte hash so we can pass the check
+            jest.spyOn(StorageUtils, 'getHashFromURL').mockReturnValue(new Array(32).fill(0))
+
+            // Force resolve() to return an empty array
+            jest.spyOn(downloader, 'resolve').mockResolvedValue([])
+
+            await expect(downloader.download('validButUnhostedUrl'))
+                .rejects
+                .toThrow('No one currently hosts this file!')
+        })
+
+        it('downloads successfully from the first working host', async () => {
+            jest.spyOn(StorageUtils, 'isValidURL').mockReturnValue(true)
+            const knownHash = [
+                102, 104, 122, 173, 248, 98, 189, 119, 108, 143,
+                193, 139, 142, 159, 142, 32, 8, 151, 20, 133,
+                110, 226, 51, 179, 144, 42, 89, 29, 13, 95,
+                41, 37
+            ]
+            jest.spyOn(StorageUtils, 'getHashFromURL').mockReturnValue(knownHash)
+
+            // Suppose two possible download URLs
+            jest.spyOn(downloader, 'resolve').mockResolvedValue([
+                'http://host1/404',
+                'http://host2/ok'
+            ])
+
+            // The first fetch -> 404, second fetch -> success
+            const fetchSpy = jest.spyOn(global, 'fetch')
+                .mockResolvedValueOnce(new Response(null, { status: 404 }))
+                .mockResolvedValueOnce(new Response(new Uint8Array(32).fill(0), {
+                    status: 200,
+                    headers: { 'Content-Type': 'application/test' }
+                }))
+
+            const result = await downloader.download('validUrl')
+            expect(fetchSpy).toHaveBeenCalledTimes(2)
+            expect(result).toEqual({
+                data: new Uint8Array(32).fill(0),
+                mimeType: 'application/test'
+            })
+        })
+
+        it('throws if content hash mismatches the UHRP hash', async () => {
+            jest.spyOn(StorageUtils, 'isValidURL').mockReturnValue(true)
+            // The expected hash is all zeros
+            jest.spyOn(StorageUtils, 'getHashFromURL').mockReturnValue(new Array(32).fill(0))
+
+            // One potential host
+            jest.spyOn(downloader, 'resolve').mockResolvedValue([
+                'http://bad-content.test'
+            ])
+
+            // The fetch returns 32 bytes of all 1's => hash mismatch
+            jest.spyOn(global, 'fetch').mockResolvedValue(
+                new Response(new Uint8Array(32).fill(1), { status: 200 })
+            )
+
+            await expect(downloader.download('validButBadHashUrl'))
+                .rejects
+                .toThrow()
+        })
+
+        it('throws if all hosts fail or mismatch', async () => {
+            jest.spyOn(StorageUtils, 'isValidURL').mockReturnValue(true)
+            jest.spyOn(StorageUtils, 'getHashFromURL').mockReturnValue(new Array(32).fill(0))
+
+            jest.spyOn(downloader, 'resolve').mockResolvedValue([
+                'http://host1.test',
+                'http://host2.test'
+            ])
+
+            // Both fetches fail with 500 or something >=400
+            jest.spyOn(global, 'fetch').mockResolvedValue(
+                new Response(null, { status: 500 })
+            )
+
+            await expect(downloader.download('validButNoGoodHostUrl'))
+                .rejects
+                .toThrow('Unable to download content from validButNoGoodHostUrl')
+        })
+
+        it('throws if all entries are expired', async () => {
+            const currentTime = Math.floor(Date.now())
+
+            jest.spyOn(LookupResolver.prototype, 'query').mockResolvedValue({
+                type: 'output-list',
+                outputs: [
+                    { beef: 'fake-beef-a', outputIndex: 0 },
+                    { beef: 'fake-beef-b', outputIndex: 1 }
+                ]
+            } as any)
+
+            jest.spyOn(Transaction, 'fromBEEF').mockImplementation(() => {
+                return {
+                    outputs: [
+                        { lockingScript: {} },
+                        { lockingScript: {} }
+                    ]
+                } as any
+            })
+
+            jest.spyOn(PushDrop, 'decode').mockImplementation(() => {
+                return {
+                    lockingPublicKey: {} as PublicKey,
+                    fields: [[], [], [], [currentTime - 100]]
+                }
+            })
+
+            await expect(downloader.resolve('expiredUhrpUrl'))
+                .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/mobile/node_modules/@bsv/sdk/src/storage/__tests/StorageUploader.test.ts

@@ -0,0 +1,219 @@
+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
+ */
+function stringToUtf8Array(str: string): number[] {
+  return Array.from(new TextEncoder().encode(str))
+}
+
+describe('StorageUploader Tests', () => {
+  let uploader: StorageUploader
+  let walletClient: WalletClient
+
+  // We'll have TWO spies:
+  let authFetchSpy: jest.SpiedFunction<typeof global.fetch>
+  let globalFetchSpy: jest.SpiedFunction<typeof global.fetch>
+
+  beforeEach(() => {
+    walletClient = new WalletClient('json-api', 'non-admin.com')
+    uploader = new StorageUploader({
+      storageURL: 'https://example.test.system',
+      wallet: walletClient
+    })
+
+    // 1) Spy on the "authFetch.fetch" calls for /find, /list, /renew
+    authFetchSpy = jest
+      .spyOn(uploader['authFetch'], 'fetch')
+      .mockResolvedValue(new Response(null, { status: 200 }))
+
+    // 2) Spy on the global "fetch" calls for file upload (uploadFile)
+    globalFetchSpy = jest
+      .spyOn(global, 'fetch')
+      .mockResolvedValue(new Response(null, { status: 200 }))
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  it('should upload a file, produce a valid UHRP URL, and decode it to the known SHA-256', async () => {
+    const data = stringToUtf8Array('Hello, world!')
+
+    // Mock out getUploadInfo so we can control the returned upload/public URLs
+    jest.spyOn(uploader as any, 'getUploadInfo').mockResolvedValue({
+      uploadURL: 'https://example-upload.com/put'
+    })
+
+    const result = await uploader.publishFile({
+      file: { data, type: 'text/plain' },
+      retentionPeriod: 7
+    })
+
+    // This direct upload uses global.fetch, not authFetch
+    expect(globalFetchSpy).toHaveBeenCalledTimes(1)
+
+    // Check the result
+    expect(StorageUtils.isValidURL(result.uhrpURL)).toBe(true)
+    expect(result.published).toBe(true)
+
+    const url = StorageUtils.getHashFromURL(result.uhrpURL)
+    const firstFour = url.slice(0, 4)
+      .map(b => b.toString(16).padStart(2, '0'))
+      .join('')
+    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 }))
+
+    // Also mock getUploadInfo
+    jest.spyOn(uploader as any, 'getUploadInfo').mockResolvedValue({
+      uploadURL: 'https://example-upload.com/put'
+    })
+
+    const failingData = stringToUtf8Array('failing data')
+
+    await expect(
+      uploader.publishFile({
+        file: { data: failingData, type: 'text/plain' },
+        retentionPeriod: 30
+      })
+    ).rejects.toThrow('File upload failed: HTTP 500')
+  })
+
+  it('should find a file and return metadata', async () => {
+    // This route goes through authFetch, not global fetch
+    authFetchSpy.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          status: 'success',
+          data: {
+            name: 'cdn/abc123',
+            size: '1024',
+            mimeType: 'text/plain',
+            expiryTime: 123456
+          }
+        }),
+        { status: 200 }
+      )
+    )
+
+    const fileData = await uploader.findFile('uhrp://some-hash')
+    expect(authFetchSpy).toHaveBeenCalledTimes(1)
+    expect(fileData.name).toBe('cdn/abc123')
+    expect(fileData.size).toBe('1024')
+    expect(fileData.mimeType).toBe('text/plain')
+    expect(fileData.expiryTime).toBe(123456)
+  })
+
+  it('should throw an error if findFile returns an error status', async () => {
+    authFetchSpy.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({ status: 'error', code: 'ERR_NOT_FOUND', description: 'File not found' }),
+        { status: 200 }
+      )
+    )
+
+    await expect(uploader.findFile('uhrp://unknown-hash'))
+      .rejects
+      .toThrow('findFile returned an error: ERR_NOT_FOUND - File not found')
+  })
+
+  it('should list user uploads successfully', async () => {
+    // /list uses authFetch
+    const mockUploads = [
+      { uhrpUrl: 'uhrp://hash1', expiryTime: 111111 },
+      { uhrpUrl: 'uhrp://hash2', expiryTime: 222222 }
+    ]
+    authFetchSpy.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({ status: 'success', uploads: mockUploads }),
+        { status: 200 }
+      )
+    )
+
+    const result = await uploader.listUploads()
+    expect(authFetchSpy).toHaveBeenCalledTimes(1)
+    expect(result).toEqual(mockUploads)
+  })
+
+  it('should throw an error if listUploads returns an error', async () => {
+    authFetchSpy.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({ status: 'error', code: 'ERR_INTERNAL', description: 'Something broke' }),
+        { status: 200 }
+      )
+    )
+
+    await expect(uploader.listUploads()).rejects.toThrow(
+      'listUploads returned an error: ERR_INTERNAL - Something broke'
+    )
+  })
+
+  it('should renew a file and return the new expiry info', async () => {
+    // /renew uses authFetch
+    authFetchSpy.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          status: 'success',
+          prevExpiryTime: 123,
+          newExpiryTime: 456,
+          amount: 99
+        }),
+        { status: 200 }
+      )
+    )
+
+    const renewal = await uploader.renewFile('uhrp://some-hash', 30)
+    expect(authFetchSpy).toHaveBeenCalledTimes(1)
+    expect(renewal.status).toBe('success')
+    expect(renewal.prevExpiryTime).toBe(123)
+    expect(renewal.newExpiryTime).toBe(456)
+    expect(renewal.amount).toBe(99)
+  })
+
+  it('should throw an error if renewFile returns error status JSON', async () => {
+    authFetchSpy.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({ status: 'error', code: 'ERR_CANT_RENEW', description: 'Failed to renew' }),
+        { status: 200 }
+      )
+    )
+
+    await expect(uploader.renewFile('uhrp://some-other-hash', 15))
+      .rejects
+      .toThrow('renewFile returned an error: ERR_CANT_RENEW - Failed to renew')
+  })
+
+  it('should throw if renewFile request fails with non-200 status', async () => {
+    authFetchSpy.mockResolvedValueOnce(new Response(null, { status: 404 }))
+
+    await expect(uploader.renewFile('uhrp://ghost', 10))
+      .rejects
+      .toThrow('renewFile request failed: HTTP 404')
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/storage/__tests/StorageUtils.test.ts

@@ -0,0 +1,86 @@
+import { StorageUtils } from '../index.js'
+import * as Utils from '../../primitives/utils.js'
+import * as Hash from '../..//primitives/Hash.js'
+
+// Example data
+const exampleHashHex = '1a5ec49a3f32cd56d19732e89bde5d81755ddc0fd8515dc8b226d47654139dca'
+const exampleHash = Utils.toArray(exampleHashHex, 'hex')
+const exampleFileHex = '687da27f04a112aa48f1cab2e7949f1eea4f7ba28319c1e999910cd561a634a05a3516e6db'
+const exampleFile = Utils.toArray(exampleFileHex, 'hex')
+const exampleURL = 'XUT6PqWb3GP3LR7dmBMCJwZ3oo5g1iGCF3CrpzyuJCemkGu1WGoq'
+
+describe('StorageUtils', () => {
+  describe('getURLForHash', () => {
+    it('Creates the correct URL for the hash', () => {
+      const url = StorageUtils.getURLForHash(exampleHash)
+      expect(url).toBe(exampleURL)
+    })
+
+    it('Throws an error if hash length is invalid', () => {
+      // Get the length of a FILE (not a hash — wrong length!)
+      expect(() => StorageUtils.getURLForHash(exampleFile)).toThrow(
+        new Error('Hash length must be 32 bytes (sha256)')
+      )
+    })
+  })
+
+  describe('getURLForFile', () => {
+    it('Creates the correct URL for the file', () => {
+      const url = StorageUtils.getURLForFile(exampleFile)
+      expect(url).toEqual(exampleURL)
+    })
+  })
+
+  describe('getHashFromURL', () => {
+    it('Decodes the URL to the correct hash', () => {
+      const hash = StorageUtils.getHashFromURL(exampleURL)
+      expect(Utils.toHex(hash)).toEqual(exampleHashHex)
+    })
+
+    it('Gets the same hash as getting one directly from the file', () => {
+      const hashA = StorageUtils.getHashFromURL(exampleURL)
+      const hashB = Hash.sha256(exampleFile)
+      expect(hashA).toEqual(hashB)
+    })
+
+    it('Throws an error if checksum is invalid', () => {
+      const badURL = 'XUU7cTfy6fA6q2neLDmzPqJnGB6o18PXKoGaWLPrH1SeWLKgdCKq'
+      expect(() => StorageUtils.getHashFromURL(badURL)).toThrow(new Error('Invalid checksum'))
+    })
+
+    it('Throws an error if URL length is invalid', () => {
+      const badURL = 'SomeBase58CheckTooShortOrTooLong'
+      expect(() => StorageUtils.getHashFromURL(badURL)).toThrow()
+    })
+
+    it('Throws an error if prefix is invalid', () => {
+      const invalidPrefixURL1 = 'AInvalidPrefixTestString1'
+      const invalidPrefixURL2 = 'AInvalidPrefixTestString2'
+      expect(() => StorageUtils.getHashFromURL(invalidPrefixURL1)).toThrow()
+      expect(() => StorageUtils.getHashFromURL(invalidPrefixURL2)).toThrow()
+    })
+  })
+
+  describe('isValidURL', () => {
+    it('Returns true when URL is valid', () => {
+      expect(StorageUtils.isValidURL(exampleURL)).toBe(true)
+    })
+
+    it('Returns false if checksum is invalid', () => {
+      const badURL = 'XUU7cTfy6fA6q2neLDmzPqJnGB6o18PXKoGaWLPrH1SeWLKgdCKq'
+      expect(StorageUtils.isValidURL(badURL)).toBe(false)
+    })
+
+    it('Returns false if URL length is invalid', () => {
+      const badURL = 'SomeBase58CheckTooShortOrTooLong'
+      expect(StorageUtils.isValidURL(badURL)).toBe(false)
+    })
+
+    it('Returns false if prefix is invalid', () => {
+      const badURL1 = 'AnotherInvalidPrefixTestString'
+      const badURL2 = 'YetAnotherInvalidPrefixTestString'
+      expect(StorageUtils.isValidURL(badURL1)).toBe(false)
+      expect(StorageUtils.isValidURL(badURL2)).toBe(false)
+    })
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/storage/index.ts

@@ -0,0 +1,5 @@
+export * as StorageUtils from './StorageUtils.js'
+
+export { StorageUploader } from './StorageUploader.js'
+
+export { StorageDownloader } from './StorageDownloader.js'