@bsv/sdk 1.3.35 → 1.3.36

package/package.json

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

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

@@ -211,15 +211,13 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Bob received message:', Utils.toUTF8(payload))
           await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
           resolve()
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
     const aliceReceivedGeneralMessage = new Promise<void>((resolve) => {
       alice.listenForGeneralMessages((senderPublicKey, payload) => {
-        console.log('Alice received message:', Utils.toUTF8(payload))
         resolve()
       })
     })
@@ -260,29 +258,26 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     const bobReceivedGeneralMessage = new Promise<void>((resolve) => {
       bob.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Bob 1 received message:', Utils.toUTF8(payload))
           await bob.toPeer(Utils.toArray('Hello Alice!'), senderPublicKey)
           resolve()
           bobMessageHandler(senderPublicKey, payload)
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
     let aliceReceivedGeneralMessageOnFirstDevice = new Promise<void>((resolve) => {
       aliceFirstDevice.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Alice 1 received message:', Utils.toUTF8(payload))
           resolve()
           alice1MessageHandler(senderPublicKey, payload)
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
     const aliceReceivedGeneralMessageOnOtherDevice = new Promise<void>((resolve) => {
       aliceOtherDevice.listenForGeneralMessages((senderPublicKey, payload) => {
         (async () => {
-          console.log('Alice 2 received message:', Utils.toUTF8(payload))
           resolve()
           alice2MessageHandler(senderPublicKey, payload)
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 
@@ -333,10 +328,10 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             // Use a for...of loop instead of forEach with an async callback.
             for (const cert of certificatesReceivedByBob) {
               // Decrypt to ensure it has the correct fields.
-              const decryptedFields = await cert.decryptFields(walletB)
+              // const decryptedFields = await cert.decryptFields(walletB)
               if (cert.certifier !== 'bob') {
-                console.log('Bob accepted the message:', Utils.toUTF8(payload))
-                console.log('Decrypted fields:', decryptedFields)
+                // console.log('Bob accepted the message:', Utils.toUTF8(payload))
+                // console.log('Decrypted fields:', decryptedFields)
               }
             }
           }
@@ -640,7 +635,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       }
       )
     })
@@ -658,7 +653,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       }
       )
     })
@@ -672,7 +667,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
             senderPublicKey
           )
           resolve()
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 
@@ -766,7 +761,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 
@@ -783,7 +778,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
               resolve()
             }
           }
-        })().catch(e => console.log(e))
+        })().catch(e => { })
       })
     })
 

package/src/auth/clients/AuthFetch.ts

@@ -6,14 +6,21 @@ import { SessionManager } from '../SessionManager.js'
 import { RequestedCertificateSet } from '../types.js'
 import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
 import { Writer } from '../../primitives/utils.js'
+import { getVerifiableCertificates } from '../utils/index.js'
 
