@bsv/wallet-toolbox 1.7.18 → 1.7.20

package/src/__tests/WalletPermissionsManager.fixtures.ts

@@ -1,5 +1,14 @@
 const { Validation } = jest.requireActual('@bsv/sdk')
 
+const existingFetch = (globalThis as any).fetch
+if (!existingFetch || !(existingFetch as any)._isMockFunction) {
+  ;(globalThis as any).fetch = jest.fn(async () => ({
+    ok: false,
+    status: 404,
+    json: async () => ({})
+  }))
+}
+
 /**
  * A permissions manager testing mock/stub file for:
  *  1) The `@bsv/sdk` library: Transaction, LockingScript, PushDrop, Utils, Random, etc.

package/src/__tests/WalletPermissionsManager.flows.test.ts

@@ -35,6 +35,163 @@ describe('WalletPermissionsManager - Permission Request Flow & Active Requests',
    * UNIT TESTS
    */
   describe('Unit Tests: requestPermissionFlow & activeRequests map', () => {
+    it('should coalesce level-2 protocol requests for the same counterparty into a single grouped permission prompt based on manifest.json', async () => {
+      mockNoTokensFound(manager)
+
+      jest.spyOn(manager as any, 'fetchManifestGroupPermissions').mockResolvedValue({
+        protocolPermissions: [
+          {
+            protocolID: [2, 'l2-proto-A'],
+            counterparty: '',
+            description: 'A'
+          },
+          {
+            protocolID: [2, 'l2-proto-B'],
+            counterparty: 'peer-123',
+            description: 'B'
+          },
+          {
+            protocolID: [2, 'l2-proto-C'],
+            counterparty: 'peer-999',
+            description: 'C'
+          },
+          {
+            protocolID: [1, 'l1-proto-D'],
+            counterparty: 'peer-123',
+            description: 'D'
+          }
+        ]
+      })
+
+      const groupRequestCallback = jest.fn(() => {})
+      manager.bindCallback('onGroupedPermissionRequested', groupRequestCallback)
+
+      const callA = manager.ensureProtocolPermission({
+        originator: 'example.com',
+        privileged: false,
+        protocolID: [2, 'l2-proto-A'],
+        counterparty: 'peer-123',
+        reason: 'UnitTest - L2 A',
+        seekPermission: true,
+        usageType: 'signing'
+      })
+
+      const callB = manager.ensureProtocolPermission({
+        originator: 'example.com',
+        privileged: false,
+        protocolID: [2, 'l2-proto-B'],
+        counterparty: 'peer-123',
+        reason: 'UnitTest - L2 B',
+        seekPermission: true,
+        usageType: 'signing'
+      })
+
+      await new Promise(res => setTimeout(res, 5))
+
+      expect(groupRequestCallback).toHaveBeenCalledTimes(1)
+      const callbackArg = (groupRequestCallback.mock as any).calls[0][0]
+      const requestID = callbackArg.requestID
+      expect(typeof requestID).toBe('string')
+      expect(requestID).toMatch(/^group-peer:/)
+
+      const activeRequests = (manager as any).activeRequests as Map<string, any>
+      const queued = activeRequests.get(requestID)
+      expect(queued.request.permissions.protocolPermissions.length).toBe(2)
+      expect(queued.request.permissions.protocolPermissions).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ protocolID: [2, 'l2-proto-A'], counterparty: 'peer-123' }),
+          expect.objectContaining({ protocolID: [2, 'l2-proto-B'], counterparty: 'peer-123' })
+        ])
+      )
+
+      await manager.denyGroupedPermission(requestID)
+
+      await expect(callA).rejects.toThrow(/denied/i)
+      await expect(callB).rejects.toThrow(/denied/i)
+
+      expect(activeRequests.size).toBe(0)
+    })
+
+    it('should create separate grouped permission requests for different peers (no cross-peer grouping)', async () => {
+      mockNoTokensFound(manager)
+
+      jest.spyOn(manager as any, 'fetchManifestGroupPermissions').mockResolvedValue({
+        protocolPermissions: [
+          {
+            protocolID: [2, 'l2-proto-B'],
+            counterparty: 'peer-123',
+            description: 'B'
+          },
+          {
+            protocolID: [2, 'l2-proto-C'],
+            counterparty: 'peer-999',
+            description: 'C'
+          }
+        ]
+      })
+
+      const groupRequestCallback = jest.fn(() => {})
+      manager.bindCallback('onGroupedPermissionRequested', groupRequestCallback)
+
+      const callB = manager.ensureProtocolPermission({
+        originator: 'example.com',
+        privileged: false,
+        protocolID: [2, 'l2-proto-B'],
+        counterparty: 'peer-123',
+        reason: 'UnitTest - L2 B peer-123',
+        seekPermission: true,
+        usageType: 'signing'
+      })
+
+      const callC = manager.ensureProtocolPermission({
+        originator: 'example.com',
+        privileged: false,
+        protocolID: [2, 'l2-proto-C'],
+        counterparty: 'peer-999',
+        reason: 'UnitTest - L2 C peer-999',
+        seekPermission: true,
+        usageType: 'signing'
+      })
+
+      await new Promise(res => setTimeout(res, 5))
+
+      expect(groupRequestCallback).toHaveBeenCalledTimes(2)
+      const requestID1 = (groupRequestCallback.mock as any).calls[0][0].requestID
+      const requestID2 = (groupRequestCallback.mock as any).calls[1][0].requestID
+
+      expect(requestID1).not.toBe(requestID2)
+      expect(requestID1).toMatch(/^group-peer:/)
+      expect(requestID2).toMatch(/^group-peer:/)
+
+      const activeRequests = (manager as any).activeRequests as Map<string, any>
+      expect(activeRequests.size).toBe(2)
+
+      const queued1 = activeRequests.get(requestID1)
+      const queued2 = activeRequests.get(requestID2)
+
+      expect(queued1.request.permissions.protocolPermissions).toEqual(
+        expect.arrayContaining([expect.objectContaining({ protocolID: [2, 'l2-proto-B'], counterparty: 'peer-123' })])
+      )
+      expect(queued1.request.permissions.protocolPermissions).not.toEqual(
+        expect.arrayContaining([expect.objectContaining({ protocolID: [2, 'l2-proto-C'], counterparty: 'peer-999' })])
+      )
+
+      expect(queued2.request.permissions.protocolPermissions).toEqual(
+        expect.arrayContaining([expect.objectContaining({ protocolID: [2, 'l2-proto-C'], counterparty: 'peer-999' })])
+      )
+      expect(queued2.request.permissions.protocolPermissions).not.toEqual(
+        expect.arrayContaining([expect.objectContaining({ protocolID: [2, 'l2-proto-B'], counterparty: 'peer-123' })])
+      )
+
+      await manager.denyGroupedPermission(requestID1)
+      await manager.denyGroupedPermission(requestID2)
+
+      await expect(callB).rejects.toThrow(/denied/i)
+      await expect(callC).rejects.toThrow(/denied/i)
+
+      expect(activeRequests.size).toBe(0)
+    })
+
     it('should coalesce parallel requests for the same resource into a single user prompt', async () => {
       // We want to test the underlying private method "requestPermissionFlow" indirectly
       // or we can test it via a public method that calls it. We'll do so via ensureProtocolPermission.

package/src/services/chaintracker/chaintracks/Ingest/BulkIngestorWhatsOnChainCdn.ts

@@ -11,7 +11,7 @@ import { WhatsOnChainServices, WhatsOnChainServicesOptions } from './WhatsOnChai
 
 export interface BulkIngestorWhatsOnChainOptions extends BulkIngestorBaseOptions, WhatsOnChainServicesOptions {
   /**
-   * Maximum msces of "normal" pause with no new data arriving.
+   * Maximum msecs of "normal" pause with no new data arriving.
    */
   idleWait: number | undefined
   /**

package/src/services/chaintracker/chaintracks/__tests/Chaintracks.test.ts

@@ -35,7 +35,8 @@ describe('Chaintracks tests', () => {
     await NoDbBody('test')
   })
 
-  test.skip('3 NoDb export mainnet', async () => {
+  test('3 NoDb export mainnet', async () => {
+    if (_tu.noEnv('main')) return
     await NoDbBody('main', true)
   })
 

package/src/services/chaintracker/chaintracks/util/validBulkHeaderFilesByFileHash.ts

@@ -428,5 +428,17 @@ export const validBulkHeaderFiles: BulkHeaderFileInfo[] = [
     prevHash: '00000000000000000e7dcc27c06ee353bd37260b2e7e664314c204f0324a5087',
     sourceUrl: 'https://cdn.projectbabbage.com/blockheaders',
     validated: true
+  },
+  {
+    chain: 'main',
+    count: 31772,
+    fileHash: 'NuVsRUrI5QnjILbYy4LS3A/Udl6PH/m8Y9uVguEsekM=',
+    fileName: 'mainNet_9.headers',
+    firstHeight: 900000,
+    lastChainWork: '0000000000000000000000000000000000000000016ab16bb9b31430588788d3',
+    lastHash: '0000000000000000024a2f1caef4b0ffdc1a036b09f9ed7f48b538f619f32ef2',
+    prevChainWork: '000000000000000000000000000000000000000001664db1f2d50327928007e0',
+    prevHash: '00000000000000000e7dcc27c06ee353bd37260b2e7e664314c204f0324a5087',
+    sourceUrl: 'https://cdn.projectbabbage.com/blockheaders'
   }
 ]

package/src/storage/StorageProvider.ts

@@ -12,7 +12,8 @@ import {
   RelinquishOutputArgs,
   AbortActionArgs,
   Validation,
-  WalletLoggerInterface
+  WalletLoggerInterface,
+  ChainTracker
 } from '@bsv/sdk'
 import { getBeefForTransaction } from './methods/getBeefForTransaction'
 import { GetReqsAndBeefDetail, GetReqsAndBeefResult, processAction } from './methods/processAction'
@@ -57,6 +58,7 @@ import { TableMonitorEvent } from '../../src/storage/schema/tables/TableMonitorE
 import { TableCertificateX } from './schema/tables/TableCertificate'
 import {
   WERR_INTERNAL,
+  WERR_INVALID_MERKLE_ROOT,
   WERR_INVALID_OPERATION,
   WERR_INVALID_PARAMETER,
   WERR_MISSING_PARAMETER,
@@ -438,6 +440,20 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
     return proven != undefined || rawTx != undefined
   }
 
+  /**
+   * Pulls data from storage to build a valid beef for a txid.
+   *
+   * Optionally merges the data into an existing beef.
+   * Optionally requires a minimum number of proof levels.
+   *
+   * @param txid
+   * @param mergeToBeef
+   * @param trustSelf
+   * @param knownTxids
+   * @param trx
+   * @param requiredLevels
+   * @returns
+   */
   async getValidBeefForKnownTxid(
     txid: string,
     mergeToBeef?: Beef,
@@ -457,7 +473,9 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
     trustSelf?: TrustSelf,
     knownTxids?: string[],
     trx?: TrxToken,
-    requiredLevels?: number
+    requiredLevels?: number,
+    chainTracker?: ChainTracker,
+    skipInvalidProofs?: boolean
   ): Promise<Beef | undefined> {
     const beef = mergeToBeef || new Beef()
 
@@ -468,10 +486,25 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
       } else {
         if (trustSelf === 'known') beef.mergeTxidOnly(txid)
         else {
-          beef.mergeRawTx(r.proven.rawTx)
           const mp = new EntityProvenTx(r.proven).getMerklePath()
-          beef.mergeBump(mp)
-          return beef
+          if (chainTracker) {
+            const root = mp.computeRoot()
+            const isValid = await chainTracker.isValidRootForHeight(root, r.proven.height)
+            if (!isValid) {
+              if (!skipInvalidProofs) {
+                throw new WERR_INVALID_MERKLE_ROOT(r.proven.blockHash, r.proven.height, root, txid)
+              }
+              // ignore this currently invalid proof and try to recurse deeper
+              r.rawTx = r.proven.rawTx
+              r.proven = undefined
+            }
+          }
+          if (r.proven) {
+            // If we still like this proof, merge it and return
+            beef.mergeRawTx(r.proven.rawTx)
+            beef.mergeBump(mp)
+            return beef
+          }
         }
       }
     }