@bsv/sdk 2.1.0 → 2.1.1

package/src/identity/IdentityClient.ts

@@ -18,6 +18,30 @@ import { PrivateKey, Utils } from '../primitives/index.js'
 import { LookupResolver, SHIPBroadcaster, TopicBroadcaster, withDoubleSpendRetry } from '../overlay-tools/index.js'
 import { ContactsManager, Contact } from './ContactsManager.js'
 
+/** Options for {@link IdentityClient.resolveByIdentityKey}. */
+export interface ResolveByIdentityKeyOptions {
+  /** Default `true`. If `false`, contacts are skipped and the overlay is queried directly. */
+  overrideWithContacts?: boolean
+  /**
+   * Default `false`. When `true`, fire contacts and overlay in parallel (legacy behavior) instead
+   * of short-circuiting on a contacts hit. Use when callers specifically need a fresh overlay
+   * answer alongside the contact record.
+   */
+  parallel?: boolean
+}
+
+/** Options for {@link IdentityClient.resolveByAttributes}. */
+export interface ResolveByAttributesOptions {
+  /** Default `true`. If `false`, contacts are skipped and the overlay is queried directly. */
+  overrideWithContacts?: boolean
+  /**
+   * Default `false`. When `true`, fire contacts and overlay in parallel (legacy behavior). The
+   * contacts-first path tries to match the supplied attributes against the locally-stored
+   * contacts; if any contact matches every attribute, the overlay is skipped.
+   */
+  parallel?: boolean
+}
+
 /**
  * IdentityClient lets you discover who others are, and let the world know who you are.
  */
@@ -69,7 +93,8 @@ export class IdentityClient {
         certificate.signature
       )
       await masterCert.verify()
-    } catch (error) {
+    } catch (_certVerificationError) {
+      // Low-level cert error details are suppressed — surface a user-facing message only
       throw new Error('Public reveal failed: Certificate verification failed!')
     }
 
@@ -97,7 +122,7 @@ export class IdentityClient {
       true,
       true
     )
