@bsv/wallet-toolbox 1.7.15 → 1.7.17

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

@@ -1,74 +0,0 @@
-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

@@ -1,236 +0,0 @@
-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

@@ -1,219 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

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