@bsv/wallet-toolbox 1.6.33 → 1.6.34

package/src/storage/WalletStorageManager.ts

@@ -525,9 +525,9 @@ export class WalletStorageManager implements sdk.WalletStorage {
    * For each proven_txs record currently sourcing its transaction merkle proof from the given deactivated header,
    * attempt to reprove the transaction against the current chain,
    * updating the proven_txs record if a new valid proof is found.
-   * 
+   *
    * @param deactivatedHash An orphaned header than may have served as a proof source for proven_txs records.
-   * @returns 
+   * @returns
    */
   async reproveHeader(deactivatedHash: string): Promise<sdk.ReproveHeaderResult> {
     const r: sdk.ReproveHeaderResult = { log: '', updated: [], unchanged: [], unavailable: [] }
@@ -547,8 +547,8 @@ export class WalletStorageManager implements sdk.WalletStorage {
       const rp = await this.reproveProven(ptx, true)
 
       r.log += rp.log
-      if (rp.unavailable) r.unavailable.push(ptx);
-      if (rp.unchanged) r.unchanged.push(ptx);
+      if (rp.unavailable) r.unavailable.push(ptx)
+      if (rp.unchanged) r.unchanged.push(ptx)
       if (rp.updated) r.updated.push({ was: ptx, update: rp.updated.update, logUpdate: rp.updated.logUpdate })
     }
 
@@ -566,14 +566,14 @@ export class WalletStorageManager implements sdk.WalletStorage {
 
   /**
    * Extends the Beef `verify` function to handle BUMPs that have become invalid due to a chain reorg.
-   * 
+   *
    * 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.
    * Finally, a new beef is generated and verified against the chaintracker.
-   * 
-   * @param beef 
-   * @param allowTxidOnly 
-   * @returns 
+   *
+   * @param beef
+   * @param allowTxidOnly
+   * @returns
    */
   async verifyAndRepairBeef(beef: Beef, allowTxidOnly?: boolean): Promise<boolean> {
     throw new sdk.WERR_NOT_IMPLEMENTED()
@@ -587,10 +587,7 @@ export class WalletStorageManager implements sdk.WalletStorage {
 
     const invalidRoots: Record<number, string> = {}
     for (const height of Object.keys(r.roots)) {
-      const isValid = await chaintracker.isValidRootForHeight(
-        r.roots[height],
-        Number(height)
-      )
+      const isValid = await chaintracker.isValidRootForHeight(r.roots[height], Number(height))
       if (!isValid) {
         invalidRoots[height] = r.roots[height]
       }
@@ -619,10 +616,10 @@ export class WalletStorageManager implements sdk.WalletStorage {
    * If a new valid proof is found and noUpdate is not true,
    * update the proven_txs record with new block and merkle proof data.
    * If noUpdate is true, the update to be applied is available in the returned result.
-   * 
+   *
    * @param ptx proven_txs record to reprove
-   * @param noUpdate 
-   * @returns 
+   * @param noUpdate
+   * @returns
    */
   async reproveProven(ptx: TableProvenTx, noUpdate?: boolean): Promise<sdk.ReproveProvenResult> {
     const r: sdk.ReproveProvenResult = { log: '', updated: undefined, unchanged: false, unavailable: false }
@@ -672,8 +669,8 @@ export class WalletStorageManager implements sdk.WalletStorage {
 
     if (r.updated && !noUpdate) {
       await this.runAsStorageProvider(async sp => {
-          await sp.updateProvenTx(ptx.provenTxId, r.updated!.update)
-          r.log += `    txid ${ptx.txid} proof data updated\n` + r.updated!.logUpdate
+        await sp.updateProvenTx(ptx.provenTxId, r.updated!.update)
+        r.log += `    txid ${ptx.txid} proof data updated\n` + r.updated!.logUpdate
       })
     }
 
@@ -924,4 +921,4 @@ export class WalletStorageManager implements sdk.WalletStorage {
     }
     return stores
   }
-}
+}

package/src/storage/methods/internalizeAction.ts

@@ -559,4 +559,4 @@ class InternalizeActionContext {
 
     basket.eo = txOut
   }
-}
+}

package/src/storage/remoting/StorageClient.ts

@@ -44,6 +44,8 @@ import { TableOutputBasket } from '../schema/tables/TableOutputBasket'
 import { TableOutput } from '../schema/tables/TableOutput'
 import { TableProvenTxReq } from '../schema/tables/TableProvenTxReq'
 import { EntityTimeStamp } from '../../sdk/types'
+import { WalletError } from '../../sdk/WalletError'
+import { WalletErrorFromJson } from '../../sdk/WalletErrorFromJson'
 
 /**
  * `StorageClient` implements the `WalletStorageProvider` interface which allows it to
@@ -118,12 +120,8 @@ export class StorageClient implements WalletStorageProvider {
 
       const json = await response.json()
       if (json.error) {
-        const { code, message, data } = json.error
-        const err = new Error(`RPC Error: ${message}`)
-        // You could attach more info here if you like:
-        ;(err as any).code = code
-        ;(err as any).data = data
-        throw err
+        const werr = WalletErrorFromJson(json.error)
+        throw werr
       }
 
       return json.result

package/src/storage/remoting/StorageServer.ts

@@ -14,6 +14,7 @@ import { StorageProvider } from '../StorageProvider'
 import { WERR_UNAUTHORIZED } from '../../sdk/WERR_errors'
 import { SyncChunk } from '../../sdk/WalletStorage.interfaces'
 import { EntityTimeStamp } from '../../sdk/types'
+import { WalletError } from '../../sdk/WalletError'
 
 export interface WalletStorageServerOptions {
   port: number
@@ -165,19 +166,20 @@ export class StorageServer {
             id
           })
         }
-      } catch (error) {
-        // Catch any thrown errors from the local walletStorage method
-        const err = error as Error
+      } catch (error: unknown) {
+        /**
+         * Catch any thrown errors from the local walletStorage method.
+         *
+         * Convert errors to standard JSON object format that can be converted
+         * back to WalletError derived objects on the client side and re-thrown.
+         *
+         * Uses WalletError.fromJson(<error object>) on the client side to re-create
+         * an error object of the right class and properties.
+         */
+        const json = WalletError.unknownToJson(error)
         return res.status(200).json({
           jsonrpc: '2.0',
-          error: {
-            code: -32000,
-            message: err.message,
-            data: {
-              name: err.name,
-              stack: err.stack
-            }
-          },
+          error: JSON.parse(json),
           id
         })
       }

package/test/Wallet/specOps/specOps.man.test.ts

@@ -200,13 +200,15 @@ describe('specOps tests', () => {
 
 async function createSetup(chain: sdk.Chain): Promise<TestWalletNoSetup> {
   const env = _tu.getEnv(chain)
-  if (!env.testIdentityKey) throw new sdk.WERR_INVALID_PARAMETER('env.testIdentityKey', 'valid')
-  if (!env.testFilePath) throw new sdk.WERR_INVALID_PARAMETER('env.testFilePath', 'valid')
+  const identityKey = chain === 'test' ? env.testIdentityKey : env.identityKey
+  const filePath = chain === 'test' ? env.testFilePath : env.filePath
+  if (!identityKey) throw new sdk.WERR_INVALID_PARAMETER('identityKey', 'valid for chain ' + chain)
+  if (!filePath) throw new sdk.WERR_INVALID_PARAMETER('filePath', 'valid for chain ' + chain)
 
   const setup = await _tu.createTestWallet({
     chain,
-    rootKeyHex: env.devKeys[env.testIdentityKey],
-    filePath: env.testFilePath,
+    rootKeyHex: env.devKeys[identityKey],
+    filePath,
     setActiveClient: false,
     addLocalBackup: false,
     useMySQLConnectionForClient: false