@bsv/wallet-toolbox 1.6.40 → 1.6.41

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

@@ -210,8 +210,7 @@ describe('WalletPermissionsManager - On-Chain Token Creation, Renewal & Revocati
           'originator app.example',
           'privileged false',
           'protocolName testProto',
-          'protocolSecurityLevel 1',
-          'counterparty self'
+          'protocolSecurityLevel 1'
         ])
       )
 
@@ -500,86 +499,5 @@ describe('WalletPermissionsManager - On-Chain Token Creation, Renewal & Revocati
       // The content can be a mock, we just check it’s not empty
       expect(signArgs.spends[0].unlockingScript).toBeDefined()
     })
-
-    it('should remove the old token from listing after revocation', async () => {
-      jest.spyOn(MockedBSV_SDK.Transaction, 'fromBEEF').mockImplementation(() => {
-        const mockTx = new MockTransaction()
-        // Add outputs with lockingScript
-        mockTx.outputs = [
-          {
-            lockingScript: {
-              // Ensure this matches what PushDrop.decode expects to work with
-              toHex: () => 'some script'
-            }
-          }
-        ]
-        // Add the toBEEF method
-        mockTx.toBEEF = () => []
-        return mockTx
-      })
-      // Add this to your test alongside the Transaction.fromBEEF mock
-      jest.spyOn(MockedBSV_SDK.PushDrop, 'decode').mockReturnValue({
-        fields: [
-          // Values that will decrypt to the expected values for domain, expiry, and basket
-          Utils.toArray('encoded-domain'),
-          Utils.toArray('encoded-expiry'),
-          Utils.toArray('encoded-basket')
-        ]
-      })
-
-      // You'll also need to mock the decryptPermissionTokenField method
-      // to handle these encoded values
-      jest.spyOn(manager as any, 'decryptPermissionTokenField').mockImplementation(field => {
-        if (field === 'encoded-domain') return new Uint8Array([...Buffer.from('example.com')])
-        if (field === 'encoded-expiry') return new Uint8Array([...Buffer.from('1735689600')])
-        if (field === 'encoded-basket') return new Uint8Array([...Buffer.from('protocol-permission')])
-        return new Uint8Array()
-      })
-
-      // 1) Setup the underlying wallet to initially return the old token in listOutputs
-      const oldToken: PermissionToken = {
-        tx: [],
-        txid: 'aaaa1111',
-        outputIndex: 0,
-        outputScript: 'some script',
-        satoshis: 1,
-        originator: 'example.com',
-        expiry: 999999,
-        basketName: 'myBasket'
-      }
-      // We mock listOutputs so that it returns the old token before revocation
-      underlying.listOutputs.mockResolvedValueOnce({
-        totalOutputs: 1,
-        outputs: [
-          {
-            outpoint: 'aaaa1111.0',
-            lockingScript: 'some script',
-            satoshis: 1,
-            tags: ['originator example.com', 'basket myBasket']
-          }
-        ]
-      })
-
-      // Confirm the manager sees it in listBasketAccess
-      const tokensBefore = await manager.listBasketAccess({
-        originator: 'example.com'
-      })
-      expect(tokensBefore).toHaveLength(1)
-      expect(tokensBefore[0].txid).toBe('aaaa1111')
-
-      // 2) Revoke the token
-      await manager.revokePermission(oldToken)
-
-      // 3) After revocation, mock the underlying wallet to show zero outputs
-      underlying.listOutputs.mockResolvedValue({
-        totalOutputs: 0,
-        outputs: []
-      })
-
-      const tokensAfter = await manager.listBasketAccess({
-        originator: 'example.com'
-      })
-      expect(tokensAfter).toHaveLength(0)
-    })
   })
 })

package/src/sdk/WalletError.ts

@@ -150,9 +150,15 @@ export class WalletError extends Error implements WalletErrorObject {
     const t = typeof error
     const ctor = t === 'object' && error !== null ? (error as any).constructor?.name : undefined
     const name = t === 'object' && error !== null && typeof (error as any).name === 'string' ? (error as any).name : ''
-    const message = t === 'object' && error !== null && typeof (error as any).message === 'string' ? (error as any).message : ''
-    const toJson = t === 'object' && error !== null && typeof (error as any).toJson === 'function' ? (error as any).toJson : undefined
-    console.log(`WalletError.unknownToJson: error type=${t} ctor=${ctor} name=${name} message=${message} hasToJson=${toJson ? 'yes' : 'no'}`)
+    const message =
+      t === 'object' && error !== null && typeof (error as any).message === 'string' ? (error as any).message : ''
+    const toJson =
+      t === 'object' && error !== null && typeof (error as any).toJson === 'function'
+        ? (error as any).toJson
+        : undefined
+    console.log(
+      `WalletError.unknownToJson: error type=${t} ctor=${ctor} name=${name} message=${message} hasToJson=${toJson ? 'yes' : 'no'}`
+    )
     if (ctor && ctor.startsWith('WERR_') && toJson !== undefined) {
       json = (error as WalletError).toJson()
     } else if (name && message) {

package/src/storage/WalletStorageManager.ts

@@ -567,10 +567,10 @@ export class WalletStorageManager implements sdk.WalletStorage {
   /**
    * Extends the Beef `verify` function to handle BUMPs that have become invalid due to a chain reorg,
    * and originated from proven_txs records tracked by this storage.
-   * 
+   *
    * This method is optimized for making sure outgoing beefs are valid before sharing them externally.
    * In particular, it only "repairs" proofs previously tracked by this storage.
-   * 
+   *
    * Any merkle root that fails `isValidRootForHeight` triggers a reprove attempt for that block header.
    * This results in proven_txs with invalid proofs being updated with new valid proofs where possible.
    *
@@ -599,7 +599,9 @@ export class WalletStorageManager implements sdk.WalletStorage {
       if (!isValid) {
         // root is not currently the valid hash for this height according to the chaintracker.
         // What beef txids depended on this root:
-        const txids = beef.txs.filter(tx => tx.bumpIndex !== undefined && beef.bumps[tx.bumpIndex].blockHeight === height).map(tx => tx.txid)
+        const txids = beef.txs
+          .filter(tx => tx.bumpIndex !== undefined && beef.bumps[tx.bumpIndex].blockHeight === height)
+          .map(tx => tx.txid)
         const reproveResults = await this.reproveHeader(root)
         r.invalidRoots[height] = { root, reproveResults }
       }
@@ -938,5 +940,5 @@ export class WalletStorageManager implements sdk.WalletStorage {
 export interface VerifyAndRepairBeefResult {
   isStructurallyValid: boolean
   originalRoots: Record<number, string>
-  invalidRoots: Record<number, { root: string, reproveResults: sdk.ReproveHeaderResult }>
-}
+  invalidRoots: Record<number, { root: string; reproveResults: sdk.ReproveHeaderResult }>
+}