@bsv/sdk 1.3.36 → 1.4.0

package/src/auth/__tests/Peer.test.ts

@@ -6,7 +6,7 @@ import { Utils, PrivateKey } from '../../primitives/index.js'
 import { VerifiableCertificate } from '../../auth/certificates/VerifiableCertificate.js'
 import { MasterCertificate } from '../../auth/certificates/MasterCertificate.js'
 import { getVerifiableCertificates } from '../../auth/utils/getVerifiableCertificates.js'
-import { CompletedProtoWallet } from '../../../mod.js'
+import { CompletedProtoWallet } from '../certificates/__tests/CompletedProtoWallet.js'
 
 jest.mock('../../auth/utils/getVerifiableCertificates')
 
@@ -337,7 +337,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           }
           resolve()
         })().catch((e) => {
-          console.error(e)
+          // console.error(e)
         })
       })
     })
@@ -396,9 +396,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             Object.keys(decryptedFields).length !== 0 &&
             typeof decryptedFields.libraryCardNumber !== 'undefined'
           ) {
-            console.log(
-              `Alice received Bob's library card number: ${decryptedFields.libraryCardNumber}`
-            )
+            // console.log(
+            //   `Alice received Bob's library card number: ${decryptedFields.libraryCardNumber}`
+            // )
             aliceAcceptedLibraryCard()
           }
         }
@@ -407,7 +407,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Bob received message from Alice:', Utils.toUTF8(payload))
+        // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -452,7 +452,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
           await bobReceivedCertificates
-          console.log('Bob received message:', Utils.toUTF8(payload))
+          // console.log('Bob received message:', Utils.toUTF8(payload))
 
           // Bob requests additional certificates after initial communication
           await bob.requestCertificates(certificatesToRequest, senderPublicKey)
@@ -473,11 +473,11 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             // Decrypt to confirm
             for (const cert of certificates) {
               const decrypted = await cert.decryptFields(walletB)
-              console.log(
-                'Bob received additional certificates from Alice:',
-                cert
-              )
-              console.log('Decrypted fields:', decrypted)
+              // console.log(
+              //   'Bob received additional certificates from Alice:',
+              //   cert
+              // )
+              // console.log('Decrypted fields:', decrypted)
             }
             resolve()
           }
@@ -535,9 +535,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             // Decrypt Alice's certificate fields
             const decryptedFields = await cert.decryptFields(walletB)
             if (typeof decryptedFields.membershipStatus !== 'undefined') {
-              console.log(
-                `Bob received Alice's membership status: ${decryptedFields.membershipStatus}`
-              )
+              // console.log(
+              //   `Bob received Alice's membership status: ${decryptedFields.membershipStatus}`
+              // )
               bobAcceptedMembershipStatus()
               resolve()
             }
@@ -551,7 +551,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Bob received message from Alice:', Utils.toUTF8(payload))
+        // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -628,9 +628,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletA)
             if (decryptedFields.driversLicenseNumber !== undefined) {
-              console.log(
-                `Alice received Bob's driver's license number: ${decryptedFields.driversLicenseNumber}`
-              )
+              // console.log(
+              //   `Alice received Bob's driver's license number: ${decryptedFields.driversLicenseNumber}`
+              // )
               aliceAcceptedBobDL()
               resolve()
             }
@@ -646,9 +646,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletB)
             if (decryptedFields.driversLicenseNumber !== undefined) {
-              console.log(
-                `Bob received Alice's driver's license number: ${decryptedFields.driversLicenseNumber}`
-              )
+              // console.log(
+              //   `Bob received Alice's driver's license number: ${decryptedFields.driversLicenseNumber}`
+              // )
               bobAcceptedAliceDL()
               resolve()
             }
