@bsv/sdk 1.5.3 → 1.6.1

package/package.json

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

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

@@ -8,6 +8,10 @@ import { MasterCertificate } from '../../auth/certificates/MasterCertificate.js'
 import { getVerifiableCertificates } from '../../auth/utils/getVerifiableCertificates.js'
 import { CompletedProtoWallet } from '../certificates/__tests/CompletedProtoWallet.js'
 
+const certifierPrivKey = new PrivateKey(21)
+const alicePrivKey = new PrivateKey(22)
+const bobPrivKey = new PrivateKey(23)
+
 jest.mock('../../auth/utils/getVerifiableCertificates')
 
 class LocalTransport implements Transport {
@@ -40,6 +44,19 @@ class LocalTransport implements Transport {
   }
 }
 
+function waitForNextGeneralMessage (
+  peer: Peer,
+  handler?: (senderPublicKey: string, payload: number[]) => void
+): Promise<void> {
+  return new Promise(resolve => {
+    const listenerId = peer.listenForGeneralMessages((senderPublicKey, payload) => {
+      peer.stopListeningForGeneralMessages(listenerId)
+      if (handler !== undefined) handler(senderPublicKey, payload)
+      resolve()
+    })
+  })
+}
+
 describe('Peer class mutual authentication and certificate exchange', () => {
   let walletA: WalletInterface, walletB: WalletInterface
   let transportA: LocalTransport, transportB: LocalTransport
@@ -49,7 +66,7 @@ describe('Peer class mutual authentication and certificate exchange', () => {
 
   const certificateType = Utils.toBase64(new Array(32).fill(1))
   // const certificateSerialNumber = Utils.toBase64(new Array(32).fill(2))
-  const certifierPrivateKey = PrivateKey.fromRandom()
+  const certifierPrivateKey = certifierPrivKey
   const certifierPublicKey = certifierPrivateKey.toPublicKey().toString()
   const certificatesToRequest = {
     certifiers: [certifierPublicKey],
@@ -198,8 +215,8 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     certificatesReceivedByAlice = []
     certificatesReceivedByBob = []
 
-    walletA = new CompletedProtoWallet(PrivateKey.fromRandom())
-    walletB = new CompletedProtoWallet(PrivateKey.fromRandom())
+    walletA = new CompletedProtoWallet(alicePrivKey)
+    walletB = new CompletedProtoWallet(bobPrivKey)
   })
 
   it('Neither Alice nor Bob request certificates, mutual authentication completes successfully', async () => {
@@ -235,10 +252,10 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     const transportA2 = new LocalTransport()
     const transportB = new LocalTransport()
     transportA1.connect(transportB)
-    const aliceKey = PrivateKey.fromRandom()
+    const aliceKey = alicePrivKey
     const walletA1 = new CompletedProtoWallet(aliceKey)
     const walletA2 = new CompletedProtoWallet(aliceKey)
-    const walletB = new CompletedProtoWallet(PrivateKey.fromRandom())
+    const walletB = new CompletedProtoWallet(alicePrivKey)
     const aliceFirstDevice = new Peer(
       walletA1,
       transportA1
@@ -264,22 +281,14 @@ describe('Peer class mutual authentication and certificate exchange', () => {
         })().catch(e => { })
       })
     })
-    let aliceReceivedGeneralMessageOnFirstDevice = new Promise<void>((resolve) => {
-      aliceFirstDevice.listenForGeneralMessages((senderPublicKey, payload) => {
-        (async () => {
-          resolve()
-          alice1MessageHandler(senderPublicKey, payload)
-        })().catch(e => { })
-      })
-    })
-    const aliceReceivedGeneralMessageOnOtherDevice = new Promise<void>((resolve) => {
-      aliceOtherDevice.listenForGeneralMessages((senderPublicKey, payload) => {
-        (async () => {
-          resolve()
-          alice2MessageHandler(senderPublicKey, payload)
-        })().catch(e => { })
-      })
-    })
+    const aliceReceivedGeneralMessageOnFirstDevice = waitForNextGeneralMessage(
+      aliceFirstDevice,
+      alice1MessageHandler
+    )
+    const aliceReceivedGeneralMessageOnOtherDevice = waitForNextGeneralMessage(
+      aliceOtherDevice,
+      alice2MessageHandler
+    )
 
     await aliceFirstDevice.toPeer(Utils.toArray('Hello Bob!'))
     await bobReceivedGeneralMessage
@@ -288,8 +297,14 @@ describe('Peer class mutual authentication and certificate exchange', () => {
     await aliceOtherDevice.toPeer(Utils.toArray('Hello Bob from my other device!'))
     await aliceReceivedGeneralMessageOnOtherDevice
     transportA1.connect(transportB)
-    await aliceFirstDevice.toPeer(Utils.toArray('Back on my first device now, Bob! Can you still hear me?'))
-    await new Promise(resolve => setTimeout(resolve, 2000))
+    const waitForSecondMessage = waitForNextGeneralMessage(
+      aliceFirstDevice,
+      alice1MessageHandler
+    )
+    await aliceFirstDevice.toPeer(
+      Utils.toArray('Back on my first device now, Bob! Can you still hear me?')
+    )
+    await waitForSecondMessage
     expect(alice1MessageHandler.mock.calls.length).toEqual(2)
   }, 30000)
 

package/src/auth/certificates/__tests/MasterCertificate.test.ts

@@ -3,23 +3,30 @@ import { VerifiableCertificate } from '../../../auth/certificates/VerifiableCert
 import { PrivateKey, SymmetricKey, Utils, Random } from '../../../../mod'
 import { CompletedProtoWallet } from '../../../auth/certificates/__tests/CompletedProtoWallet'
 
+const subjectPrivateKey = new PrivateKey(21)
+const certifierPrivateKey = new PrivateKey(22)
+
+const fieldSymFixed1 = new SymmetricKey(51)
+const fieldSymWrong = new SymmetricKey(61)
+
+const subjectKey2 = new PrivateKey(71)
+const verifierKey2 = new PrivateKey(81)
+
+// A mock revocation outpoint for testing
+const mockRevocationOutpoint =
+  'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
+
+// Arbitrary certificate data (in plaintext)
+const plaintextFields = {
+  name: 'Alice',
+  email: 'alice@example.com',
+  department: 'Engineering'
+}
+
+const subjectWallet = new CompletedProtoWallet(subjectPrivateKey)
+const certifierWallet = new CompletedProtoWallet(certifierPrivateKey)
+
 describe('MasterCertificate', () => {
-  const subjectPrivateKey = PrivateKey.fromRandom()
-  const certifierPrivateKey = PrivateKey.fromRandom()
-
-  // A mock revocation outpoint for testing
-  const mockRevocationOutpoint =
-    'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
-
-  // Arbitrary certificate data (in plaintext)
-  const plaintextFields = {
-    name: 'Alice',
-    email: 'alice@example.com',
-    department: 'Engineering'
-  }
-
-  const subjectWallet = new CompletedProtoWallet(subjectPrivateKey)
-  const certifierWallet = new CompletedProtoWallet(certifierPrivateKey)
   let subjectIdentityKey: string
   let certifierIdentityKey: string
 
@@ -35,7 +42,7 @@ describe('MasterCertificate', () => {
   describe('constructor', () => {
     it('should construct a MasterCertificate successfully when masterKeyring is valid', () => {
       // Prepare a minimal valid MasterCertificate
-      const fieldSymKey = SymmetricKey.fromRandom()
+      const fieldSymKey = fieldSymFixed1
       const encryptedFieldValue = Utils.toBase64(
         fieldSymKey.encrypt(Utils.toArray('Alice', 'utf8')) as number[]
       )
@@ -129,7 +136,7 @@ describe('MasterCertificate', () => {
         mockRevocationOutpoint,
         {
           name: Utils.toBase64(
-            SymmetricKey.fromRandom().encrypt(
+            fieldSymWrong.encrypt(
               Utils.toArray('Alice', 'utf8')
             ) as number[]
           )
@@ -149,7 +156,7 @@ describe('MasterCertificate', () => {
   })
 
   describe('createKeyringForVerifier (static)', () => {
-    const verifierPrivateKey = PrivateKey.fromRandom()
+    const verifierPrivateKey = verifierKey2
     const verifierWallet = new CompletedProtoWallet(verifierPrivateKey)
     let verifierIdentityKey: string
 
@@ -350,7 +357,7 @@ describe('MasterCertificate', () => {
     })
     it('should allow issuing a self-signed certificate and decrypt it with the same wallet', async () => {
       // In a self-signed scenario, the subject and certifier are the same
-      const subjectWallet = new CompletedProtoWallet(PrivateKey.fromRandom())
+      const subjectWallet = new CompletedProtoWallet(subjectKey2)
 
       // Some sample fields
       const selfSignedFields = {

package/src/auth/certificates/__tests/VerifiableCertificate.test.ts

@@ -5,28 +5,31 @@ import { CompletedProtoWallet } from '../../../auth/certificates/__tests/Complet
 import { MasterCertificate } from '../../../auth/certificates/MasterCertificate'
 import { ProtoWallet, WalletCertificate } from '../../../wallet/index'
 
-describe('VerifiableCertificate', () => {
-  const subjectPrivateKey = PrivateKey.fromRandom()
-  const subjectIdentityKey = subjectPrivateKey.toPublicKey().toString()
-  const certifierPrivateKey = PrivateKey.fromRandom()
-  const certifierIdentityKey = certifierPrivateKey.toPublicKey().toString()
-  const verifierPrivateKey = PrivateKey.fromRandom()
-  const verifierIdentityKey = verifierPrivateKey.toPublicKey().toString()
-
-  const subjectWallet = new CompletedProtoWallet(subjectPrivateKey)
-  const verifierWallet = new CompletedProtoWallet(verifierPrivateKey)
-
-  const sampleType = Utils.toBase64(new Array(32).fill(1))
-  const sampleSerialNumber = Utils.toBase64(new Array(32).fill(2))
-  const sampleRevocationOutpoint =
-    'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
-
-  const plaintextFields = {
-    name: 'Alice',
-    email: 'alice@example.com',
-    organization: 'Example Corp'
-  }
+const subjectPrivateKey = new PrivateKey(21)
+const subjectIdentityKey = subjectPrivateKey.toPublicKey().toString()
+const certifierPrivateKey = new PrivateKey(22)
+const certifierIdentityKey = certifierPrivateKey.toPublicKey().toString()
+const verifierPrivateKey = new PrivateKey(23)
+const verifierIdentityKey = verifierPrivateKey.toPublicKey().toString()
+
+const wrongPrivateKey = new PrivateKey(31)
+const wrongWallet = new CompletedProtoWallet(wrongPrivateKey)
+
+const subjectWallet = new CompletedProtoWallet(subjectPrivateKey)
+const verifierWallet = new CompletedProtoWallet(verifierPrivateKey)
+
+const sampleType = Utils.toBase64(new Array(32).fill(1))
+const sampleSerialNumber = Utils.toBase64(new Array(32).fill(2))
+const sampleRevocationOutpoint =
+  'deadbeefdeadbeefdeadbeefdeadbeef00000000000000000000000000000000.1'
+
+const plaintextFields = {
+  name: 'Alice',
+  email: 'alice@example.com',
+  organization: 'Example Corp'
+}
 
+describe('VerifiableCertificate', () => {
   let verifiableCert: VerifiableCertificate
 
   beforeEach(async () => {
@@ -79,9 +82,6 @@ describe('VerifiableCertificate', () => {
     })
 
     it('should fail if the verifier wallet does not have the correct private key (wrong key)', async () => {
-      const wrongPrivateKey = PrivateKey.fromRandom()
-      const wrongWallet = new CompletedProtoWallet(wrongPrivateKey)
-
       await expect(verifiableCert.decryptFields(wrongWallet)).rejects.toThrow(
         /Failed to decrypt selectively revealed certificate fields using keyring/
       )

package/src/overlay-tools/LookupResolver.ts

@@ -27,12 +27,9 @@ export type LookupAnswer =
     outputs: Array<{
       beef: number[]
       outputIndex: number
+      context?: number[]
     }>
   }
-  | {
-    type: 'freeform'
-    result: unknown
-  }
 
 /** Default SLAP trackers */
 export const DEFAULT_SLAP_TRACKERS: string[] = [
@@ -200,11 +197,6 @@ export default class LookupResolver {
     }
 
     // Process the successful responses
-    if (successfulResponses[0].type === 'freeform') {
-      // Return the first freeform response
-      return successfulResponses[0]
-    }
-
     // Aggregate outputs from all successful responses
     const outputs = new Map<string, { beef: number[], outputIndex: number }>()
 

package/src/overlay-tools/SHIPBroadcaster.ts

@@ -16,6 +16,7 @@ import OverlayAdminTokenTemplate from './OverlayAdminTokenTemplate.js'
 export interface TaggedBEEF {
   beef: number[]
   topics: string[]
+  offChainValues?: number[]
 }
 
 /**
@@ -86,7 +87,6 @@ export class HTTPSOverlayBroadcastFacilitator implements OverlayBroadcastFacilit
   }
 
   async send (url: string, taggedBEEF: TaggedBEEF): Promise<STEAK> {
-    console.log(url)
     if (!url.startsWith('https:') && !this.allowHTTP) {
       throw new Error(
         'HTTPS facilitator can only use URLs that start with "https:"'
@@ -164,7 +164,6 @@ export default class TopicBroadcaster implements Broadcaster {
       )
     }
     const interestedHosts = await this.findInterestedHosts()
-    console.log(interestedHosts)
     if (Object.keys(interestedHosts).length === 0) {
       return {
         status: 'error',

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

@@ -620,118 +620,6 @@ describe('LookupResolver', () => {
     ])
   })
 
-  it('should handle hosts returning different response types', async () => {
-    const slapHostKey1 = new PrivateKey(42)
-    const slapWallet1 = new CompletedProtoWallet(slapHostKey1)
-    const slapLib1 = new OverlayAdminTokenTemplate(slapWallet1)
-    const slapScript1 = await slapLib1.lock(
-      'SLAP',
-      'https://slaphost1.com',
-      'ls_foo'
-    )
-    const slapTx1 = new Transaction(
-      1,
-      [],
-      [
-        {
-          lockingScript: slapScript1,
-          satoshis: 1
-        }
-      ],
-      0
-    )
-
-    const slapHostKey2 = new PrivateKey(43)
-    const slapWallet2 = new CompletedProtoWallet(slapHostKey2)
-    const slapLib2 = new OverlayAdminTokenTemplate(slapWallet2)
-    const slapScript2 = await slapLib2.lock(
-      'SLAP',
-      'https://slaphost2.com',
-      'ls_foo'
-    )
-    const slapTx2 = new Transaction(
-      1,
-      [],
-      [
-        {
-          lockingScript: slapScript2,
-          satoshis: 1
-        }
-      ],
-      0
-    )
-
-    // SLAP tracker returns two hosts
-    mockFacilitator.lookup.mockReturnValueOnce({
-      type: 'output-list',
-      outputs: [
-        { outputIndex: 0, beef: slapTx1.toBEEF() },
-        { outputIndex: 0, beef: slapTx2.toBEEF() }
-      ]
-    })
-
-    // First host returns 'freeform' response
-    mockFacilitator.lookup.mockReturnValueOnce({
-      type: 'freeform',
-      result: { message: 'Freeform response from host1' }
-    })
-
-    // Second host returns 'output-list' response
-    mockFacilitator.lookup.mockReturnValueOnce({
-      type: 'output-list',
-      outputs: [{ beef: sampleBeef3, outputIndex: 0 }]
-    })
-
-    const r = new LookupResolver({
-      facilitator: mockFacilitator,
-      slapTrackers: ['https://mock.slap']
-    })
-
-    const res = await r.query({
-      service: 'ls_foo',
-      query: { test: 1 }
-    })
-
-    // Since the first response is 'freeform', it should return that response
-    expect(res).toEqual({
-      type: 'freeform',
-      result: { message: 'Freeform response from host1' }
-    })
-
-    expect(mockFacilitator.lookup.mock.calls).toEqual([
-      [
-        'https://mock.slap',
-        {
-          service: 'ls_slap',
-          query: {
-            service: 'ls_foo'
-          }
-        },
-        5000
-      ],
-      [
-        'https://slaphost1.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ],
-      [
-        'https://slaphost2.com',
-        {
-          service: 'ls_foo',
-          query: {
-            test: 1
-          }
-        },
-        undefined
-      ]
-    ])
-  })
-
   it('should ignore freeform responses when first response is output-list', async () => {
     const slapHostKey1 = new PrivateKey(42)
     const slapWallet1 = new CompletedProtoWallet(slapHostKey1)