-    // TODO: Consider verification and if this is necessary
+    // Consider verification and if this is necessary
     // counterpartyCanVerifyMyOwnership: true
 
     const { tx } = await this.wallet.createAction(
@@ -130,67 +155,124 @@ export class IdentityClient {
   /**
    * Resolves displayable identity certificates, issued to a given identity key by a trusted certifier.
    *
-   * @param {DiscoverByIdentityKeyArgs} args - Arguments for requesting the discovery based on the identity key.
-   * @param {boolean} [overrideWithContacts=true] - Whether to override the results with personal contacts if available.
-   * @returns {Promise<DisplayableIdentity[]>} The promise resolves to displayable identities.
+   * By default, contacts are consulted first and the overlay is only queried on a contacts miss.
+   * Pass `{ parallel: true }` to fire both in parallel (the legacy behavior, useful when callers
+   * specifically want a fresh overlay answer even when a contact exists).
+   *
+   * @param args - Arguments for requesting the discovery based on the identity key.
+   * @param overrideWithContacts - Whether to consult personal contacts. Default true. When `false`,
+   *   contacts are skipped entirely and the overlay is queried directly. Boolean kept for legacy
+   *   call sites; new code should prefer the options-object form.
+   * @returns The promise resolves to displayable identities.
    */
   async resolveByIdentityKey (
     args: DiscoverByIdentityKeyArgs,
-    overrideWithContacts = true
+    overrideWithContacts: boolean | ResolveByIdentityKeyOptions = true
   ): Promise<DisplayableIdentity[]> {
-    // Run both queries in parallel for better performance
+    const opts: ResolveByIdentityKeyOptions =
+      typeof overrideWithContacts === 'boolean'
+        ? { overrideWithContacts }
+        : { overrideWithContacts: true, ...overrideWithContacts }
+    const useContacts = opts.overrideWithContacts !== false
+    const parallel = opts.parallel === true
+
+    if (useContacts && !parallel) {
+      const contacts = await this.contactsManager.getContacts(args.identityKey)
+      if (contacts.length > 0) return contacts
+
+      const certificatesResult = await this.wallet.discoverByIdentityKey(args, this.originator)
+      const certs = certificatesResult?.certificates ?? []
+      return certs.map((cert) => IdentityClient.parseIdentity(cert))
+    }
+
     const [contacts, certificatesResult] = await Promise.all([
-      overrideWithContacts
+      useContacts
         ? this.contactsManager.getContacts(args.identityKey)
-        : Promise.resolve([]),
+        : Promise.resolve([] as Contact[]),
       this.wallet.discoverByIdentityKey(args, this.originator)
     ])
 
-    // Override results with personal contacts if available
-    if (contacts.length > 0) {
-      return contacts
-    }
-
+    if (contacts.length > 0) return contacts
     const certs = certificatesResult?.certificates ?? []
-    return certs.map((cert) => {
-      return IdentityClient.parseIdentity(cert)
-    })
+    return certs.map((cert) => IdentityClient.parseIdentity(cert))
   }
 
   /**
    * Resolves displayable identity certificates by specific identity attributes, issued by a trusted entity.
    *
-   * @param {DiscoverByAttributesArgs} args - Attributes and optional parameters used to discover certificates.
-   * @param {boolean} [overrideWithContacts=true] - Whether to override the results with personal contacts if available.
-   * @returns {Promise<DisplayableIdentity[]>} The promise resolves to displayable identities.
+   * By default, contacts are consulted first: if any contact matches, the overlay call is skipped
+   * entirely. Set `parallel: true` to keep the legacy parallel behavior.
+   *
+   * @param args - Attributes and optional parameters used to discover certificates.
+   * @param overrideWithContacts - Whether to consult personal contacts. Default true. Boolean kept
+   *   for legacy call sites; new code should prefer the options-object form.
+   * @returns The promise resolves to displayable identities.
    */
   async resolveByAttributes (
     args: DiscoverByAttributesArgs,
-    overrideWithContacts = true
+    overrideWithContacts: boolean | ResolveByAttributesOptions = true
   ): Promise<DisplayableIdentity[]> {
-    // Run both queries in parallel for better performance
+    const opts: ResolveByAttributesOptions =
+      typeof overrideWithContacts === 'boolean'
+        ? { overrideWithContacts }
+        : { overrideWithContacts: true, ...overrideWithContacts }
+    const useContacts = opts.overrideWithContacts !== false
+    const parallel = opts.parallel === true
+
+    if (useContacts && !parallel) {
+      const contacts = await this.contactsManager.getContacts()
+      const matches = this.matchContactsByAttributes(contacts, args)
+      if (matches.length > 0) return matches
+
+      const certificatesResult = await this.wallet.discoverByAttributes(args, this.originator)
+      const certs = certificatesResult?.certificates ?? []
+      const contactByKey = new Map<PubKeyHex, Contact>(
+        contacts.map((contact) => [contact.identityKey, contact] as const)
+      )
+      return certs.map(
+        (cert) => contactByKey.get(cert.subject) ?? IdentityClient.parseIdentity(cert)
+      )
+    }
+
     const [contacts, certificatesResult] = await Promise.all([
-      overrideWithContacts
-        ? this.contactsManager.getContacts()
-        : Promise.resolve([]),
+      useContacts ? this.contactsManager.getContacts() : Promise.resolve([] as Contact[]),
       this.wallet.discoverByAttributes(args, this.originator)
     ])
 
-    // Fast lookup by identityKey
     const contactByKey = new Map<PubKeyHex, Contact>(
       contacts.map((contact) => [contact.identityKey, contact] as const)
     )
-
-    // Guard if certificates might be absent
     const certs = certificatesResult?.certificates ?? []
-
-    // Parse certificates and substitute with contacts where available
     return certs.map(
-      (cert) =>
-        contactByKey.get(cert.subject) ?? IdentityClient.parseIdentity(cert)
+      (cert) => contactByKey.get(cert.subject) ?? IdentityClient.parseIdentity(cert)
     )
   }
 
+  /**
+   * Best-effort match of contacts against a `DiscoverByAttributesArgs.attributes` shape.
+   * Used by the contacts-first path of {@link resolveByAttributes} to decide whether the overlay
+   * can be skipped. Compares string-valued attributes against same-named fields on the contact's
+   * decrypted record. Returns the subset of contacts that match every supplied attribute.
+   */
+  private matchContactsByAttributes (
+    contacts: Contact[],
+    args: DiscoverByAttributesArgs
+  ): Contact[] {
+    const attrs = (args).attributes
+    if (attrs == null || typeof attrs !== 'object' || Array.isArray(attrs)) return []
+    const entries = Object.entries(attrs as Record<string, unknown>).filter(
+      ([, v]) => typeof v === 'string' && v.length > 0
+    ) as Array<[string, string]>
+    if (entries.length === 0) return []
+    return contacts.filter((contact) => {
+      const bag: Record<string, unknown> = {
+        name: contact.name,
+        identityKey: contact.identityKey
+      }
+      return entries.every(([k, v]) => typeof bag[k] === 'string' && (bag[k] as string).toLowerCase() === v.toLowerCase())
+    })
+  }
+
   /**
    * Remove public certificate revelation from overlay services by spending the identity token
    * @param serialNumber - Unique serial number of the certificate to revoke revelation
@@ -346,42 +428,42 @@ export class IdentityClient {
         avatarURL = decryptedFields.profilePhoto
         badgeLabel = `X account certified by ${certifierInfo.name}`
         badgeIconURL = certifierInfo.iconUrl
-        badgeClickURL = 'https://socialcert.net' // TODO Make a specific page for this.
+        badgeClickURL = 'https://socialcert.net' // (no dedicated page yet)
         break
       case KNOWN_IDENTITY_TYPES.discordCert:
         name = decryptedFields.userName
         avatarURL = decryptedFields.profilePhoto
         badgeLabel = `Discord account certified by ${certifierInfo.name}`
         badgeIconURL = certifierInfo.iconUrl
-        badgeClickURL = 'https://socialcert.net' // TODO Make a specific page for this.
+        badgeClickURL = 'https://socialcert.net' // (no dedicated page yet)
         break
       case KNOWN_IDENTITY_TYPES.emailCert:
         name = decryptedFields.email
         avatarURL = 'XUTZxep7BBghAJbSBwTjNfmcsDdRFs5EaGEgkESGSgjJVYgMEizu'
         badgeLabel = `Email certified by ${certifierInfo.name}`
         badgeIconURL = certifierInfo.iconUrl
-        badgeClickURL = 'https://socialcert.net' // TODO Make a specific page for this.
+        badgeClickURL = 'https://socialcert.net' // (no dedicated page yet)
         break
       case KNOWN_IDENTITY_TYPES.phoneCert:
         name = decryptedFields.phoneNumber
         avatarURL = 'XUTLxtX3ELNUwRhLwL7kWNGbdnFM8WG2eSLv84J7654oH8HaJWrU'
         badgeLabel = `Phone certified by ${certifierInfo.name}`
         badgeIconURL = certifierInfo.iconUrl
-        badgeClickURL = 'https://socialcert.net' // TODO Make a specific page for this.
+        badgeClickURL = 'https://socialcert.net' // (no dedicated page yet)
         break
       case KNOWN_IDENTITY_TYPES.identiCert:
         name = `${decryptedFields.firstName} ${decryptedFields.lastName}`
         avatarURL = decryptedFields.profilePhoto
         badgeLabel = `Government ID certified by ${certifierInfo.name}`
         badgeIconURL = certifierInfo.iconUrl
-        badgeClickURL = 'https://identicert.me' // TODO Make a specific page for this.
+        badgeClickURL = 'https://identicert.me' // (no dedicated page yet)
         break
       case KNOWN_IDENTITY_TYPES.registrant:
         name = decryptedFields.name
         avatarURL = decryptedFields.icon
         badgeLabel = `Entity certified by ${certifierInfo.name}`
         badgeIconURL = certifierInfo.iconUrl
-        badgeClickURL = 'https://bsv-blockchain.github.io/ts-sdk/reference/identity/' // TODO: Make this doc page exist
+        badgeClickURL = 'https://bsv-blockchain.github.io/ts-sdk/reference/identity/' // (no dedicated page yet)
         break
       case KNOWN_IDENTITY_TYPES.coolCert:
         name = decryptedFields.cool === 'true' ? 'Cool Person!' : 'Not cool!'
@@ -392,14 +474,14 @@ export class IdentityClient {
         badgeLabel =
           'Represents the ability for anyone to access this information.'
         badgeIconURL = 'XUUV39HVPkpmMzYNTx7rpKzJvXfeiVyQWg2vfSpjBAuhunTCA9uG'
-        badgeClickURL = 'https://bsv-blockchain.github.io/ts-sdk/reference/identity/' // TODO: Make this doc page exist
+        badgeClickURL = 'https://bsv-blockchain.github.io/ts-sdk/reference/identity/' // (no dedicated page yet)
         break
       case KNOWN_IDENTITY_TYPES.self:
         name = 'You'
         avatarURL = 'XUT9jHGk2qace148jeCX5rDsMftkSGYKmigLwU2PLLBc7Hm63VYR'
         badgeLabel = 'Represents your ability to access this information.'
         badgeIconURL = 'XUUV39HVPkpmMzYNTx7rpKzJvXfeiVyQWg2vfSpjBAuhunTCA9uG'
-        badgeClickURL = 'https://bsv-blockchain.github.io/ts-sdk/reference/identity/' // TODO: Make this doc page exist
+        badgeClickURL = 'https://bsv-blockchain.github.io/ts-sdk/reference/identity/' // (no dedicated page yet)
         break
       default: {
         const parsed = IdentityClient.tryToParseGenericIdentity(
@@ -455,34 +537,41 @@ export class IdentityClient {
     // Try to construct a name from common field patterns
     const firstName = decryptedFields.firstName
     const lastName = decryptedFields.lastName
-    const fullName =
-      IdentityClient.hasValue(firstName) && IdentityClient.hasValue(lastName)
-        ? `${firstName} ${lastName}`
-        : IdentityClient.hasValue(firstName)
-          ? firstName
-          : IdentityClient.hasValue(lastName)
-            ? lastName
-            : undefined
-
-    const name = IdentityClient.hasValue(decryptedFields.name)
-      ? decryptedFields.name
-      : IdentityClient.hasValue(decryptedFields.userName)
-        ? decryptedFields.userName
-        : (fullName ??
-          (IdentityClient.hasValue(decryptedFields.email)
-            ? decryptedFields.email
-            : defaultIdentity.name))
+    let fullName: string | undefined
+    if (IdentityClient.hasValue(firstName) && IdentityClient.hasValue(lastName)) {
+      fullName = `${firstName} ${lastName}`
+    } else if (IdentityClient.hasValue(firstName)) {
+      fullName = firstName
+    } else if (IdentityClient.hasValue(lastName)) {
+      fullName = lastName
+    }
+
+    let name: string | undefined
+    if (IdentityClient.hasValue(decryptedFields.name)) {
+      name = decryptedFields.name
+    } else if (IdentityClient.hasValue(decryptedFields.userName)) {
+      name = decryptedFields.userName
+    } else if (fullName !== undefined) {
+      name = fullName
+    } else if (IdentityClient.hasValue(decryptedFields.email)) {
+      name = decryptedFields.email
+    } else {
+      name = defaultIdentity.name
+    }
 
     // Try to find an avatar/photo from common field names
-    const avatarURL = IdentityClient.hasValue(decryptedFields.profilePhoto)
-      ? decryptedFields.profilePhoto
-      : IdentityClient.hasValue(decryptedFields.avatar)
-        ? decryptedFields.avatar
-        : IdentityClient.hasValue(decryptedFields.icon)
-          ? decryptedFields.icon
-          : IdentityClient.hasValue(decryptedFields.photo)
-            ? decryptedFields.photo
-            : defaultIdentity.avatarURL
+    let avatarURL: string | undefined
+    if (IdentityClient.hasValue(decryptedFields.profilePhoto)) {
+      avatarURL = decryptedFields.profilePhoto
+    } else if (IdentityClient.hasValue(decryptedFields.avatar)) {
+      avatarURL = decryptedFields.avatar
+    } else if (IdentityClient.hasValue(decryptedFields.icon)) {
+      avatarURL = decryptedFields.icon
+    } else if (IdentityClient.hasValue(decryptedFields.photo)) {
+      avatarURL = decryptedFields.photo
+    } else {
+      avatarURL = defaultIdentity.avatarURL
+    }
 
     // Generate badge information
     const badgeLabel = IdentityClient.hasValue(certifierInfo?.name)

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

@@ -264,7 +264,31 @@ describe('IdentityClient', () => {
 
       expect(identities).toHaveLength(1)
       expect(identities[0].name).toBe('Alice Smith (Personal Contact)') // Contact should be returned, not discovered identity
-      // Both calls fire in parallel, but contacts take priority in the result
+      // New default: contacts-first short-circuit — the overlay is skipped entirely on a contacts hit.
+      expect(walletMock.discoverByIdentityKey).not.toHaveBeenCalled()
+    })
+
+    it('should still call the overlay when parallel: true is passed', async () => {
+      const contact = {
+        name: 'Alice Smith (Personal Contact)',
+        identityKey: 'alice-identity-key',
+        avatarURL: 'alice-avatar.png',
+        abbreviatedKey: 'alice-i...',
+        badgeIconURL: '',
+        badgeLabel: '',
+        badgeClickURL: ''
+      }
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue([contact])
+      walletMock.discoverByIdentityKey = jest.fn().mockResolvedValue({ certificates: [] })
+
+      const identities = await identityClient.resolveByIdentityKey(
+        { identityKey: 'alice-identity-key' },
+        { parallel: true }
+      )
+
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('Alice Smith (Personal Contact)')
       expect(walletMock.discoverByIdentityKey).toHaveBeenCalled()
     })
   })

package/src/kvstore/GlobalKVStore.ts

@@ -146,7 +146,7 @@ export class GlobalKVStore {
       throw new Error('Key must be a non-empty string.')
     }
     if (typeof value !== 'string') {
-      throw new Error('Value must be a string.')
+      throw new TypeError('Value must be a string.')
     }
 
     const controller = await this.getIdentityKey()
@@ -186,7 +186,30 @@ export class GlobalKVStore {
         const existingEntries = await this.queryOverlay({ key, controller }, { includeToken: true })
         const existingToken = existingEntries.length > 0 ? existingEntries[0].token : undefined
 
-        if (existingToken != null) {
+        if (existingToken == null) {
+          // Create new token
+          const { tx } = await this.wallet.createAction({
+            description: tokenSetDescription,
+            outputs: [{
+              satoshis: tokenAmount ?? this.config.tokenAmount as number,
+              lockingScript: lockingScript.toHex(),
+              outputDescription: 'KVStore token'
+            }],
+            options: {
+              acceptDelayedBroadcast: this.config.acceptDelayedBroadcast,
+              noSend: this.config.overlayBroadcast,
+              randomizeOutputs: false
+            }
+          }, this.config.originator)
+
+          if (tx == null) {
+            throw new Error('Failed to create transaction')
+          }
+
+          const transaction = Transaction.fromAtomicBEEF(tx)
+          await this.submitToOverlay(transaction)
+          return `${transaction.id('hex')}.0`
+        } else {
           // Update existing token
           const inputs: CreateActionInput[] = [{
             outpoint: `${existingToken.txid}.${existingToken.outputIndex}`,
@@ -239,29 +262,6 @@ export class GlobalKVStore {
           const transaction = Transaction.fromAtomicBEEF(finalTx)
           await this.submitToOverlay(transaction)
           return `${transaction.id('hex')}.0`
-        } else {
-          // Create new token
-          const { tx } = await this.wallet.createAction({
-            description: tokenSetDescription,
-            outputs: [{
-              satoshis: tokenAmount ?? this.config.tokenAmount as number,
-              lockingScript: lockingScript.toHex(),
-              outputDescription: 'KVStore token'
-            }],
-            options: {
-              acceptDelayedBroadcast: this.config.acceptDelayedBroadcast,
-              noSend: this.config.overlayBroadcast,
-              randomizeOutputs: false
-            }
-          }, this.config.originator)
-
-          if (tx == null) {
-            throw new Error('Failed to create transaction')
-          }
-
-          const transaction = Transaction.fromAtomicBEEF(tx)
-          await this.submitToOverlay(transaction)
-          return `${transaction.id('hex')}.0`
         }
       }, this.topicBroadcaster)
 
@@ -421,9 +421,7 @@ export class GlobalKVStore {
    * @private
    */
   private async getIdentityKey (): Promise<PubKeyHex> {
-    if (this.cachedIdentityKey == null) {
-      this.cachedIdentityKey = (await this.wallet.getPublicKey({ identityKey: true }, this.config.originator)).publicKey
-    }
+    this.cachedIdentityKey ??= (await this.wallet.getPublicKey({ identityKey: true }, this.config.originator)).publicKey
     return this.cachedIdentityKey
   }
 
@@ -467,13 +465,13 @@ export class GlobalKVStore {
         const signature = decoded.fields.pop() as number[]
         try {
           await anyoneWallet.verifySignature({
-            data: decoded.fields.reduce((a, e) => [...a, ...e], []),
+            data: decoded.fields.flat(),
             signature,
             counterparty: Utils.toHex(decoded.fields[kvProtocol.controller]),
             protocolID: JSON.parse(Utils.toUTF8(decoded.fields[kvProtocol.protocolID])),
             keyID: Utils.toUTF8(decoded.fields[kvProtocol.key])
           })
-        } catch (error) {
+        } catch (_signatureVerificationError) {
           // Skip all outputs that fail signature verification
           continue
         }
@@ -483,7 +481,7 @@ export class GlobalKVStore {
         if (hasTagsField && decoded.fields[kvProtocol.tags] != null) {
           try {
             tags = JSON.parse(Utils.toUTF8(decoded.fields[kvProtocol.tags]))
-          } catch (e) {
+          } catch (_tagsParseError) {
             // If tags parsing fails, continue without tags
             tags = undefined
           }
@@ -514,7 +512,8 @@ export class GlobalKVStore {
         }
 
         entries.push(entry)
-      } catch (error) {
+      } catch (_malformedOutputError) {
+        // Skip malformed or undecodable outputs rather than failing the entire query
         continue
       }
     }

package/src/kvstore/LocalKVStore.ts

@@ -155,7 +155,7 @@ export default class LocalKVStore {
     if (outputs.length === 0) {
       return r
     }
-    const output = outputs.slice(-1)[0]
+    const output = outputs.at(-1)!
     r.outpoint = output.outpoint
     let field: number[]
     try {
@@ -169,23 +169,23 @@ export default class LocalKVStore {
     } catch (error) {
       throw new Error(`Invalid value found. You need to call set to collapse the corrupted state (or relinquish the corrupted ${outputs[0].outpoint} output from the ${this.context} basket) before you can get this value again. Original error: ${error instanceof Error ? error.message : String(error)}`)
     }
-    if (!this.encrypt) {
-      r.value = Utils.toUTF8(field)
-    } else {
+    if (this.encrypt) {
       const { plaintext } = await this.wallet.decrypt({
         ...this.getProtocol(key),
         ciphertext: field
       }, this.originator)
       r.value = Utils.toUTF8(plaintext)
+    } else {
+      r.value = Utils.toUTF8(field)
     }
     return r
   }
 
   private getInputs (outputs: WalletOutput[]): CreateActionInput[] {
     const inputs: CreateActionInput[] = []
-    for (let i = 0; i < outputs.length; i++) {
+    for (const output of outputs) {
       inputs.push({
-        outpoint: outputs[i].outpoint,
+        outpoint: output.outpoint,
         unlockingScriptLength: 74,
         inputDescription: 'Previous key-value token'
       })
@@ -197,7 +197,7 @@ export default class LocalKVStore {
     const p = this.getProtocol(key)
     const tx = Transaction.fromAtomicBEEF(atomicBEEF)
     const spends: Record<number, SignActionSpend> = {}
-    for (let i = 0; i < outputs.length; i++) {
+    for (const [i] of outputs.entries()) {
       const unlocker = pushdrop.unlock(p.protocolID, p.keyID, 'self')
       const unlockingScript = await unlocker.sign(tx, i)
       spends[i] = {
@@ -328,7 +328,7 @@ export default class LocalKVStore {
               }
             }, this.originator)
             if (typeof signableTransaction !== 'object') {
-              throw new Error('Wallet did not return a signable transaction when expected.')
+              throw new TypeError('Wallet did not return a signable transaction when expected.')
             }
             const spends = await this.getSpends(key, outputs, pushdrop, signableTransaction.tx)
             const { txid } = await this.wallet.signAction({

package/src/kvstore/kvStoreInterpreter.ts

@@ -25,8 +25,8 @@ export interface KVContext { key: string, protocolID: WalletProtocol }
 export const kvStoreInterpreter: InterpreterFunction<string, KVContext> = async (transaction: Transaction, outputIndex: number, ctx?: KVContext): Promise<string | undefined> => {
   try {
     const output = transaction.outputs[outputIndex]
-    if (output == null || output.lockingScript == null) return undefined
-    if (ctx == null || ctx.key == null) return undefined
+    if (output?.lockingScript == null) return undefined
+    if (ctx?.key == null) return undefined
 
     // Decode the KVStore token
     const decoded = PushDrop.decode(output.lockingScript)

package/src/messages/SignedMessage.ts

@@ -72,7 +72,7 @@ export const verify = (
     const verifierRest = reader.read(32)
     const verifierDER = toHex([verifierFirst, ...verifierRest])
     if (typeof recipient !== 'object') {
-      throw new Error(
+      throw new TypeError(
         `This signature can only be verified with knowledge of a specific private key. The associated public key is: ${verifierDER}`
       )
     }

package/src/overlay-tools/Historian.ts

@@ -181,7 +181,7 @@ export class Historian<T, C = unknown> {
 
     // History is built in reverse chronological order during traversal,
     // so we reverse it to return oldest-first
-    const chronological = history.reverse()
+    const chronological = history.toReversed()
 
     if (this.historyCache != null) {
       const cacheKey = this.historyKey(startTransaction, context)