@@ -661,7 +661,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Bob received message from Alice:', Utils.toUTF8(payload))
+          // console.log('Bob received message from Alice:', Utils.toUTF8(payload))
           await bob.toPeer(
             Utils.toArray('Looking forward to carpooling!'),
             senderPublicKey
@@ -673,7 +673,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
     const aliceReceivedGeneralMessage = new Promise<void>((resolve) => {
       alice.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Alice received message from Bob:', Utils.toUTF8(payload))
+        // console.log('Alice received message from Bob:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -754,9 +754,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletA)
             if (decryptedFields.email !== undefined || decryptedFields.name !== undefined) {
-              console.log(
-                `Alice received Bob's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
-              )
+              // console.log(
+              //   `Alice received Bob's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
+              // )
               aliceAcceptedPartialCert()
               resolve()
             }
@@ -771,9 +771,9 @@ describe('Peer class mutual authentication and certificate exchange', () => {
           for (const cert of certificates) {
             const decryptedFields = await cert.decryptFields(walletB)
             if (decryptedFields.email !== undefined || decryptedFields.name !== undefined) {
-              console.log(
-                `Bob received Alice's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
-              )
+              // console.log(
+              //   `Bob received Alice's certificate with fields: ${Object.keys(decryptedFields).join(', ')}`
+              // )
               bobAcceptedPartialCert()
               resolve()
             }
@@ -784,7 +784,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Bob received message:', Utils.toUTF8(payload))
+        // console.log('Bob received message:', Utils.toUTF8(payload))
         resolve()
       })
     })

package/src/auth/certificates/Certificate.ts

@@ -1,14 +1,14 @@
 import {
-  Utils,
   Base64String,
   PubKeyHex,
   HexString,
   OutpointString,
   CertificateFieldNameUnder50Bytes,
-  Signature,
-  WalletProtocol,
-  ProtoWallet
-} from '../../../mod.js'
+  WalletProtocol
+} from '../../wallet/Wallet.interfaces.js'
+import * as Utils from '../../primitives/utils.js'
+import ProtoWallet from '../../wallet/ProtoWallet.js'
+import Signature from '../../primitives/Signature.js'
 
 /**
  * Represents an Identity Certificate as per the Wallet interface specifications.

package/src/auth/certificates/MasterCertificate.ts

@@ -1,16 +1,16 @@
 import {
-  SymmetricKey,
-  Utils,
   Base64String,
   CertificateFieldNameUnder50Bytes,
   HexString,
   OutpointString,
   PubKeyHex,
-  Random,
   WalletCounterparty,
-  ProtoWallet
-} from '../../../mod.js'
+} from '../../wallet/Wallet.interfaces.js'
 import Certificate from './Certificate.js'
+import * as Utils from '../../primitives/utils.js'
+import SymmetricKey from '../../primitives/SymmetricKey.js'
+import Random from '../../primitives/Random.js'
+import ProtoWallet from '../../wallet/ProtoWallet.js'
 
 interface CreateCertificateFieldsResult {
   certificateFields: Record<CertificateFieldNameUnder50Bytes, Base64String>

package/src/auth/certificates/VerifiableCertificate.ts

@@ -1,13 +1,13 @@
-import {
-  SymmetricKey,
-  Utils,
+import type {
+  PubKeyHex,
   Base64String,
   CertificateFieldNameUnder50Bytes,
   HexString,
   OutpointString,
-  PubKeyHex,
-  ProtoWallet
-} from '../../../mod.js'
+} from '../../wallet/Wallet.interfaces.js'
+import SymmetricKey from '../../primitives/SymmetricKey.js'
+import * as Utils from '../../primitives/utils.js'
+import ProtoWallet from '../../wallet/ProtoWallet.js'
 import Certificate from './Certificate.js'
 
 /**

package/src/auth/certificates/__tests/CompletedProtoWallet.ts

@@ -1,35 +1,21 @@
 //@ts-nocheck
-import { PrivateKey } from '../../../../mod.js'
+import PrivateKey from '../../../primitives/PrivateKey.js'
 import {
   ProtoWallet,
   WalletInterface,
-
   CreateActionResult,
-
   SignActionResult,
-
   AbortActionResult,
-
   ListActionsResult,
-
   InternalizeActionResult,
-
   ListOutputsResult,
-
   RelinquishOutputResult,
-
   AcquireCertificateResult,
-
   ListCertificatesResult,
-
   ProveCertificateResult,
-
   RelinquishCertificateResult,
-
   DiscoverCertificatesResult,
-
   GetHeightResult,
-
   GetHeaderResult,
   KeyDeriverApi,
   KeyDeriver,

package/src/auth/clients/AuthFetch.ts

@@ -1,5 +1,10 @@
 // @ts-nocheck
-import { Utils, Random, P2PKH, PublicKey, WalletInterface, createNonce } from '../../../mod.js'
+import * as Utils from '../../primitives/utils.js'
+import Random from '../../primitives/Random.js'
+import P2PKH from '../../script/templates/P2PKH.js'
+import PublicKey from '../../primitives/PublicKey.js'
+import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
+import { createNonce } from '../utils/createNonce.js'
 import { Peer } from '../Peer.js'
 import { SimplifiedFetchTransport } from '../transports/SimplifiedFetchTransport.js'
 import { SessionManager } from '../SessionManager.js'

package/src/auth/transports/SimplifiedFetchTransport.ts

@@ -1,7 +1,7 @@
 // @ts-nocheck
 // @ts-ignore
 import { AuthMessage, RequestedCertificateSet, Transport } from "../types.js"
-import { Utils } from '../../../mod.js'
+import * as Utils from '../../primitives/utils.js'
 
 const SUCCESS_STATUS_CODES = [200, 402]
 

package/src/auth/utils/createNonce.ts

@@ -1,10 +1,10 @@
 import {
-  Utils,
-  Random,
   WalletInterface,
   WalletCounterparty,
   Base64String
-} from '../../../mod.js'
+} from '../../wallet/Wallet.interfaces.js'
+import * as Utils from '../../primitives/utils.js'
+import Random from '../../primitives/Random.js'
 
 /**
  * Creates a nonce derived from a wallet

package/src/auth/utils/getVerifiableCertificates.ts

@@ -1,5 +1,5 @@
 import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
-import { WalletInterface } from '../../../mod.js'
+import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
 import { RequestedCertificateSet } from '../types.js'
 
 /**

package/src/auth/utils/verifyNonce.ts

@@ -1,4 +1,5 @@
-import { Utils, WalletInterface, WalletCounterparty, Base64String } from '../../../mod.js'
+import * as Utils from '../../primitives/utils.js'
+import { WalletInterface, WalletCounterparty, Base64String } from '../../wallet/Wallet.interfaces.js'
 
 /**
  * Verifies a nonce derived from a wallet

package/src/overlay-tools/LookupResolver.ts

@@ -227,8 +227,8 @@ export default class LookupResolver {
             continue
           }
         }
-      } catch (error) {
-        console.error('Error processing response outputs:', error)
+      } catch (_) {
+        // Error processing output, proceed.
       }
     }
     return {

package/src/primitives/utils.ts

@@ -359,7 +359,7 @@ export const fromBase58Check = (
   str: string,
   enc?: 'hex',
   prefixLength: number = 1
-): any => {
+): { data: number[] | string, prefix: number[] | string } => {
   const bin = fromBase58(str)
   let prefix: string | number[] = bin.slice(0, prefixLength)
   let data: string | number[] = bin.slice(prefixLength, -4)

package/src/storage/StorageUploader.ts

@@ -0,0 +1,108 @@
+import { AuthFetch } from '../auth/clients/AuthFetch.js'
+import { WalletInterface } from '../wallet/Wallet.interfaces.js'
+import * as StorageUtils from './StorageUtils.js'
+
+export interface UploaderConfig {
+  storageURL: string
+  wallet: WalletInterface
+}
+
+export interface UploadableFile {
+  data: number[]
+  type: string
+}
+
+export interface UploadFileResult {
+  published: boolean
+  uhrpURL: string
+}
+
+export class StorageUploader {
+  private readonly authFetch: AuthFetch
+  private readonly baseURL: string
+
+  constructor (config: UploaderConfig) {
+    this.baseURL = config.storageURL
+    this.authFetch = new AuthFetch(config.wallet)
+  }
+
+  private async getUploadInfo (
+    fileSize: number,
+    retentionPeriod: number
+  ): Promise<{
+      uploadURL: string
+      amount?: number
+    }> {
+    const url = `${this.baseURL}/upload`
+    const body = { fileSize, retentionPeriod }
+
+    const response = await this.authFetch.fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body)
+    })
+    if (!response.ok) {
+      throw new Error(`Upload info request failed: HTTP ${response.status}`)
+    }
+    const data = await response.json() as {
+      status: string
+      uploadURL: string
+      amount?: number
+    }
+    if (data.status === 'error') {
+      throw new Error('Upload route returned an error.')
+    }
+    return {
+      uploadURL: data.uploadURL,
+      amount: data.amount
+    }
+  }
+
+  private async uploadFile (
+    uploadURL: string,
+    file: UploadableFile
+  ): Promise<UploadFileResult> {
+    const body = Uint8Array.from(file.data)
+
+    const response = await fetch(uploadURL, {
+      method: 'PUT',
+      body,
+      headers: { 'Content-Type': file.type }
+    })
+    if (!response.ok) {
+      throw new Error(`File upload failed: HTTP ${response.status}`)
+    }
+
+    const uhrpURL = await StorageUtils.getURLForFile(file.data)
+    return {
+      published: true,
+      uhrpURL
+    }
+  }
+
+  /**
+     * Publishes a file to the storage server with the specified retention period.
+     *
+     * This will:
+     * 1. Request an upload URL from the server.
+     * 2. Perform an HTTP PUT to upload the file’s raw bytes.
+     * 3. Return a UHRP URL referencing the file once published.
+     *
+     * @param params.file - An object describing the file’s data (number[] array of bytes) and mime type.
+     * @param params.retentionPeriod - Number of minutes to keep the file hosted.
+     *
+     * @returns An object indicating whether the file was published successfully and the resulting UHRP URL.
+     *
+     * @throws If either the upload info request or the subsequent file upload request fails (non-OK HTTP status).
+     */
+  public async publishFile (params: {
+    file: UploadableFile
+    retentionPeriod: number
+  }): Promise<UploadFileResult> {
+    const { file, retentionPeriod } = params
+    const fileSize = file.data.length
+
+    const { uploadURL } = await this.getUploadInfo(fileSize, retentionPeriod)
+    return await this.uploadFile(uploadURL, file)
+  }
+}

package/src/storage/StorageUtils.ts

@@ -0,0 +1,66 @@
+import { sha256 } from '../primitives/Hash.js'
+import { toHex, fromBase58Check, toBase58Check, toArray } from '../primitives/utils.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.
+ * @param {number[] | string} file - File content as number array or string.
+ * @returns {string} - Base58Check encoded URL.
+ */
+export const getURLForFile = (file: number[]): string => {
+  const hash = sha256(file)
+  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/src/storage/__test/StorageUploader.test.ts

@@ -0,0 +1,80 @@
+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
+function stringToUtf8Array(str: string): number[] {
+  return Array.from(new TextEncoder().encode(str))
+}
+
+describe('StorageUploader Tests', () => {
+  let uploader: StorageUploader
+  let walletClient: WalletClient
+  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
+    })
+
+    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
+    })
+
+    // We expect exactly one PUT request
+    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 throw if the upload fails with HTTP 500', async () => {
+    // Force the 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')
+  })
+})