@bsv/wallet-toolbox 1.6.1 → 1.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",

package/src/services/Services.ts

@@ -413,10 +413,14 @@ export class Services implements WalletServices {
   async hashToHeader(hash: string): Promise<BlockHeader> {
     const method = async () => {
       const header = await this.options.chaintracks!.findHeaderForBlockHash(hash)
-      if (!header) throw new WERR_INVALID_PARAMETER('hash', `valid blockhash '${hash}' on mined chain ${this.chain}`)
       return header
     }
-    return this.invokeChaintracksWithRetry(method)
+    let header = await this.invokeChaintracksWithRetry(method)
+    if (!header) {
+      header = await this.whatsonchain.getBlockHeaderByHash(hash)
+    }
+    if (!header) throw new WERR_INVALID_PARAMETER('hash', `valid blockhash '${hash}' on mined chain ${this.chain}`)
+    return header
   }
 
   async getMerklePath(txid: string, useNext?: boolean): Promise<GetMerklePathResult> {

package/src/services/chaintracker/__tests/ChaintracksServiceClient.test.ts

@@ -23,5 +23,7 @@ describe('ChaintracksServiceClient tests', () => {
 })
 
 function makeClient(chain: sdk.Chain) {
-  return new ChaintracksServiceClient(chain, `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`)
+  //const chaintracksUrl = `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`
+  const chaintracksUrl = `https://${chain}net-chaintracks.babbage.systems`
+  return new ChaintracksServiceClient(chain, chaintracksUrl)
 }

package/src/services/chaintracker/chaintracks/Ingest/LiveIngestorWhatsOnChainPoll.ts

@@ -2,11 +2,10 @@ import { BlockHeader, Chain } from '../../../../sdk'
 import { wait } from '../../../../utility/utilityHelpers'
 import { LiveIngestorBase, LiveIngestorBaseOptions } from './LiveIngestorBase'
 import {
-  EnqueueHandler,
-  ErrorHandler,
   WhatsOnChainServices,
   WhatsOnChainServicesOptions,
-  WocGetHeadersHeader
+  WocGetHeadersHeader,
+  wocGetHeadersHeaderToBlockHeader
 } from './WhatsOnChainServices'
 
 export interface LiveIngestorWhatsOnChainOptions extends LiveIngestorBaseOptions, WhatsOnChainServicesOptions {
@@ -81,20 +80,7 @@ export class LiveIngestorWhatsOnChainPoll extends LiveIngestorBase {
       const newHeaders = headers.filter(h => !lastHeaders.some(lh => lh.hash === h.hash))
 
       for (const h of newHeaders) {
-        const bits: number = typeof h.bits === 'string' ? parseInt(h.bits, 16) : h.bits
-        if (!h.previousblockhash) {
-          h.previousblockhash = '0000000000000000000000000000000000000000000000000000000000000000' // genesis
-        }
-        const bh: BlockHeader = {
-          height: h.height,
-          hash: h.hash,
-          version: h.version,
-          previousHash: h.previousblockhash,
-          merkleRoot: h.merkleroot,
-          time: h.time,
-          bits,
-          nonce: h.nonce
-        }
+        const bh = wocGetHeadersHeaderToBlockHeader(h)
         liveHeaders.unshift(bh)
       }
 

package/src/services/chaintracker/chaintracks/Ingest/WhatsOnChainServices.ts

@@ -192,6 +192,25 @@ export interface WocGetHeadersHeader {
   num_tx: number
 }
 
+export function wocGetHeadersHeaderToBlockHeader(h: WocGetHeadersHeader): BlockHeader {
+  const bits: number = typeof h.bits === 'string' ? parseInt(h.bits, 16) : h.bits
+  if (!h.previousblockhash) {
+    h.previousblockhash = '0000000000000000000000000000000000000000000000000000000000000000' // genesis
+  }
+  const bh: BlockHeader = {
+    height: h.height,
+    hash: h.hash,
+    version: h.version,
+    previousHash: h.previousblockhash,
+    merkleRoot: h.merkleroot,
+    time: h.time,
+    bits,
+    nonce: h.nonce
+  }
+
+  return bh
+}
+
 export interface GetHeaderByteFileLinksResult {
   sourceUrl: string
   fileName: string

package/src/services/chaintracker/chaintracks/__tests/ChaintracksClientApi.test.ts

@@ -22,13 +22,14 @@ clientClass = 'Chaintracks'
 const includeLocalServiceClient = true
 const includeLocalServiceChaintracks = true
 const includeNpmRegistryClient = true
+const includeGcrTestClient = true
 
 describe(`ChaintracksClientApi tests`, () => {
   jest.setTimeout(999999999)
 
   const chain: Chain = 'main'
 
-  const clients: ChaintracksClientApi[] = []
+  const clients: { client: ChaintracksClientApi; chain: Chain }[] = []
 
   let localService: ChaintracksService
   let localServiceStorage: ChaintracksStorageApi
@@ -43,19 +44,28 @@ describe(`ChaintracksClientApi tests`, () => {
 
       if (includeLocalServiceClient) {
         localServiceClient = new ChaintracksServiceClient(chain, `http://localhost:${localService.port}`, {})
-        clients.push(localServiceClient)
+        clients.push({ client: localServiceClient, chain })
       }
 
       if (includeLocalServiceChaintracks) {
-        clients.push(localService.chaintracks)
+        clients.push({ client: localService.chaintracks, chain })
       }
     }
 
+    if (includeGcrTestClient) {
+      const gcr = new ChaintracksServiceClient('test', `https://testnet-chaintracks.babbage.systems`, {})
+      clients.push({ client: gcr, chain: 'test' })
+    }
+    if (includeGcrTestClient) {
+      const gcr = new ChaintracksServiceClient('main', `https://mainnet-chaintracks.babbage.systems`, {})
+      clients.push({ client: gcr, chain: 'main' })
+    }
+
     if (includeNpmRegistryClient) {
-      clients.push(makeNpmRegistryClient(chain))
+      clients.push({ client: makeNpmRegistryClient(chain), chain })
     }
 
-    const ft = await clients[0].findChainTipHeader()
+    const ft = await clients[0].client.findChainTipHeader()
     if (!ft) throw new Error('No chain tip found')
     firstTip = ft
   })
@@ -65,30 +75,30 @@ describe(`ChaintracksClientApi tests`, () => {
   })
 
   test('0 getChain', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const gotChain = await client.getChain()
       expect(gotChain).toBe(chain)
     }
   })
 
   test('1 getInfo', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const gotInfo = await client.getInfo()
       expect(gotInfo.chain).toBe(chain)
       expect(gotInfo.heightBulk).toBeGreaterThan(700000)
-      expect(gotInfo.heightLive).toBeGreaterThanOrEqual(firstTip.height)
+      expect(gotInfo.heightLive).toBeGreaterThanOrEqual(firstTip.height - 2)
     }
   })
 
   test('2 getPresentHeight', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const presentHeight = await client.getPresentHeight()
-      expect(presentHeight).toBeGreaterThanOrEqual(firstTip.height)
+      expect(presentHeight).toBeGreaterThanOrEqual(firstTip.height - 2)
     }
   })
 
   test('3 getHeaders', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const info = await client.getInfo()
       const h0 = info.heightBulk + 1
       const h1 = info.heightLive || 10
@@ -113,21 +123,21 @@ describe(`ChaintracksClientApi tests`, () => {
   })
 
   test('4 findChainTipHeader', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const tipHeader = await client.findChainTipHeader()
       expect(tipHeader.height >= firstTip.height).toBe(true)
     }
   })
 
   test('5 findChainTipHash', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const hash = await client.findChainTipHash()
       expect(hash.length === 64).toBe(true)
     }
   })
 
   test('6 findHeaderForHeight', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const header0 = await client.findHeaderForHeight(0)
       expect(header0 !== undefined).toBe(true)
       if (header0) {
@@ -137,13 +147,13 @@ describe(`ChaintracksClientApi tests`, () => {
       const header = await client.findHeaderForHeight(firstTip.height)
       expect(header && header.height === firstTip.height).toBe(true)
 
-      const missing = await client.findHeaderForHeight(1000 + firstTip.height)
+      const missing = await client.findHeaderForHeight(99999999)
       expect(missing === undefined).toBe(true)
     }
   })
 
   test('7 addHeader', async () => {
-    for (const client of clients) {
+    for (const { client, chain } of clients) {
       const t = await client.findChainTipHeader()
       const h: BaseBlockHeader = {
         version: t.version,

package/src/services/chaintracker/chaintracks/__tests/LocalCdnServer.ts

@@ -42,11 +42,19 @@ export class LocalCdnServer {
     this.app.get('/download/:filename', (req, res) => {
       const filePath = path.join(this.folder, req.params.filename)
 
-      if (!fs.existsSync(filePath)) {
+      // Ensure filePath stays within the allowed folder (prevent directory traversal)
+      const resolvedFolder = path.resolve(this.folder)
+      const resolvedFilePath = path.resolve(filePath)
+      if (!resolvedFilePath.startsWith(resolvedFolder + path.sep)) {
+        // Prevent access to files outside the allowed directory
+        return res.status(403).json({ error: 'Access denied' })
+      }
+
+      if (!fs.existsSync(resolvedFilePath)) {
         return res.status(404).json({ error: 'File not found' })
       }
 
-      res.download(filePath, err => {
+      res.download(resolvedFilePath, err => {
         if (err) {
           res.status(500).json({ error: 'Error downloading file' })
         }

package/src/services/createDefaultWalletServicesOptions.ts

@@ -15,6 +15,9 @@ export function createDefaultWalletServicesOptions(
       ? 'mainnet_9596de07e92300c6287e4393594ae39c' // no plan
       : 'testnet_0e6cf72133b43ea2d7861da2a38684e3' // personal "starter" key
 
+  //const chaintracksUrl = `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`
+  const chaintracksUrl = `https://${chain}net-chaintracks.babbage.systems`
+
   const o: WalletServicesOptions = {
     chain,
     taalApiKey,
@@ -36,11 +39,8 @@ export function createDefaultWalletServicesOptions(
     fiatUpdateMsecs: 1000 * 60 * 60 * 24, // 24 hours
     disableMapiCallback: true, // Rely on WalletMonitor by default.
     exchangeratesapiKey: 'bd539d2ff492bcb5619d5f27726a766f',
-    chaintracksFiatExchangeRatesUrl: `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}/getFiatExchangeRates`,
-    chaintracks: new ChaintracksServiceClient(
-      chain,
-      `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`
-    ),
+    chaintracksFiatExchangeRatesUrl: `${chaintracksUrl}/getFiatExchangeRates`,
+    chaintracks: new ChaintracksServiceClient(chain, chaintracksUrl),
     arcUrl: arcDefaultUrl(chain),
     arcConfig: {
       apiKey: arcApiKey ?? undefined,

package/src/signer/methods/internalizeAction.ts

@@ -63,14 +63,14 @@ export async function internalizeAction(
   function setupWalletPaymentForOutput(o: InternalizeOutput, dargs: ValidInternalizeActionArgs) {
     const p = o.paymentRemittance
     const output = tx.outputs[o.outputIndex]
-    if (!p) throw new WERR_INVALID_PARAMETER('paymentRemitance', `valid for protocol ${o.protocol}`)
+    if (!p) throw new WERR_INVALID_PARAMETER('paymentRemittance', `valid for protocol ${o.protocol}`)
 
     const keyID = `${p.derivationPrefix} ${p.derivationSuffix}`
 
     const privKey = wallet.keyDeriver!.derivePrivateKey(brc29ProtocolID, keyID, p.senderIdentityKey)
     const expectedLockScript = new P2PKH().lock(privKey.toAddress())
     if (output.lockingScript.toHex() !== expectedLockScript.toHex())
-      throw new WERR_INVALID_PARAMETER('paymentRemitance', `locked by script conforming to BRC-29`)
+      throw new WERR_INVALID_PARAMETER('paymentRemittance', `locked by script conforming to BRC-29`)
   }
 
   function setupBasketInsertionForOutput(o: InternalizeOutput, dargs: ValidInternalizeActionArgs) {

package/src/storage/StorageProvider.ts

@@ -103,6 +103,7 @@ export abstract class StorageProvider extends StorageReaderWriter implements Wal
     this.feeModel = options.feeModel
     this.commissionPubKeyHex = options.commissionPubKeyHex
     this.commissionSatoshis = options.commissionSatoshis
+    this.maxRecursionDepth = 12
   }
 
   abstract reviewStatus(args: { agedLimit: Date; trx?: TrxToken }): Promise<{ log: string }>

package/src/storage/__test/getBeefForTransaction.test.ts

@@ -1,32 +1,9 @@
 import { Beef, ListActionsResult, ListOutputsResult } from '@bsv/sdk'
+import { WalletError } from '../../sdk/WalletError'
+import { StorageAdminStats, StorageProvider } from '../StorageProvider'
+import { Chain } from '../../sdk/types'
+import { Services } from '../../services/Services'
 import {
-  TrxToken,
-  PurgeParams,
-  PurgeResults,
-  ProvenOrRawTx,
-  AuthId,
-  ValidListActionsArgs,
-  ValidListOutputsArgs,
-  FindCertificatesArgs,
-  FindOutputBasketsArgs,
-  FindOutputsArgs,
-  FindOutputTagMapsArgs,
-  FindProvenTxReqsArgs,
-  FindProvenTxsArgs,
-  FindTxLabelMapsArgs,
-  FindCertificateFieldsArgs,
-  FindCommissionsArgs,
-  FindMonitorEventsArgs,
-  FindOutputTagsArgs,
-  FindSyncStatesArgs,
-  FindTransactionsArgs,
-  FindTxLabelsArgs,
-  FindUsersArgs,
-  FindForUserSincePagedArgs,
-  StorageGetBeefOptions
-} from '../../sdk'
-import {
-  StorageProvider,
   TableCertificate,
   TableCertificateField,
   TableCertificateX,
@@ -43,17 +20,41 @@ import {
   TableTransaction,
   TableTxLabel,
   TableTxLabelMap,
-  TableUser,
-  sdk,
-  Services,
-  EntityProvenTx,
-  StorageAdminStats
-} from '../../index.client'
+  TableUser
+} from '../schema/tables'
+import {
+  AuthId,
+  FindCertificateFieldsArgs,
+  FindCertificatesArgs,
+  FindCommissionsArgs,
+  FindForUserSincePagedArgs,
+  FindMonitorEventsArgs,
+  FindOutputBasketsArgs,
+  FindOutputsArgs,
+  FindOutputTagMapsArgs,
+  FindOutputTagsArgs,
+  FindProvenTxReqsArgs,
+  FindProvenTxsArgs,
+  FindSyncStatesArgs,
+  FindTransactionsArgs,
+  FindTxLabelMapsArgs,
+  FindTxLabelsArgs,
+  FindUsersArgs,
+  ProvenOrRawTx,
+  PurgeParams,
+  PurgeResults,
+  StorageGetBeefOptions,
+  TrxToken,
+} from '../../sdk/WalletStorage.interfaces'
+import {
+  ValidListActionsArgs,
+  ValidListOutputsArgs
+} from '../../sdk/validationHelpers'
 
 describe('getBeefForTransaction tests', () => {
   jest.setTimeout(99999999)
 
-  test('0_', async () => {
+  test('0 ProtoStorage.getBeefForTxid', async () => {
     const ps = new ProtoStorage('main')
     const beef = await ps.getBeefForTxid('794f836052ad73732a550c38bea3697a722c6a1e54bcbe63735ba79e0d23f623')
     expect(beef.bumps.length > 0)
@@ -68,7 +69,7 @@ class ProtoStorage extends StorageProvider {
   gbo: StorageGetBeefOptions
   whatsOnChainApiKey?: string
 
-  constructor(chain: sdk.Chain) {
+  constructor(chain: Chain) {
     const o = StorageProvider.createStorageBaseOptions(chain)
     super(o)
     const so = Services.createDefaultOptions(chain)
@@ -80,6 +81,7 @@ class ProtoStorage extends StorageProvider {
       ignoreServices: false,
       ignoreStorage: true
     }
+    this.maxRecursionDepth = 2
   }
 
   async getBeefForTxid(txid: string): Promise<Beef> {

package/src/utility/Format.ts

@@ -101,7 +101,7 @@ export abstract class Format {
 
   static toLogStringAdminStats(s: StorageAdminStats): string {
     let log = `StorageAdminStats: ${s.when} ${s.requestedBy}\n`
-    log += `  ${al('', 13)} ${ar('Day', 15)} ${ar('Month', 15)} ${ar('Total', 15)}\n`
+    log += `  ${al('', 13)} ${ar('Day', 18)} ${ar('Month', 18)} ${ar('Total', 18)}\n`
     log += dmt('users', s.usersDay, s.usersMonth, s.usersTotal)
     log += dmt('change sats', sa(s.satoshisDefaultDay), sa(s.satoshisDefaultMonth), sa(s.satoshisDefaultTotal))
     log += dmt('other sats', sa(s.satoshisOtherDay), sa(s.satoshisOtherMonth), sa(s.satoshisOtherTotal))
@@ -122,7 +122,7 @@ export abstract class Format {
     return log
 
     function dmt(l: string, d: number | string, m: number | string, t: number | string): string {
-      return `  ${al(l, 13)} ${ar(d, 15)} ${ar(m, 15)} ${ar(t, 15)}\n`
+      return `  ${al(l, 13)} ${ar(d, 18)} ${ar(m, 18)} ${ar(t, 18)}\n`
     }
   }
 }

package/src/utility/utilityHelpers.ts

@@ -151,9 +151,16 @@ export function verifyOne<T>(results: T[], errorDescrition?: string): T {
 
 /**
  * Returns an await'able Promise that resolves in the given number of msecs.
+ * @param msecs number of milliseconds to wait before resolving the promise.
+ * Must be greater than zero and less than 2 minutes (120,000 msecs)
  * @publicbody
  */
 export function wait(msecs: number): Promise<void> {
+  const MIN_WAIT = 0
+  const MAX_WAIT = 2 * 60 * 1000 // maximum allowed wait in ms (2 minutes)
+  if (typeof msecs !== 'number' || !Number.isFinite(msecs) || isNaN(msecs) || msecs < MIN_WAIT || msecs > MAX_WAIT) {
+    throw new WERR_INVALID_PARAMETER('msecs', `a number between ${MIN_WAIT} and ${MAX_WAIT} msecs, not ${msecs}.`)
+  }
   return new Promise(resolve => setTimeout(resolve, msecs))
 }