@bsv/sdk 1.7.3 → 1.7.5

package/src/auth/utils/createNonce.ts

@@ -1,7 +1,8 @@
 import {
   WalletInterface,
   WalletCounterparty,
-  Base64String
+  Base64String,
+  OriginatorDomainNameStringUnder250Bytes
 } from '../../wallet/Wallet.interfaces.js'
 import * as Utils from '../../primitives/utils.js'
 import Random from '../../primitives/Random.js'
@@ -14,7 +15,8 @@ import Random from '../../primitives/Random.js'
  */
 export async function createNonce(
   wallet: WalletInterface,
-  counterparty: WalletCounterparty = 'self'
+  counterparty: WalletCounterparty = 'self',
+  originator?: OriginatorDomainNameStringUnder250Bytes
 ): Promise<Base64String> {
   // Generate 16 random bytes for the first half of the data
   const firstHalf = Random(16)
@@ -24,7 +26,7 @@ export async function createNonce(
     keyID: Utils.toUTF8(firstHalf),
     data: firstHalf,
     counterparty
-  })
+  }, originator)
   // Concatenate firstHalf and secondHalf as the nonce bytes
   const nonceBytes = [...firstHalf, ...hmac]
   return Utils.toBase64(nonceBytes)

package/src/auth/utils/getVerifiableCertificates.ts

@@ -1,5 +1,5 @@
 import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
-import { WalletInterface } from '../../wallet/Wallet.interfaces.js'
+import { OriginatorDomainNameStringUnder250Bytes, WalletInterface } from '../../wallet/Wallet.interfaces.js'
 import { RequestedCertificateSet } from '../types.js'
 
 /**
@@ -13,14 +13,15 @@ import { RequestedCertificateSet } from '../types.js'
 export const getVerifiableCertificates = async (
   wallet: WalletInterface,
   requestedCertificates: RequestedCertificateSet,
-  verifierIdentityKey: string
+  verifierIdentityKey: string,
+  originator?: OriginatorDomainNameStringUnder250Bytes
 ): Promise<VerifiableCertificate[]> => {
   // Find matching certificates we have
   // Note: This may return multiple certificates that match the correct type.
   const matchingCertificates = await wallet.listCertificates({
     certifiers: requestedCertificates.certifiers,
     types: Object.keys(requestedCertificates.types)
-  })
+  }, originator)
 
   // For each certificate requested, create a verifiable cert with selectively revealed fields
   return await Promise.all(
@@ -29,7 +30,7 @@ export const getVerifiableCertificates = async (
         certificate,
         fieldsToReveal: requestedCertificates.types[certificate.type],
         verifier: verifierIdentityKey
-      })
+      }, originator)
       return new VerifiableCertificate(
         certificate.type,
         certificate.serialNumber,

package/src/auth/utils/validateCertificates.ts

@@ -1,4 +1,4 @@
-import { WalletInterface } from '../../wallet/index.js'
+import { OriginatorDomainNameStringUnder250Bytes, WalletInterface } from '../../wallet/index.js'
 import { AuthMessage, RequestedCertificateSet } from '../types.js'
 import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
 
@@ -13,7 +13,8 @@ import { VerifiableCertificate } from '../certificates/VerifiableCertificate.js'
 export const validateCertificates = async (
   verifierWallet: WalletInterface,
   message: AuthMessage,
-  certificatesRequested?: RequestedCertificateSet
+  certificatesRequested?: RequestedCertificateSet,
+  originator?: OriginatorDomainNameStringUnder250Bytes
 ): Promise<void> => {
   if ((message.certificates == null) || message.certificates.length === 0) {
     throw new Error('No certificates were provided in the AuthMessage.')
@@ -58,7 +59,7 @@ export const validateCertificates = async (
 
         // Check type and fields match requested
         const requestedFields = types[certToVerify.type]
-        if (requestedFields == null) { // ✅ Explicitly check for null or undefined
+        if (requestedFields == null) {
           throw new Error(
             `Certificate with type ${certToVerify.type} was not requested`
           )
@@ -66,7 +67,7 @@ export const validateCertificates = async (
       }
 
       // Attempt to decrypt fields
-      await certToVerify.decryptFields(verifierWallet)
+      await certToVerify.decryptFields(verifierWallet, undefined, undefined, originator)
     })
   )
 }

package/src/auth/utils/verifyNonce.ts

@@ -1,5 +1,5 @@
 import * as Utils from '../../primitives/utils.js'
-import { WalletInterface, WalletCounterparty, Base64String } from '../../wallet/Wallet.interfaces.js'
+import { WalletInterface, WalletCounterparty, Base64String, OriginatorDomainNameStringUnder250Bytes } from '../../wallet/Wallet.interfaces.js'
 
 /**
  * Verifies a nonce derived from a wallet
@@ -11,7 +11,8 @@ import { WalletInterface, WalletCounterparty, Base64String } from '../../wallet/
 export async function verifyNonce(
   nonce: Base64String,
   wallet: WalletInterface,
-  counterparty: WalletCounterparty = 'self'
+  counterparty: WalletCounterparty = 'self',
+  originator?: OriginatorDomainNameStringUnder250Bytes
 ): Promise<boolean> {
   // Convert nonce from base64 string to Uint8Array
   const buffer = Utils.toArray(nonce, 'base64')
@@ -27,7 +28,7 @@ export async function verifyNonce(
     protocolID: [2, 'server hmac'],
     keyID: Utils.toUTF8(data),
     counterparty
-  })
+  }, originator)
 
   return valid
 }

package/src/identity/ContactsManager.ts

@@ -1,7 +1,7 @@
 import { PubKeyHex, WalletClient, WalletInterface, WalletProtocol } from '../wallet/index.js'
 import { Utils, Random } from '../primitives/index.js'
 import { DisplayableIdentity } from './types/index.js'
-import { PushDrop } from '../script/index.js'
+import { LockingScript, PushDrop } from '../script/index.js'
 import { Transaction } from '../transaction/index.js'
 export type Contact = DisplayableIdentity & { metadata?: Record<string, any> }
 
@@ -41,9 +41,10 @@ export class ContactsManager {
    * Load all records from the contacts basket
    * @param identityKey Optional specific identity key to fetch
    * @param forceRefresh Whether to force a check for new contact data
+   * @param limit Maximum number of contacts to return
    * @returns A promise that resolves with an array of contacts
    */
