@bsv/wallet-toolbox 1.1.60 → 1.1.62

package/src/monitor/MonitorDaemon.ts

@@ -88,10 +88,7 @@ export class MonitorDaemon {
       if (a.storageProvider) {
         await a.storageProvider.makeAvailable()
         const settings = await a.storageProvider.getSettings()
-        a.storageManager = new WalletStorageManager(
-          settings.storageIdentityKey,
-          a.storageProvider
-        )
+        a.storageManager = new WalletStorageManager(settings.storageIdentityKey, a.storageProvider)
         await a.storageManager.makeAvailable()
       } else if (!a.storageManager) {
         throw new sdk.WERR_INVALID_PARAMETER(
@@ -102,10 +99,7 @@ export class MonitorDaemon {
 
       if (a.servicesOptions) {
         if (a.servicesOptions.chain != a.chain)
-          throw new sdk.WERR_INVALID_PARAMETER(
-            'serviceOptions.chain',
-            'same as args.chain'
-          )
+          throw new sdk.WERR_INVALID_PARAMETER('serviceOptions.chain', 'same as args.chain')
         a.services = new Services(a.servicesOptions)
       }
 
@@ -115,11 +109,7 @@ export class MonitorDaemon {
 
       a.storageManager.setServices(a.services)
 
-      const monitorOptions = Monitor.createDefaultWalletMonitorOptions(
-        a.chain,
-        a.storageManager,
-        a.services
-      )
+      const monitorOptions = Monitor.createDefaultWalletMonitorOptions(a.chain, a.storageManager, a.services)
       a.monitor = new Monitor(monitorOptions)
     }
 
@@ -130,8 +120,7 @@ export class MonitorDaemon {
 
   async start(): Promise<void> {
     if (!this.setup) await this.createSetup()
-    if (!this.setup?.monitor)
-      throw new sdk.WERR_INTERNAL('createSetup failed to initialize setup')
+    if (!this.setup?.monitor) throw new sdk.WERR_INTERNAL('createSetup failed to initialize setup')
 
     const { monitor } = this.setup
 
@@ -144,11 +133,7 @@ export class MonitorDaemon {
   async stop(): Promise<void> {
     console.log('start of stop')
 
-    if (
-      !this.setup ||
-      (!this.doneTasks && !this.noRunTasks) ||
-      !this.doneListening
-    )
+    if (!this.setup || (!this.doneTasks && !this.noRunTasks) || !this.doneListening)
       throw new sdk.WERR_INTERNAL('call start or createSetup first')
 
     const { monitor } = this.setup
@@ -189,9 +174,7 @@ export class MonitorDaemon {
         console.log('done')
       } catch (eu: unknown) {
         const e = sdk.WalletError.fromUnknown(eu)
-        console.log(
-          `\n\nrunWatchman Main Error Handler\n\ncode: ${e.code}\nDescription: ${e.description}\n\n\n`
-        )
+        console.log(`\n\nrunWatchman Main Error Handler\n\ncode: ${e.code}\nDescription: ${e.description}\n\n\n`)
       }
     }
   }

package/src/monitor/tasks/TaskCheckForProofs.ts

@@ -1,11 +1,4 @@
-import {
-  asString,
-  doubleSha256BE,
-  EntityProvenTx,
-  EntityProvenTxReq,
-  sdk,
-  TableProvenTxReq
-} from '../../index.client'
+import { asString, doubleSha256BE, EntityProvenTx, EntityProvenTxReq, sdk, TableProvenTxReq } from '../../index.client'
 import { Monitor } from '../Monitor'
 import { WalletMonitorTask } from './WalletMonitorTask'
 
@@ -45,8 +38,7 @@ export class TaskCheckForProofs extends WalletMonitorTask {
     return {
       run:
         TaskCheckForProofs.checkNow ||
-        (this.triggerMsecs > 0 &&
-          nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs)
+        (this.triggerMsecs > 0 && nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs)
     }
   }
 
@@ -60,14 +52,7 @@ export class TaskCheckForProofs extends WalletMonitorTask {
     for (;;) {
       const reqs = await this.storage.findProvenTxReqs({
         partial: {},
-        status: [
-          'callback',
-          'unmined',
-          'nosend',
-          'sending',
-          'unknown',
-          'unconfirmed'
-        ],
+        status: ['callback', 'unmined', 'nosend', 'sending', 'unknown', 'unconfirmed'],
         paged: { limit, offset }
       })
       if (reqs.length === 0) break
@@ -189,11 +174,7 @@ export class TaskCheckForProofs extends WalletMonitorTask {
       // one more time.
       //
       r = await this.monitor.services.getMerklePath(req.txid)
-      ptx = await EntityProvenTx.fromReq(
-        req,
-        r,
-        countsAsAttempt && req.status !== 'nosend'
-      )
+      ptx = await EntityProvenTx.fromReq(req, r, countsAsAttempt && req.status !== 'nosend')
 
       if (ptx) {
         // We have a merklePath proof for the request (and a block header)

package/src/monitor/tasks/TaskClock.ts

@@ -28,8 +28,6 @@ export class TaskClock extends WalletMonitorTask {
   }
 
   getNextMinute(): number {
-    return (
-      Math.ceil(Date.now() / this.monitor.oneMinute) * this.monitor.oneMinute
-    )
+    return Math.ceil(Date.now() / this.monitor.oneMinute) * this.monitor.oneMinute
   }
 }

package/src/monitor/tasks/TaskFailAbandoned.ts

@@ -32,9 +32,7 @@ export class TaskFailAbandoned extends WalletMonitorTask {
     let offset = 0
     for (;;) {
       const now = new Date()
-      const abandoned = new Date(
-        now.getTime() - this.monitor.options.abandonedMsecs
-      )
+      const abandoned = new Date(now.getTime() - this.monitor.options.abandonedMsecs)
       const done = await this.storage.runAsStorageProvider(async sp => {
         const txsAll = await sp.findTransactions({
           partial: {},

package/src/monitor/tasks/TaskNewHeader.ts

@@ -34,10 +34,7 @@ export class TaskNewHeader extends WalletMonitorTask {
       const skip = this.header.height - oldHeader.height - 1
       const skipped = skip > 0 ? ` SKIPPED ${skip}` : ''
       log = `new header: ${this.header.height} ${this.header.hash}${skipped}`
-    } else if (
-      oldHeader.height === this.header.height &&
-      oldHeader.hash != this.header.hash
-    ) {
+    } else if (oldHeader.height === this.header.height && oldHeader.hash != this.header.hash) {
       log = `reorg header: ${this.header.height} ${this.header.hash}`
     } else {
       isNew = false

package/src/monitor/tasks/TaskPurge.ts

@@ -49,8 +49,7 @@ export class TaskPurge extends WalletMonitorTask {
     return {
       run:
         TaskPurge.checkNow ||
-        (this.triggerMsecs > 0 &&
-          nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs)
+        (this.triggerMsecs > 0 && nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs)
     }
   }
 

package/src/monitor/tasks/TaskReviewStatus.ts

@@ -29,9 +29,7 @@ export class TaskReviewStatus extends WalletMonitorTask {
 
   trigger(nowMsecsSinceEpoch: number): { run: boolean } {
     return {
-      run:
-        this.triggerMsecs > 0 &&
-        nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs
+      run: this.triggerMsecs > 0 && nowMsecsSinceEpoch - this.lastRunMsecsSinceEpoch > this.triggerMsecs
     }
   }
 

package/src/monitor/tasks/TaskSendWaiting.ts

@@ -34,9 +34,7 @@ export class TaskSendWaiting extends WalletMonitorTask {
       })
       if (reqs.length === 0) break
       log += `${reqs.length} reqs with status 'unsent'\n`
-      const agedReqs = reqs.filter(
-        req => verifyTruthy(req.updated_at) < agedLimit
-      )
+      const agedReqs = reqs.filter(req => verifyTruthy(req.updated_at) < agedLimit)
       log += `  Of those reqs, ${agedReqs.length} where last updated before ${agedLimit.toISOString()}.\n`
       log += await this.processUnsent(agedReqs, 2)
       if (reqs.length < limit) break
@@ -62,10 +60,7 @@ export class TaskSendWaiting extends WalletMonitorTask {
    *
    * @param reqApis
    */
-  async processUnsent(
-    reqApis: TableProvenTxReq[],
-    indent = 0
-  ): Promise<string> {
+  async processUnsent(reqApis: TableProvenTxReq[], indent = 0): Promise<string> {
     let log = ''
     for (let i = 0; i < reqApis.length; i++) {
       const reqApi = reqApis[i]
@@ -84,9 +79,7 @@ export class TaskSendWaiting extends WalletMonitorTask {
         })
         for (const bra of batchReqApis) {
           // Remove any matching batchReqApis from reqApis
-          const index = reqApis.findIndex(
-            ra => ra.provenTxReqId === bra.provenTxReqId
-          )
+          const index = reqApis.findIndex(ra => ra.provenTxReqId === bra.provenTxReqId)
           if (index > -1) reqApis.slice(index, index + 1)
           // And add to reqs being processed now:
           reqs.push(new EntityProvenTxReq(bra))

package/src/sdk/CertOps.ts

@@ -23,14 +23,8 @@ export interface CertOpsWallet {
     args: GetPublicKeyArgs,
     originator?: OriginatorDomainNameStringUnder250Bytes
   ): Promise<GetPublicKeyResult>
-  encrypt(
-    args: WalletEncryptArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<WalletEncryptResult>
-  decrypt(
-    args: WalletDecryptArgs,
-    originator?: OriginatorDomainNameStringUnder250Bytes
-  ): Promise<WalletDecryptResult>
+  encrypt(args: WalletEncryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<WalletEncryptResult>
+  decrypt(args: WalletDecryptArgs, originator?: OriginatorDomainNameStringUnder250Bytes): Promise<WalletDecryptResult>
 }
 
 export class CertOps extends BsvCertificate {
@@ -42,15 +36,7 @@ export class CertOps extends BsvCertificate {
     public wallet: CertOpsWallet,
     wc: WalletCertificate
   ) {
-    super(
-      wc.type,
-      wc.serialNumber,
-      wc.subject,
-      wc.certifier,
-      wc.revocationOutpoint,
-      wc.fields,
-      wc.signature
-    )
+    super(wc.type, wc.serialNumber, wc.subject, wc.certifier, wc.revocationOutpoint, wc.fields, wc.signature)
   }
 
   static async fromCounterparty(
@@ -96,13 +82,9 @@ export class CertOps extends BsvCertificate {
     return c
   }
 
-  static async fromDecrypted(
-    wallet: CertOpsWallet,
-    wc: WalletCertificate
-  ): Promise<CertOps> {
+  static async fromDecrypted(wallet: CertOpsWallet, wc: WalletCertificate): Promise<CertOps> {
     const c = new CertOps(wallet, wc)
-    ;({ fields: c._encryptedFields, keyring: c._keyring } =
-      await c.encryptFields())
+    ;({ fields: c._encryptedFields, keyring: c._keyring } = await c.encryptFields())
     c._decryptedFields = await c.decryptFields()
     return c
   }
@@ -129,15 +111,8 @@ export class CertOps extends BsvCertificate {
     certificate: WalletCertificate
     keyring: Record<CertificateFieldNameUnder50Bytes, string>
   } {
-    if (
-      !this._keyring ||
-      !this._encryptedFields ||
-      !this.signature ||
-      this.signature.length === 0
-    )
-      throw new WERR_INVALID_OPERATION(
-        `Certificate must be encrypted and signed prior to export.`
-      )
+    if (!this._keyring || !this._encryptedFields || !this.signature || this.signature.length === 0)
+      throw new WERR_INVALID_OPERATION(`Certificate must be encrypted and signed prior to export.`)
     const certificate = this.toWalletCertificate()
     const keyring = this._keyring!
     return { certificate, keyring }
@@ -155,30 +130,19 @@ export class CertOps extends BsvCertificate {
     fields: Record<CertificateFieldNameUnder50Bytes, string>
     keyring: Record<CertificateFieldNameUnder50Bytes, string>
   }> {
-    const fields: Record<CertificateFieldNameUnder50Bytes, string> =
-      this._decryptedFields || this.fields
-    const encryptedFields: Record<
-      CertificateFieldNameUnder50Bytes,
-      Base64String
-    > = {}
+    const fields: Record<CertificateFieldNameUnder50Bytes, string> = this._decryptedFields || this.fields
+    const encryptedFields: Record<CertificateFieldNameUnder50Bytes, Base64String> = {}
     const keyring: Record<CertificateFieldNameUnder50Bytes, Base64String> = {}
 
     for (const fieldName of Object.keys(fields)) {
       const fieldSymmetricKey = SymmetricKey.fromRandom()
-      const encryptedFieldValue = fieldSymmetricKey.encrypt(
-        Utils.toArray(this.fields[fieldName], 'utf8')
-      )
-      encryptedFields[fieldName] = Utils.toBase64(
-        encryptedFieldValue as number[]
-      )
+      const encryptedFieldValue = fieldSymmetricKey.encrypt(Utils.toArray(this.fields[fieldName], 'utf8'))
+      encryptedFields[fieldName] = Utils.toBase64(encryptedFieldValue as number[])
 
       const encryptedFieldKey = await this.wallet.encrypt({
         plaintext: fieldSymmetricKey.toArray(),
         counterparty,
-        ...CertOps.getProtocolForCertificateFieldEncryption(
-          this.serialNumber,
-          fieldName
-        )
+        ...CertOps.getProtocolForCertificateFieldEncryption(this.serialNumber, fieldName)
       })
       keyring[fieldName] = Utils.toBase64(encryptedFieldKey.ciphertext)
     }
@@ -193,8 +157,7 @@ export class CertOps extends BsvCertificate {
     keyring?: Record<CertificateFieldNameUnder50Bytes, string>
   ): Promise<Record<CertificateFieldNameUnder50Bytes, string>> {
     keyring ||= this._keyring
-    const fields: Record<CertificateFieldNameUnder50Bytes, Base64String> =
-      this._encryptedFields || this.fields
+    const fields: Record<CertificateFieldNameUnder50Bytes, Base64String> = this._encryptedFields || this.fields
     const decryptedFields: Record<CertificateFieldNameUnder50Bytes, string> = {}
     if (!keyring) throw new sdk.WERR_INVALID_PARAMETER('keyring', 'valid')
 
@@ -203,15 +166,10 @@ export class CertOps extends BsvCertificate {
         const { plaintext: fieldRevelationKey } = await this.wallet.decrypt({
           ciphertext: Utils.toArray(keyring[fieldName], 'base64'),
           counterparty: counterparty || this.subject,
-          ...CertOps.getProtocolForCertificateFieldEncryption(
-            this.serialNumber,
-            fieldName
-          )
+          ...CertOps.getProtocolForCertificateFieldEncryption(this.serialNumber, fieldName)
         })
 
-        const fieldValue = new SymmetricKey(fieldRevelationKey).decrypt(
-          Utils.toArray(fields[fieldName], 'base64')
-        )
+        const fieldValue = new SymmetricKey(fieldRevelationKey).decrypt(Utils.toArray(fields[fieldName], 'base64'))
         decryptedFields[fieldName] = Utils.toUTF8(fieldValue as number[])
       }
       this._keyring = keyring
@@ -233,20 +191,10 @@ export class CertOps extends BsvCertificate {
     keyring: Record<CertificateFieldNameUnder50Bytes, string>
     counterparty: PubKeyHex
   }> {
-    if (
-      !this._keyring ||
-      !this._encryptedFields ||
-      !this.signature ||
-      this.signature.length === 0
-    )
-      throw new WERR_INVALID_OPERATION(
-        `Certificate must be encrypted and signed prior to export.`
-      )
+    if (!this._keyring || !this._encryptedFields || !this.signature || this.signature.length === 0)
+      throw new WERR_INVALID_OPERATION(`Certificate must be encrypted and signed prior to export.`)
     const certificate = this.toWalletCertificate()
-    const keyring = await this.createKeyringForVerifier(
-      counterparty,
-      fieldsToReveal
-    )
+    const keyring = await this.createKeyringForVerifier(counterparty, fieldsToReveal)
     // The exported counterparty is who we are to them...
     return {
       certificate,
@@ -272,24 +220,14 @@ export class CertOps extends BsvCertificate {
     verifierIdentityKey: PubKeyHex,
     fieldsToReveal: CertificateFieldNameUnder50Bytes[]
   ): Promise<Record<CertificateFieldNameUnder50Bytes, Base64String>> {
-    if (!this._keyring || !this._encryptedFields)
-      throw new sdk.WERR_INVALID_OPERATION(`certificate must be encrypted`)
-    if (
-      !Array.isArray(fieldsToReveal) ||
-      fieldsToReveal.some(n => this._encryptedFields![n] === undefined)
-    )
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'fieldsToReveal',
-        `an array of certificate field names`
-      )
+    if (!this._keyring || !this._encryptedFields) throw new sdk.WERR_INVALID_OPERATION(`certificate must be encrypted`)
+    if (!Array.isArray(fieldsToReveal) || fieldsToReveal.some(n => this._encryptedFields![n] === undefined))
+      throw new sdk.WERR_INVALID_PARAMETER('fieldsToReveal', `an array of certificate field names`)
     const fieldRevelationKeyring = {}
     for (const fieldName of fieldsToReveal) {
       // Create a keyID
       const encryptedFieldKey = this._keyring[fieldName]
-      const protocol = CertOps.getProtocolForCertificateFieldEncryption(
-        this.serialNumber,
-        fieldName
-      )
+      const protocol = CertOps.getProtocolForCertificateFieldEncryption(this.serialNumber, fieldName)
 
       // Decrypt the master field key
       const { plaintext: fieldKey } = await this.wallet.decrypt({
@@ -300,27 +238,20 @@ export class CertOps extends BsvCertificate {
 
       // Verify that derived key actually decrypts requested field
       try {
-        new SymmetricKey(fieldKey).decrypt(
-          Utils.toArray(this.fields[fieldName], 'base64')
-        )
+        new SymmetricKey(fieldKey).decrypt(Utils.toArray(this.fields[fieldName], 'base64'))
       } catch (_) {
-        throw new sdk.WERR_INTERNAL(
-          `unable to decrypt field "${fieldName}" using derived field key.`
-        )
+        throw new sdk.WERR_INTERNAL(`unable to decrypt field "${fieldName}" using derived field key.`)
       }
 
       // Encrypt derived fieldRevelationKey for verifier
-      const { ciphertext: encryptedFieldRevelationKey } =
-        await this.wallet.encrypt({
-          plaintext: fieldKey,
-          counterparty: verifierIdentityKey,
-          ...protocol
-        })
+      const { ciphertext: encryptedFieldRevelationKey } = await this.wallet.encrypt({
+        plaintext: fieldKey,
+        counterparty: verifierIdentityKey,
+        ...protocol
+      })
 
       // Add encryptedFieldRevelationKey to fieldRevelationKeyring
-      fieldRevelationKeyring[fieldName] = Utils.toBase64(
-        encryptedFieldRevelationKey
-      )
+      fieldRevelationKeyring[fieldName] = Utils.toBase64(encryptedFieldRevelationKey)
     }
 
     // Return the field revelation keyring which can be used to create a verifiable certificate for a verifier.
@@ -333,10 +264,7 @@ export class CertOps extends BsvCertificate {
    */
   async encryptAndSignNewCertificate(): Promise<void> {
     if ((await getIdentityKey(this.wallet)) !== this.certifier)
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'wallet',
-        'the certifier for new certificate issuance.'
-      )
+      throw new sdk.WERR_INVALID_PARAMETER('wallet', 'the certifier for new certificate issuance.')
 
     await this.encryptFields(this.subject)
     await this.sign(this.wallet as unknown as WalletInterface)

package/src/sdk/PrivilegedKeyManager.ts

@@ -90,10 +90,7 @@ export class PrivilegedKeyManager implements ProtoWallet {
    * @param keyGetter - Asynchronous function that retrieves the PrivateKey from a secure environment.
    * @param retentionPeriod - Time in milliseconds to retain the obfuscated key in memory before zeroizing.
    */
-  constructor(
-    keyGetter: (reason: string) => Promise<PrivateKey>,
-    retentionPeriod = 120_000
-  ) {
+  constructor(keyGetter: (reason: string) => Promise<PrivateKey>, retentionPeriod = 120_000) {
     this.keyGetter = keyGetter
     this.retentionPeriod = retentionPeriod
 
@@ -192,8 +189,7 @@ export class PrivilegedKeyManager implements ProtoWallet {
     let offset = 0
 
     for (let i = 0; i < this.CHUNK_COUNT; i++) {
-      const size =
-        i === this.CHUNK_COUNT - 1 ? keyBytes.length - offset : chunkSize
+      const size = i === this.CHUNK_COUNT - 1 ? keyBytes.length - offset : chunkSize
       chunks.push(keyBytes.slice(offset, offset + size))
       offset += size
     }
@@ -256,9 +252,7 @@ export class PrivilegedKeyManager implements ProtoWallet {
     // if the numeric value has leading zeros.
     const buf = privKey.toArray()
     if (buf.length > 32) {
-      throw new Error(
-        'PrivilegedKeyManager: Expected a 32-byte key, but got more.'
-      )
+      throw new Error('PrivilegedKeyManager: Expected a 32-byte key, but got more.')
     }
     // Left-pad with zeros if needed
     const keyBytes = new Uint8Array(32)
@@ -336,67 +330,43 @@ export class PrivilegedKeyManager implements ProtoWallet {
     return fetchedKey
   }
 
-  async getPublicKey(
-    args: GetPublicKeyArgs
-  ): Promise<{ publicKey: PubKeyHex }> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).getPublicKey(args)
+  async getPublicKey(args: GetPublicKeyArgs): Promise<{ publicKey: PubKeyHex }> {
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).getPublicKey(args)
   }
 
   async revealCounterpartyKeyLinkage(
     args: RevealCounterpartyKeyLinkageArgs
   ): Promise<RevealCounterpartyKeyLinkageResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).revealCounterpartyKeyLinkage(args)
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).revealCounterpartyKeyLinkage(
+      args
+    )
   }
 
-  async revealSpecificKeyLinkage(
-    args: RevealSpecificKeyLinkageArgs
-  ): Promise<RevealSpecificKeyLinkageResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).revealSpecificKeyLinkage(args)
+  async revealSpecificKeyLinkage(args: RevealSpecificKeyLinkageArgs): Promise<RevealSpecificKeyLinkageResult> {
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).revealSpecificKeyLinkage(args)
   }
 
   async encrypt(args: WalletEncryptArgs): Promise<WalletEncryptResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).encrypt(args)
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).encrypt(args)
   }
 
   async decrypt(args: WalletDecryptArgs): Promise<WalletDecryptResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).decrypt(args)
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).decrypt(args)
   }
 
   async createHmac(args: CreateHmacArgs): Promise<CreateHmacResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).createHmac(args)
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).createHmac(args)
   }
 
   async verifyHmac(args: VerifyHmacArgs): Promise<VerifyHmacResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).verifyHmac(args)
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).verifyHmac(args)
   }
 
-  async createSignature(
-    args: CreateSignatureArgs
-  ): Promise<CreateSignatureResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).createSignature(args)
+  async createSignature(args: CreateSignatureArgs): Promise<CreateSignatureResult> {
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).createSignature(args)
   }
 
-  async verifySignature(
-    args: VerifySignatureArgs
-  ): Promise<VerifySignatureResult> {
-    return new ProtoWallet(
-      await this.getPrivilegedKey(args.privilegedReason as string)
-    ).verifySignature(args)
+  async verifySignature(args: VerifySignatureArgs): Promise<VerifySignatureResult> {
+    return new ProtoWallet(await this.getPrivilegedKey(args.privilegedReason as string)).verifySignature(args)
   }
 }

package/src/sdk/WERR_errors.ts

@@ -28,10 +28,7 @@ export class WERR_INTERNAL extends WalletError {
  */
 export class WERR_INVALID_OPERATION extends WalletError {
   constructor(message?: string) {
-    super(
-      'WERR_INVALID_OPERATION',
-      message ?? `An invalid operation was requested.`
-    )
+    super('WERR_INVALID_OPERATION', message ?? `An invalid operation was requested.`)
   }
 }
 
@@ -40,10 +37,7 @@ export class WERR_INVALID_OPERATION extends WalletError {
  */
 export class WERR_BROADCAST_UNAVAILABLE extends WalletError {
   constructor(message?: string) {
-    super(
-      'WERR_BROADCAST_UNAVAILABLE',
-      `Unable to broadcast transaction at this time.`
-    )
+    super('WERR_BROADCAST_UNAVAILABLE', `Unable to broadcast transaction at this time.`)
   }
 }
 
@@ -57,10 +51,7 @@ export class WERR_INVALID_PARAMETER extends WalletError {
     public parameter: string,
     mustBe?: string
   ) {
-    super(
-      'WERR_INVALID_PARAMETER',
-      `The ${parameter} parameter must be ${mustBe ?? 'valid.'}`
-    )
+    super('WERR_INVALID_PARAMETER', `The ${parameter} parameter must be ${mustBe ?? 'valid.'}`)
   }
 }
 
@@ -71,10 +62,7 @@ export class WERR_INVALID_PARAMETER extends WalletError {
  */
 export class WERR_MISSING_PARAMETER extends WalletError {
   constructor(public parameter: string) {
-    super(
-      'WERR_MISSING_PARAMETER',
-      `The required ${parameter} parameter is missing.`
-    )
+    super('WERR_MISSING_PARAMETER', `The required ${parameter} parameter is missing.`)
   }
 }
 
@@ -92,11 +80,7 @@ export class WERR_BAD_REQUEST extends WalletError {
  */
 export class WERR_NETWORK_CHAIN extends WalletError {
   constructor(message?: string) {
-    super(
-      'WERR_NETWORK_CHAIN',
-      message ??
-        'Configured network chain is invalid or does not match across services.'
-    )
+    super('WERR_NETWORK_CHAIN', message ?? 'Configured network chain is invalid or does not match across services.')
   }
 }
 
@@ -105,10 +89,7 @@ export class WERR_NETWORK_CHAIN extends WalletError {
  */
 export class WERR_UNAUTHORIZED extends WalletError {
   constructor(message?: string) {
-    super(
-      'WERR_UNAUTHORIZED',
-      message ?? 'Access is denied due to an authorization error.'
-    )
+    super('WERR_UNAUTHORIZED', message ?? 'Access is denied due to an authorization error.')
   }
 }