@bsv/sdk 1.4.17 → 1.4.19

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

@@ -2,7 +2,9 @@ import { StorageUploader } from '../StorageUploader.js'
 import * as StorageUtils from '../StorageUtils.js'
 import WalletClient from '../../wallet/WalletClient.js'
 
-// A helper for converting a string to a number[] of UTF-8 bytes
+/**
+ * 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))
 }
@@ -10,16 +12,24 @@ function stringToUtf8Array(str: string): number[] {
 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 }))
@@ -34,47 +44,156 @@ describe('StorageUploader Tests', () => {
 
     // 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',
+      uploadURL: 'https://example-upload.com/put'
     })
 
     const result = await uploader.publishFile({
-      file: {
-        data,
-        type: 'text/plain'
-      },
+      file: { data, type: 'text/plain' },
       retentionPeriod: 7
     })
 
-    // We expect exactly one PUT request
+    // 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('')
+    const firstFour = url.slice(0, 4)
+      .map(b => b.toString(16).padStart(2, '0'))
+      .join('')
     expect(firstFour).toHaveLength(8)
   })
 
   it('should throw if the upload fails with HTTP 500', async () => {
-    // Force the fetch to fail
+    // 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',
+      uploadURL: 'https://example-upload.com/put'
     })
 
     const failingData = stringToUtf8Array('failing data')
 
     await expect(
       uploader.publishFile({
-        file: {
-          data: failingData,
-          type: 'text/plain'
-        },
+        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/src/wallet/WERR_REVIEW_ACTIONS.ts

@@ -0,0 +1,30 @@
+import { AtomicBEEF, OutpointString, ReviewActionResult, SendWithResult, TXIDHexString } from './Wallet.interfaces.js'
+
+/**
+ * When a `createAction` or `signAction` is completed in undelayed mode (`acceptDelayedBroadcast`: false),
+ * any unsucccessful result will return the results by way of this exception to ensure attention is
+ * paid to processing errors.
+ */
+export class WERR_REVIEW_ACTIONS extends Error {
+  code: number
+  isError: boolean = true
+
+  /**
+   * All parameters correspond to their comparable `createAction` or `signSction` results
+   * with the exception of `reviewActionResults`;
+   * which contains more details, particularly for double spend results.
+   */
+  constructor (
+    public reviewActionResults: ReviewActionResult[],
+    public sendWithResults: SendWithResult[],
+    public txid?: TXIDHexString,
+    public tx?: AtomicBEEF,
+    public noSendChange?: OutpointString[]
+  ) {
+    super('Undelayed createAction or signAction results require review.')
+    this.code = 5
+    this.name = this.constructor.name
+  }
+}
+
+export default WERR_REVIEW_ACTIONS

package/src/wallet/Wallet.interfaces.ts

@@ -303,6 +303,30 @@ export interface SendWithResult {
   status: SendWithResultStatus
 }
 
+/**
+ * Indicates status of a new Action following a `createAction` or `signAction` in immediate mode:
+ * When `acceptDelayedBroadcast` is falses.
+ *
+ * 'success': The action has been broadcast and accepted by the bitcoin processing network.
+ * 'doulbeSpend': The action has been confirmed to double spend one or more inputs, and by the "first-seen-rule" is the loosing transaction.
+ * 'invalidTx': The action was rejected by the processing network as an invalid bitcoin transaction.
+ * 'serviceError': The broadcast services are currently unable to reach the bitcoin network. The action is now queued for delayed retries.
+ */
+export type ReviewActionResultStatus = 'success' | 'doubleSpend' | 'serviceError' | 'invalidTx'
+
+export interface ReviewActionResult {
+  txid: TXIDHexString
+  status: ReviewActionResultStatus
+  /**
+   * Any competing txids reported for this txid, valid when status is 'doubleSpend'.
+   */
+  competingTxs?: string[]
+  /**
+   * Merged beef of competingTxs, valid when status is 'doubleSpend'.
+   */
+  competingBeef?: number[]
+}
+
 export interface SignableTransaction {
   tx: AtomicBEEF
   reference: Base64String

package/src/wallet/WalletError.ts

@@ -16,12 +16,14 @@ export class WalletError extends Error {
 }
 
 // NOTE: Enum values must not exceed the UInt8 range (0–255)
-enum walletErrors {
+export enum walletErrors {
   unknownError = 1,
   unsupportedAction = 2,
   invalidHmac = 3,
   invalidSignature = 4,
+  reviewActions = 5,
 }
 
-export default walletErrors
 export type WalletErrorCode = keyof typeof walletErrors
+
+export default WalletError

package/src/wallet/index.ts

@@ -3,6 +3,8 @@ export * from './KeyDeriver.js'
 export { default as CachedKeyDeriver } from './CachedKeyDeriver.js'
 export { default as ProtoWallet } from './ProtoWallet.js'
 export { default as WalletClient } from './WalletClient.js'
+// Is this an error? should it be 'walletErrors', the enum not the class?
 export { default as WalletErrors } from './WalletError.js'
+export { default as WERR_REVIEW_ACTIONS } from './WERR_REVIEW_ACTIONS.js'
 export * from './WalletError.js'
 export * from './substrates/index.js'

package/src/wallet/substrates/HTTPWalletJSON.ts

@@ -33,8 +33,9 @@ import {
   SecurityLevel,
   SignActionArgs,
   SignActionResult,
-  VersionString7To30Bytes
+  VersionString7To30Bytes,
 } from '../Wallet.interfaces.js'
+import { WERR_REVIEW_ACTIONS } from '../WERR_REVIEW_ACTIONS.js'
 
 export default class HTTPWalletJSON implements WalletInterface {
   baseUrl: string
@@ -68,12 +69,17 @@ export default class HTTPWalletJSON implements WalletInterface {
 
       // Check the HTTP status on the original response
       if (!res.ok) {
-        const err = {
-          call,
-          args,
-          message: data.message ?? `HTTP Client error ${res.status}`
+        if (res.status === 400 && data.isError && data.code === 5) {
+          const err = new WERR_REVIEW_ACTIONS(data.reviewActionResults, data.sendWithResults, data.txid, data.tx, data.noSendChange)
+          throw err
+        } else {
+          const err = {
+            call,
+            args,
+            message: data.message ?? `HTTP Client error ${res.status}`
+          }
+          throw new Error(JSON.stringify(err))
         }
-        throw new Error(JSON.stringify(err))
       }
       return data
     }