-  async getContacts (identityKey?: PubKeyHex, forceRefresh = false): Promise<Contact[]> {
+  async getContacts (identityKey?: PubKeyHex, forceRefresh = false, limit = 1000): Promise<Contact[]> {
     // Check in-memory cache first unless forcing refresh
     if (!forceRefresh) {
       const cached = this.cache.getItem(this.CONTACTS_CACHE_KEY)
@@ -74,9 +75,10 @@ export class ContactsManager {
     // Get all contact outputs from the contacts basket
     const outputs = await this.wallet.listOutputs({
       basket: 'contacts',
-      include: 'entire transactions',
+      include: 'locking scripts',
       includeCustomInstructions: true,
-      tags
+      tags,
+      limit
     })
 
     if (outputs.outputs == null || outputs.outputs.length === 0) {
@@ -89,12 +91,10 @@ export class ContactsManager {
     // Process each contact output
     for (const output of outputs.outputs) {
       try {
-        const [txid, outputIndex] = output.outpoint.split('.')
-        const tx = Transaction.fromBEEF(outputs.BEEF as number[], txid)
-        const lockingScript = tx.outputs[Number(outputIndex)].lockingScript
+        if (output.lockingScript == null) continue
 
         // Decode the PushDrop data
-        const decoded = PushDrop.decode(lockingScript)
+        const decoded = PushDrop.decode(LockingScript.fromHex(output.lockingScript))
         if (output.customInstructions == null) continue
         const keyID = JSON.parse(output.customInstructions).keyID
 
@@ -164,7 +164,8 @@ export class ContactsManager {
       basket: 'contacts',
       include: 'entire transactions',
       includeCustomInstructions: true,
-      tags: [`identityKey ${Utils.toHex(hashedIdentityKey)}`]
+      tags: [`identityKey ${Utils.toHex(hashedIdentityKey)}`],
+      limit: 100 // Should only be one contact!
     })
 
     let existingOutput: any = null
@@ -309,7 +310,8 @@ export class ContactsManager {
       basket: 'contacts',
       include: 'entire transactions',
       includeCustomInstructions: true,
-      tags
+      tags,
+      limit: 100 // Should only be one contact!
     })
 
     if (outputs.outputs == null) return

package/src/identity/IdentityClient.ts

@@ -247,10 +247,11 @@ export class IdentityClient {
    * Load all records from the contacts basket
    * @param identityKey Optional specific identity key to fetch
    * @param forceRefresh Whether to force a check for new contact data
+   * @param limit Optional limit on number of contacts to fetch
    * @returns A promise that resolves with an array of contacts
    */
-  public async getContacts (identityKey?: PubKeyHex, forceRefresh = false): Promise<Contact[]> {
-    return await this.contactsManager.getContacts(identityKey, forceRefresh)
+  public async getContacts (identityKey?: PubKeyHex, forceRefresh = false, limit = 1000): Promise<Contact[]> {
+    return await this.contactsManager.getContacts(identityKey, forceRefresh, limit)
   }
 
   /**

package/src/identity/__tests/IdentityClient.test.ts

@@ -54,7 +54,11 @@ jest.mock('../../script', () => {
   })
 
   return {
-    PushDrop: mockPushDrop
+    PushDrop: mockPushDrop,
+    // Provide LockingScript.fromHex to satisfy ContactsManager.getContacts decode path
+    LockingScript: {
+      fromHex: jest.fn().mockImplementation((hex: string) => ({ toHex: () => hex }))
+    }
   }
 })
 
@@ -613,7 +617,8 @@ describe('IdentityClient', () => {
       it('should load contacts from wallet basket when cache is empty', async () => {
         const mockOutput = {
           outpoint: 'txid.0',
-          customInstructions: JSON.stringify({ keyID: 'mockKeyID' })
+          customInstructions: JSON.stringify({ keyID: 'mockKeyID' }),
+          lockingScript: 'lockingScriptHex'
         }
 
           ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
@@ -630,9 +635,10 @@ describe('IdentityClient', () => {
         expect(result).toEqual([mockContact])
         expect(walletMock.listOutputs).toHaveBeenCalledWith({
           basket: 'contacts',
-          include: 'entire transactions',
+          include: 'locking scripts',
           includeCustomInstructions: true,
-          tags: []
+          tags: [],
+          limit: 1000
         })
 
         // Verify subsequent call uses cache

package/src/storage/StorageDownloader.ts

@@ -15,9 +15,11 @@ export interface DownloadResult {
 
 export class StorageDownloader {
   private readonly networkPreset?: 'mainnet' | 'testnet' | 'local' = 'mainnet'
+  private readonly lookupResolver: LookupResolver
 
   constructor (config?: DownloaderConfig) {
-    this.networkPreset = config?.networkPreset
+    this.networkPreset = config?.networkPreset ?? 'mainnet'
+    this.lookupResolver = new LookupResolver({ networkPreset: this.networkPreset })
   }
 
   /**
@@ -27,8 +29,7 @@ export class StorageDownloader {
    */
   public async resolve (uhrpUrl: string): Promise<string[]> {
     // Use UHRP lookup service
-    const lookupResolver = new LookupResolver({ networkPreset: this.networkPreset })
-    const response = await lookupResolver.query({ service: 'ls_uhrp', query: { uhrpUrl } })
+    const response = await this.lookupResolver.query({ service: 'ls_uhrp', query: { uhrpUrl } })
     if (response.type !== 'output-list') {
       throw new Error('Lookup answer must be an output list')
     }

package/src/wallet/ProtoWallet.ts

@@ -185,8 +185,7 @@ export class ProtoWallet {
   }
 
   async decrypt (
-    args: WalletDecryptArgs
-  ): Promise<WalletDecryptResult> {
+    args: WalletDecryptArgs, originator?: string): Promise<WalletDecryptResult> {
     if (this.keyDeriver == null) {
       throw new Error('keyDeriver is undefined')
     }