-type SimplifiedFetchRequestOptions = {
-  method?: string,
-  headers?: Record<string, string>,
-  body?: any,
+interface SimplifiedFetchRequestOptions {
+  method?: string
+  headers?: Record<string, string>
+  body?: any
   retryCounter?: number
 }
-type AuthPeer = { peer: Peer, identityKey?: string, supportsMutualAuth?: boolean }
+
+interface AuthPeer {
+  peer: Peer
+  identityKey?: string
+  supportsMutualAuth?: boolean
+  pendingCertificateRequests: Array<true>
+}
 
 const PAYMENT_VERSION = '1.0'
 
@@ -26,11 +33,11 @@ const PAYMENT_VERSION = '1.0'
  * and sending BSV payment transactions when necessary.
  */
 export class AuthFetch {
-  private sessionManager: SessionManager
-  private wallet: WalletInterface
+  private readonly sessionManager: SessionManager
+  private readonly wallet: WalletInterface
   private callbacks: Record<string, { resolve: Function, reject: Function }> = {}
-  private certificatesReceived: VerifiableCertificate[] = []
-  private requestedCertificates?: RequestedCertificateSet
+  private readonly certificatesReceived: VerifiableCertificate[] = []
+  private readonly requestedCertificates?: RequestedCertificateSet
   peers: Record<string, AuthPeer> = {}
 
   /**
@@ -58,7 +65,7 @@ export class AuthFetch {
    * @throws Will throw an error if unsupported headers are used or other validation fails.
    */
   async fetch(url: string, config: SimplifiedFetchRequestOptions = {}): Promise<Response> {
-    if (config.retryCounter) {
+    if (typeof config.retryCounter === 'number') {
       if (config.retryCounter <= 0) {
         throw new Error('Request failed after maximum number of retries.')
       }
@@ -79,13 +86,28 @@ export class AuthFetch {
           // Create a peer for the request
           const newTransport = new SimplifiedFetchTransport(baseURL)
           peerToUse = {
-            peer: new Peer(this.wallet, newTransport, this.requestedCertificates, this.sessionManager)
+            peer: new Peer(this.wallet, newTransport, this.requestedCertificates, this.sessionManager),
+            pendingCertificateRequests: []
           }
           this.peers[baseURL] = peerToUse
-          const callbackId = this.peers[baseURL].peer.listenForCertificatesReceived((senderPublicKey: string, certs: VerifiableCertificate[]) => {
+          this.peers[baseURL].peer.listenForCertificatesReceived((senderPublicKey: string, certs: VerifiableCertificate[]) => {
             this.certificatesReceived.push(...certs)
-            // peerToUse.peer.stopListeningForCertificatesReceived()
           })
+          this.peers[baseURL].peer.listenForCertificatesRequested((async (verifier: string, requestedCertificates: RequestedCertificateSet) => {
+            try {
+              this.peers[baseURL].pendingCertificateRequests.push(true)
+              const certificatesToInclude = await getVerifiableCertificates(
+                this.wallet,
+                requestedCertificates,
+                verifier
+              )
+              await this.peers[baseURL].peer.sendCertificateResponse(verifier, certificatesToInclude)
+            } finally {
+              // Give the backend 500 ms to process the certificates we just sent, before releasing the queue entry
+              await new Promise(resolve => setTimeout(resolve, 500))
+              this.peers[baseURL].pendingCertificateRequests.shift()
+            }
+          }) as Function)
         } else {
           // Check if there's a session associated with this baseURL
           if (this.peers[baseURL].supportsMutualAuth === false) {
@@ -174,6 +196,20 @@ export class AuthFetch {
           delete this.callbacks[requestNonceAsBase64]
         })
 
+        // Before sending general messages to the peer, ensure that no certificate requests are pending.
+        // This way, the user would need to choose to either allow or reject the certificate request first.
+        // 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(() => {
+              if (peerToUse.pendingCertificateRequests.length === 0) {
+                resolve()
+              }
+            }, 100) // Check every 100 ms for the user to finish responding
+          })
+        }
+
         // Send the request, now that all listeners are set up
         await peerToUse.peer.toPeer(writer.toArray(), peerToUse.identityKey).catch(async error => {
           if (error.message.includes('Session not found for nonce')) {
@@ -217,7 +253,7 @@ export class AuthFetch {
     const baseURL = parsedUrl.origin
 
     let peerToUse: { peer: Peer; identityKey?: string }
-    if (this.peers[baseURL]) {
+    if (typeof this.peers[baseURL] !== 'undefined') {
       peerToUse = { peer: this.peers[baseURL].peer }
     } else {
       const newTransport = new SimplifiedFetchTransport(baseURL)
@@ -233,7 +269,7 @@ export class AuthFetch {
     }
 
     // Return a promise that resolves when certificates are received
-    return new Promise<VerifiableCertificate[]>(async (resolve, reject) => {
+    return await new Promise<VerifiableCertificate[]>((async (resolve, reject) => {
       // Set up the listener before making the request
       const callbackId = peerToUse.peer.listenForCertificatesReceived((_senderPublicKey: string, certs: VerifiableCertificate[]) => {
         peerToUse.peer.stopListeningForCertificatesReceived(callbackId)
@@ -248,7 +284,7 @@ export class AuthFetch {
         peerToUse.peer.stopListeningForCertificatesReceived(callbackId)
         reject(err)
       }
-    })
+    }) as Function)
   }
 
   /**
@@ -513,4 +549,4 @@ export class AuthFetch {
     // 9. Fallback
     throw new Error('Unsupported body type in this SimplifiedFetch implementation.')
   }
-}
+}

package/src/auth/transports/SimplifiedFetchTransport.ts

@@ -42,25 +42,38 @@ export class SimplifiedFetchTransport implements Transport {
     if (!this.onDataCallback) {
       throw new Error('Listen before you start speaking. God gave you two ears and one mouth for a reason.')
     }
-
     if (message.messageType !== 'general') {
-      const response = await this.fetchClient(`${this.baseUrl}/.well-known/auth`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(message)
-      })
-      // Handle the response if data is received and callback is set
-      if (response.ok && this.onDataCallback) {
-        const responseMessage = await response.json()
-        if (responseMessage?.status !== 'certificate received') {
-          this.onDataCallback(responseMessage as AuthMessage)
+      return new Promise(async (resolve, reject) => {
+        try {
+          const responsePromise = this.fetchClient(`${this.baseUrl}/.well-known/auth`, {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(message)
+          })
+
+          if (message.messageType !== "initialRequest") {
+            resolve()
+          }
+          const response = await responsePromise
+
+          // Handle the response if data is received and callback is set
+          if (response.ok && this.onDataCallback) {
+            const responseMessage = await response.json()
+            this.onDataCallback(responseMessage as AuthMessage)
+          } else {
+            // Server may be a non authenticated server
+            throw new Error('HTTP server failed to authenticate')
+          }
+          if (message.messageType === "initialRequest") {
+            resolve()
+          }
+        } catch (e) {
+          reject(e)
+          return
         }
-      } else {
-        // Server may be a non authenticated server
-        throw new Error('HTTP server failed to authenticate')
-      }
+      })
     } else {
       // Parse message payload
       const httpRequest = this.deserializeRequestPayload(message.payload)
@@ -105,7 +118,6 @@ export class SimplifiedFetchTransport implements Transport {
         }
       }
 
-
       // Send the actual fetch request to the server
       const response = await this.fetchClient(url, {
         method: httpRequestWithAuthHeaders.method,

package/src/auth/utils/__tests/cryptononce.test.ts

@@ -141,8 +141,6 @@ describe('verifyNonce', () => {
       counterparty: (await serverWallet.getPublicKey({ identityKey: true }))
         .publicKey
     })
-
-    console.log(Utils.toBase64(serialNumber))
     expect(valid).toEqual(true)
   })
 })

package/src/transaction/__tests/Transaction.benchmarks.test.ts

@@ -9,7 +9,7 @@ import MerklePath from '../MerklePath'
 jest.setTimeout(60000) // Increase timeout for benchmarking tests if necessary
 
 // Helper function to measure execution time
-async function measureTime (fn: () => Promise<void>): Promise<number> {
+async function measureTime(fn: () => Promise<void>): Promise<number> {
   const start = process.hrtime()
   await fn()
   const diff = process.hrtime(start)
@@ -113,11 +113,6 @@ describe('Transaction Verification Benchmark', () => {
       const verified = await tx.verify('scripts only')
       expect(verified).toBe(true)
     })
-    console.log(
-      `Verification time for wide transaction with ${inputCount} inputs: ${timeTaken.toFixed(
-        2
-      )} ms`
-    )
   })
 
   it('verifies a large transaction with many inputs and outputs', async () => {
@@ -172,11 +167,6 @@ describe('Transaction Verification Benchmark', () => {
       const verified = await tx.verify('scripts only')
       expect(verified).toBe(true)
     })
-    console.log(
-      `Verification time for large transaction with ${inputCount} inputs and ${outputCount} outputs: ${timeTaken.toFixed(
-        2
-      )} ms`
-    )
   })
 
   it('verifies a transaction with nested inputs (complex graph)', async () => {
@@ -243,10 +233,5 @@ describe('Transaction Verification Benchmark', () => {
       const verified = await finalTx.verify('scripts only')
       expect(verified).toBe(true)
     })
-    console.log(
-      `Verification time for nested inputs with depth ${depth} and fan-out ${fanOut}: ${timeTaken.toFixed(
-        2
-      )} ms`
-    )
   })
 })