@bsv/sdk 1.10.2 → 1.10.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.10.2",
+  "version": "1.10.4",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/auth/Peer.ts

@@ -55,6 +55,12 @@ export class Peer {
   { callback: (sessionNonce: string) => void, sessionNonce: string }
   > = new Map()
 
+  // Promise-based mechanism for waiting on certificate validation
+  private readonly certificateValidationPromises: Map<
+  string,
+  { resolve: () => void, reject: (error: Error) => void }
+  > = new Map()
+
   // Single shared counter for all callback types
   private callbackIdCounter: number = 0
 
@@ -644,6 +650,11 @@ export class Peer {
       peerSession.lastUpdate = Date.now()
       this.sessionManager.updateSession(peerSession)
 
+      // Resolve any promises waiting for certificate validation
+      if (peerSession.sessionNonce != null) {
+        this.resolveCertificateValidation(peerSession.sessionNonce)
+      }
+
       this.onCertificatesReceivedCallbacks.forEach(cb =>
         cb(message.identityKey, message.certificates as VerifiableCertificate[])
       )
@@ -834,6 +845,11 @@ export class Peer {
     peerSession.lastUpdate = Date.now()
     this.sessionManager.updateSession(peerSession)
 
+    // Resolve any promises waiting for certificate validation
+    if (peerSession.sessionNonce != null) {
+      this.resolveCertificateValidation(peerSession.sessionNonce)
+    }
+
     // Notify any listeners
     this.onCertificatesReceivedCallbacks.forEach(cb => {
       cb(message.identityKey, message.certificates ?? [])
@@ -869,12 +885,41 @@ export class Peer {
     const certificatesRequired = peerSession.certificatesRequired === true
     const certificatesValidated = peerSession.certificatesValidated === true
 
+    // If certificates are required but not yet validated, wait for them with a timeout
     if (certificatesRequired && !certificatesValidated) {
-      throw new Error(
-        `Received general message before certificate validation from peer ${
-          peerSession.peerIdentityKey ?? 'unknown'
-        }`
-      )
+      const CERTIFICATE_WAIT_TIMEOUT_MS = 30000
+      const sessionNonce = peerSession.sessionNonce
+
+      if (sessionNonce == null) {
+        throw new Error('Session nonce is required for certificate validation')
+      }
+
+      await new Promise<void>((resolve, reject) => {
+        // Set timeout to reject if certificates don't arrive
+        const timeoutId = setTimeout(() => {
+          const promise = this.certificateValidationPromises.get(sessionNonce)
+          if (promise != null) {
+            this.certificateValidationPromises.delete(sessionNonce)
+            reject(new Error(
+              `Timeout waiting for certificate validation from peer ${
+                peerSession.peerIdentityKey ?? 'unknown'
+              }`
+            ))
+          }
+        }, CERTIFICATE_WAIT_TIMEOUT_MS)
+
+        // Store the promise resolvers with timeout cleanup
+        this.certificateValidationPromises.set(sessionNonce, {
+          resolve: () => {
+            clearTimeout(timeoutId)
+            resolve()
+          },
+          reject: (error: Error) => {
+            clearTimeout(timeoutId)
+            reject(error)
+          }
+        })
+      })
     }
 
     const { valid } = await this.wallet.verifySignature({
@@ -904,6 +949,21 @@ export class Peer {
     })
   }
 
+  /**
+   * Resolves any pending certificate validation promises for the given session nonce.
+   * This should be called when certificates have been successfully validated.
+   *
+   * @private
+   * @param {string} sessionNonce - The session nonce to resolve promises for.
+   */
+  private resolveCertificateValidation (sessionNonce: string): void {
+    const promise = this.certificateValidationPromises.get(sessionNonce)
+    if (promise != null) {
+      promise.resolve()
+      this.certificateValidationPromises.delete(sessionNonce)
+    }
+  }
+
   private async getIdentityPublicKey (): Promise<string> {
     if (this.identityPublicKey != null) {
       return this.identityPublicKey

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

@@ -894,12 +894,18 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
       setupPeers(false, true) // Bob requires certs
 
+      // Prevent Alice from auto-sending certificate response
+      // This keeps Bob in "certs required but not validated" state
+      alice.listenForCertificatesRequested(() => {
+        // Intentionally do nothing (no auto-response)
+      })
+
       let received = false
       bob.listenForGeneralMessages(() => {
         received = true
       })
 
-      // Send message — error is thrown internally
+      // Send message — Bob will wait for certificates that never arrive
       try {
         await alice.toPeer(Utils.toArray('Hello Bob!'), bobPubKey)
       } catch {
@@ -909,7 +915,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
       // Allow transport handlers to run
       await new Promise(r => setTimeout(r, 50))
 
-      // Message must NOT be delivered
+      // Message must NOT be delivered since certificates haven't been validated
       expect(received).toBe(false)
     })
 

package/src/auth/clients/AuthFetch.ts

@@ -237,12 +237,27 @@ export class AuthFetch {
         // If the server has a resource that requires certificates to be sent before access would be granted,
         // this makes sure the user has a chance to send the certificates before the resource is requested.
         if (peerToUse.pendingCertificateRequests.length > 0) {
-          await new Promise(resolve => {
-            setInterval(() => {
+          const CERTIFICATE_WAIT_TIMEOUT_MS = 30000
+          const CHECK_INTERVAL_MS = 100
+
+          await new Promise<void>((resolve, reject) => {
+            const startTime = Date.now()
+
+            const checkPending = (): void => {
               if (peerToUse.pendingCertificateRequests.length === 0) {
                 resolve()
+                return
+              }
+
+              if (Date.now() - startTime > CERTIFICATE_WAIT_TIMEOUT_MS) {
+                reject(new Error('Timeout waiting for certificate request to complete'))
+                return
               }
-            }, 100) // Check every 100 ms for the user to finish responding
+
+              setTimeout(checkPending, CHECK_INTERVAL_MS)
+            }
+
+            checkPending()
           })
         }
 

package/src/overlay-tools/__tests/SHIPBroadcaster.test.ts

@@ -339,8 +339,12 @@ describe('SHIPCast', () => {
     })
     const testTx = new Transaction(1, [], [], 0)
 
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { })
+
     const result = await b.broadcast(testTx)
 
+    expect(consoleErrorSpy).toHaveBeenCalled()
+
     expect(result).toEqual({
       status: 'error',
       code: 'ERR_ALL_HOSTS_REJECTED',
@@ -1076,8 +1080,13 @@ describe('SHIPCast', () => {
       resolver: mockResolver as unknown as LookupResolver
     })
     const testTx = new Transaction(1, [], [], 0)
+
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => { })
+
     const response = await b.broadcast(testTx)
 
+    expect(consoleErrorSpy).toHaveBeenCalled()
+
     // Since the host responded (successfully in terms of HTTP), but with invalid data, we should consider it a failure
     expect(response).toEqual({
       status: 'error',

package/src/primitives/ReaderUint8Array.ts

@@ -0,0 +1,196 @@
+import BigNumber from './BigNumber.js'
+import { Reader } from './utils.js'
+
+/**
+ * Reader for serialized Uint8Array binary data.
+ */
+export class ReaderUint8Array {
+  public bin: Uint8Array
+  public pos: number
+  private readonly length: number
+
+  static makeReader (bin: Uint8Array | number[], pos: number = 0): Reader | ReaderUint8Array {
+    if (bin instanceof Uint8Array) {
+      return new ReaderUint8Array(bin, pos)
+    }
+    if (Array.isArray(bin)) {
+      return new Reader(bin, pos)
+    }
+    throw new Error('ReaderUint8Array.makeReader: bin must be Uint8Array or number[]')
+  }
+
+  constructor (bin: Uint8Array | number[] = new Uint8Array(0), pos: number = 0) {
+    if (bin instanceof Uint8Array) {
+      this.bin = bin
+    } else if (Array.isArray(bin)) {
+      this.bin = new Uint8Array(bin)
+    } else {
+      throw new Error('ReaderUint8Array constructor: bin must be Uint8Array or number[]')
+    }
+    this.pos = pos
+    this.length = this.bin.length
+  }
+
+  public eof (): boolean {
+    return this.pos >= this.length
+  }
+
+  public read (len = this.length): Uint8Array {
+    const start = this.pos
+    const end = this.pos + len
+    this.pos = end
+    return this.bin.slice(start, end)
+  }
+
+  public readReverse (len = this.length): Uint8Array {
+    const buf2 = new Uint8Array(len)
+    for (let i = 0; i < len; i++) {
+      buf2[i] = this.bin[this.pos + len - 1 - i]
+    }
+    this.pos += len
+    return buf2
+  }
+
+  public readUInt8 (): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    return val
+  }
+
+  public readInt8 (): number {
+    const val = this.bin[this.pos]
+    this.pos += 1
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80) !== 0 ? val - 0x100 : val
+  }
+
+  public readUInt16BE (): number {
+    const val = (this.bin[this.pos] << 8) | this.bin[this.pos + 1]
+    this.pos += 2
+    return val
+  }
+
+  public readInt16BE (): number {
+    const val = this.readUInt16BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x8000) !== 0 ? val - 0x10000 : val
+  }
+
+  public readUInt16LE (): number {
+    const val = this.bin[this.pos] | (this.bin[this.pos + 1] << 8)
+    this.pos += 2
+    return val
+  }
+
+  public readInt16LE (): number {
+    const val = this.readUInt16LE()
+    // If the sign bit is set, convert to negative value
+    const x = (val & 0x8000) !== 0 ? val - 0x10000 : val
+    return x
+  }
+
+  public readUInt32BE (): number {
+    const val =
+      this.bin[this.pos] * 0x1000000 + // Shift the first byte by 24 bits
+      ((this.bin[this.pos + 1] << 16) | // Shift the second byte by 16 bits
+        (this.bin[this.pos + 2] << 8) | // Shift the third byte by 8 bits
+        this.bin[this.pos + 3]) // The fourth byte
+    this.pos += 4
+    return val
+  }
+
+  public readInt32BE (): number {
+    const val = this.readUInt32BE()
+    // If the sign bit is set, convert to negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt32LE (): number {
+    const val =
+      (this.bin[this.pos] |
+        (this.bin[this.pos + 1] << 8) |
+        (this.bin[this.pos + 2] << 16) |
+        (this.bin[this.pos + 3] << 24)) >>>
+      0
+    this.pos += 4
+    return val
+  }
+
+  public readInt32LE (): number {
+    const val = this.readUInt32LE()
+    // Explicitly check if the sign bit is set and then convert to a negative value
+    return (val & 0x80000000) !== 0 ? val - 0x100000000 : val
+  }
+
+  public readUInt64BEBn (): BigNumber {
+    const bin = Array.from(this.bin.slice(this.pos, this.pos + 8))
+    const bn = new BigNumber(bin)
+    this.pos = this.pos + 8
+    return bn
+  }
+
+  public readUInt64LEBn (): BigNumber {
+    const bin = Array.from(this.readReverse(8))
+    const bn = new BigNumber(bin)
+    return bn
+  }
+
+  public readInt64LEBn (): BigNumber {
+    const OverflowInt64 = new BigNumber(2).pow(new BigNumber(63))
+    const OverflowUint64 = new BigNumber(2).pow(new BigNumber(64))
+    const bin = Array.from(this.readReverse(8))
+    let bn = new BigNumber(bin)
+    if (bn.gte(OverflowInt64)) {
+      bn = bn.sub(OverflowUint64) // Adjust for negative numbers
+    }
+    return bn
+  }
+
+  public readVarIntNum (signed: boolean = true): number {
+    const first = this.readUInt8()
+    let bn: BigNumber
+    switch (first) {
+      case 0xfd:
+        return this.readUInt16LE()
+      case 0xfe:
+        return this.readUInt32LE()
+      case 0xff:
+        bn = signed ? this.readInt64LEBn() : this.readUInt64LEBn()
+        if (bn.lte(new BigNumber(2).pow(new BigNumber(53)))) {
+          return bn.toNumber()
+        } else {
+          throw new Error('number too large to retain precision - use readVarIntBn')
+        }
+      default:
+        return first
+    }
+  }
+
+  public readVarInt (): Uint8Array {
+    const first = this.bin[this.pos]
+    switch (first) {
+      case 0xfd:
+        return this.read(1 + 2)
+      case 0xfe:
+        return this.read(1 + 4)
+      case 0xff:
+        return this.read(1 + 8)
+      default:
+        return this.read(1)
+    }
+  }
+
+  public readVarIntBn (): BigNumber {
+    const first = this.readUInt8()
+    switch (first) {
+      case 0xfd:
+        return new BigNumber(this.readUInt16LE())
+      case 0xfe:
+        return new BigNumber(this.readUInt32LE())
+      case 0xff:
+        return this.readUInt64LEBn()
+      default:
+        return new BigNumber(first)
+    }
+  }
+}

package/src/primitives/WriterUint8Array.ts

@@ -0,0 +1,195 @@
+import BigNumber from './BigNumber.js'
+import { Writer } from './utils.js'
+
+type WriterChunk = readonly number[] | Uint8Array
+
+/**
+ * WriterUint8Array is a utility class for writing binary data into a dynamically
+ * growing Uint8Array buffer. It provides methods to write various integer types
+ * and variable-length integers, similar to the Writer class but optimized for
+ * Uint8Array usage.
+ */
+export class WriterUint8Array {
+  private buffer: Uint8Array
+  private pos: number
+  private capacity: number
+
+  constructor (bufs?: WriterChunk[], initialCapacity: number = 256) {
+    if ((bufs != null) && bufs.length > 0) {
+      const totalLength = bufs.reduce((sum, buf) => sum + buf.length, 0)
+      initialCapacity = Math.max(initialCapacity, totalLength)
+    }
+    this.buffer = new Uint8Array(initialCapacity)
+    this.pos = 0
+    this.capacity = initialCapacity
+    if (bufs != null) {
+      for (const buf of bufs) {
+        this.write(buf)
+      }
+    }
+  }
+
+  /**
+   * Returns the current length of written data
+   */
+  getLength (): number {
+    return this.pos
+  }
+
+  /**
+   * @return the written data as Uint8Array copy of the internal buffer
+   */
+  toUint8Array (): Uint8Array {
+    return this.buffer.slice(0, this.pos)
+  }
+
+  /**
+   * Legacy compatibility method – returns number[] (Byte[])
+   */
+  toArray (): number[] {
+    return Array.from(this.toUint8Array())
+  }
+
+  /**
+   * @return the written data as Uint8Array. CAUTION: This is zero-copy subarray of the internal buffer).
+   */
+  toUint8ArrayZeroCopy (): Uint8Array {
+    return this.buffer.subarray(0, this.pos)
+  }
+
+  private ensureCapacity (needed: number): void {
+    if (this.pos + needed > this.capacity) {
+      let newCapacity = this.capacity * 2
+      while (this.pos + needed > newCapacity) {
+        newCapacity *= 2
+      }
+      const newBuffer = new Uint8Array(newCapacity)
+      newBuffer.set(this.buffer)
+      this.buffer = newBuffer
+      this.capacity = newCapacity
+    }
+  }
+
+  write (bytes: WriterChunk): this {
+    const data = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes)
+    this.ensureCapacity(data.length)
+    this.buffer.set(data, this.pos)
+    this.pos += data.length
+    return this
+  }
+
+  writeReverse (buf: WriterChunk): this {
+    const data = buf instanceof Uint8Array ? buf : new Uint8Array(buf)
+    this.ensureCapacity(data.length)
+    for (let i = data.length - 1; i >= 0; i--) {
+      this.buffer[this.pos] = data[i]
+      this.pos += 1
+    }
+    return this
+  }
+
+  writeUInt8 (value: number): this {
+    this.ensureCapacity(1)
+    this.buffer[this.pos] = value & 0xff
+    this.pos += 1
+    return this
+  }
+
+  writeInt8 (value: number): this {
+    this.writeUInt8(value)
+    return this
+  }
+
+  writeUInt16LE (value: number): this {
+    this.ensureCapacity(2)
+    this.buffer[this.pos] = value & 0xff
+    this.buffer[this.pos + 1] = (value >> 8) & 0xff
+    this.pos += 2
+    return this
+  }
+
+  writeUInt16BE (value: number): this {
+    this.ensureCapacity(2)
+    this.buffer[this.pos] = (value >> 8) & 0xff
+    this.buffer[this.pos + 1] = value & 0xff
+    this.pos += 2
+    return this
+  }
+
+  writeInt16LE (value: number): this {
+    this.writeUInt16LE(value & 0xffff)
+    return this
+  }
+
+  writeInt16BE (value: number): this {
+    this.writeUInt16BE(value & 0xffff)
+    return this
+  }
+
+  writeUInt32LE (value: number): this {
+    this.ensureCapacity(4)
+    this.buffer[this.pos] = value & 0xff
+    this.buffer[this.pos + 1] = (value >> 8) & 0xff
+    this.buffer[this.pos + 2] = (value >> 16) & 0xff
+    this.buffer[this.pos + 3] = (value >> 24) & 0xff
+    this.pos += 4
+    return this
+  }
+
+  writeUInt32BE (value: number): this {
+    this.ensureCapacity(4)
+    this.buffer[this.pos] = (value >> 24) & 0xff
+    this.buffer[this.pos + 1] = (value >> 16) & 0xff
+    this.buffer[this.pos + 2] = (value >> 8) & 0xff
+    this.buffer[this.pos + 3] = value & 0xff
+    this.pos += 4
+    return this
+  }
+
+  writeInt32LE (value: number): this {
+    this.writeUInt32LE(value >>> 0)
+    return this
+  }
+
+  writeInt32BE (value: number): this {
+    this.writeUInt32BE(value >>> 0)
+    return this
+  }
+
+  writeUInt64BEBn (bn: BigNumber): this {
+    const buf = bn.toArray('be', 8)
+    this.write(buf)
+    return this
+  }
+
+  writeUInt64LEBn (bn: BigNumber): this {
+    const buf = bn.toArray('be', 8)
+    this.writeReverse(buf)
+    return this
+  }
+
+  writeUInt64LE (n: number): this {
+    const buf = new BigNumber(n).toArray('be', 8)
+    this.writeReverse(buf)
+    return this
+  }
+
+  writeVarIntNum (n: number): this {
+    const buf = Writer.varIntNum(n)
+    this.write(buf)
+    return this
+  }
+
+  writeVarIntBn (bn: BigNumber): this {
+    const buf = Writer.varIntBn(bn)
+    this.write(buf)
+    return this
+  }
+
+  /**
+   * Resets the writer to empty state (reuses the buffer)
+   */
+  reset (): void {
+    this.pos = 0
+  }
+}