@bsv/wallet-toolbox 1.7.14 → 1.7.16

package/mobile/node_modules/@bsv/sdk/src/transaction/chaintrackers/WhatsOnChain.ts

@@ -0,0 +1,102 @@
+
+import ChainTracker from '../ChainTracker.js'
+import { HttpClient } from '../http/HttpClient.js'
+import { defaultHttpClient } from '../http/DefaultHttpClient.js'
+
+/** Configuration options for the WhatsOnChain ChainTracker. */
+export interface WhatsOnChainConfig {
+  /** Authentication token for the WhatsOnChain API */
+  apiKey?: string
+  /** The HTTP client used to make requests to the API. */
+  httpClient?: HttpClient
+}
+
+interface WhatsOnChainBlockHeader {
+  merkleroot: string
+}
+
+/**
+ * Represents a chain tracker based on What's On Chain .
+ */
+export default class WhatsOnChain implements ChainTracker {
+  readonly network: string
+  readonly apiKey: string
+  protected readonly URL: string
+  protected readonly httpClient: HttpClient
+
+  /**
+   * Constructs an instance of the WhatsOnChain ChainTracker.
+   *
+   * @param {'main' | 'test' | 'stn'} network - The BSV network to use when calling the WhatsOnChain API.
+   * @param {WhatsOnChainConfig} config - Configuration options for the WhatsOnChain ChainTracker.
+   */
+  constructor(
+    network: 'main' | 'test' | 'stn' = 'main',
+    config: WhatsOnChainConfig = {}
+  ) {
+    const { apiKey, httpClient } = config
+    this.network = network
+    this.URL = `https://api.whatsonchain.com/v1/bsv/${network}`
+    this.httpClient = httpClient ?? defaultHttpClient()
+    this.apiKey = apiKey ?? ''
+  }
+
+  async isValidRootForHeight(root: string, height: number): Promise<boolean> {
+    const requestOptions = {
+      method: 'GET',
+      headers: this.getHttpHeaders()
+    }
+
+    const response = await this.httpClient.request<WhatsOnChainBlockHeader>(
+      `${this.URL}/block/${height}/header`,
+      requestOptions
+    )
+    if (response.ok) {
+      const { merkleroot } = response.data
+      return merkleroot === root
+    } else if (response.status === 404) {
+      return false
+    } else {
+      throw new Error(
+        `Failed to verify merkleroot for height ${height} because of an error: ${JSON.stringify(response.data)} `
+      )
+    }
+  }
+
+  async currentHeight(): Promise<number> {
+    try {
+      const requestOptions = {
+        method: 'GET',
+        headers: this.getHttpHeaders()
+      }
+
+      const response = await this.httpClient.request<{ height: number }>(
+        `${this.URL}/block/headers`,
+        requestOptions
+      )
+      if (response.ok) {
+        return response.data[0].height
+      } else {
+        throw new Error(
+          `Failed to get current height because of an error: ${JSON.stringify(response.data)} `
+        )
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to get current height because of an error: ${error instanceof Error ? error.message : String(error)}`
+      )
+    }
+  }
+
+  protected getHttpHeaders(): Record<string, string> {
+    const headers: Record<string, string> = {
+      Accept: 'application/json'
+    }
+
+    if (typeof this.apiKey === 'string' && this.apiKey.trim() !== '') {
+      headers.Authorization = this.apiKey
+    }
+
+    return headers
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/transaction/chaintrackers/__tests/WhatsOnChainChainTracker.test.ts

@@ -0,0 +1,198 @@
+import { NodejsHttpClient } from '../../../transaction/http/NodejsHttpClient'
+import WhatsOnChain from '../../../transaction/chaintrackers/WhatsOnChain'
+import { FetchHttpClient } from '../../../transaction/http/FetchHttpClient'
+
+describe('WhatsOnChain ChainTracker', () => {
+  const network = 'main'
+  const height = 123456
+  const merkleroot = 'mocked_merkleroot'
+
+  const successResponse = {
+    status: 200,
+    data: {
+      merkleroot
+    }
+  }
+
+  it('should verify merkleroot successfully using window.fetch', async () => {
+    // Mocking window.fetch
+    const mockFetch = mockedFetch(successResponse)
+    global.window = { fetch: mockFetch } as any
+
+    const chainTracker = new WhatsOnChain(network)
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    )
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual(true)
+  })
+
+  it('should verify merkleroot successfully using Node.js https', async () => {
+    // Mocking Node.js https module
+    mockedHttps(successResponse)
+    if (typeof global.window !== 'undefined') global.window = {} as any
+
+    const chainTracker = new WhatsOnChain(network)
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    )
+
+    expect(response).toEqual(true)
+  })
+
+  it('should verify merkleroot successfully using provided window.fetch', async () => {
+    const mockFetch = mockedFetch(successResponse)
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    )
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual(true)
+  })
+
+  it('should verify merkleroot successfully using provided Node.js https', async () => {
+    const mockHttps = mockedHttps(successResponse)
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new NodejsHttpClient(mockHttps)
+    })
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    )
+
+    expect(response).toEqual(true)
+  })
+
+  it('should respond with invalid root for height when block for height is not found', async () => {
+    const mockFetch = mockedFetch({
+      status: 404,
+      data: 'not found'
+    })
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+    const response = await chainTracker.isValidRootForHeight(
+      merkleroot,
+      height
+    )
+
+    expect(response).toEqual(false)
+  })
+
+  it('should handle network errors', async () => {
+    const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await expect(
+      chainTracker.isValidRootForHeight(merkleroot, height)
+    ).rejects.toThrow('Network error')
+  })
+
+  it('should throw error when received error response', async () => {
+    const mockFetch = mockedFetch({
+      status: 401,
+      data: { error: 'Unauthorized' }
+    })
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await expect(
+      chainTracker.isValidRootForHeight(merkleroot, height)
+    ).rejects.toThrow(
+      /Failed to verify merkleroot for height \d+ because of an error: .*/
+    )
+  })
+
+  it('should return the current height', async () => {
+    const mockFetch = mockedFetch({
+      status: 200,
+      data: [
+        {
+          hash: '00000000000000000af9958a79fd4dbac1b04a553cc00c80e108718561ccb5a5',
+          confirmations: 1,
+          size: 29605652,
+          height: 875904,
+          version: 704643072,
+          versionHex: '2a000000',
+          merkleroot:
+            '8af5a2d4325ec30e30103b1f365c303d4b49d11e42d26b0d7e9b6866724392e9',
+          time: 1734667612,
+          mediantime: 1734663717,
+          nonce: 157007350,
+          bits: '180f2b74',
+          difficulty: 72479484799.59058,
+          chainwork:
+            '00000000000000000000000000000000000000000160c2f41c8793b90f4500dd',
+          previousblockhash:
+            '00000000000000000128f312a7c62ef5f9a91a3f845a4464d10cfbaaecd233a0',
+          nextblockhash: '',
+          nTx: 0,
+          num_tx: 167567
+        }
+      ]
+    })
+
+    const chainTracker = new WhatsOnChain(network, {
+      httpClient: new FetchHttpClient(mockFetch)
+    })
+
+    await expect(await chainTracker.currentHeight()).toBe(875904)
+  })
+
+  function mockedFetch (response: { status: number, data: any }): jest.Mock<any, any, any> {
+    return jest.fn().mockResolvedValue({
+      ok: response.status === 200,
+      status: response.status,
+      statusText: response.status === 200 ? 'OK' : 'Bad request',
+      headers: {
+        get (key: string) {
+          if (key === 'Content-Type') {
+            return 'application/json'
+          }
+        }
+      },
+      json: async () => response.data
+    })
+  }
+
+  function mockedHttps (response: { status: number, data: any }): { request: (url: string, options: any, callback: (res: any) => void) => any } {
+    const https = {
+      request: (url, options, callback) => {
+        // eslint-disable-next-line
+        callback({
+          statusCode: response.status,
+          statusMessage: response.status === 200 ? 'OK' : 'Bad request',
+          headers: {
+            'content-type': 'application/json'
+          },
+          on: (event, handler) => {
+            if (event === 'data') handler(JSON.stringify(response.data))
+            if (event === 'end') handler()
+          }
+        })
+        return {
+          on: jest.fn(),
+          write: jest.fn(),
+          end: jest.fn()
+        }
+      }
+    }
+    jest.mock('https', () => https)
+    return https
+  }
+})

package/mobile/node_modules/@bsv/sdk/src/transaction/chaintrackers/index.ts

@@ -0,0 +1,4 @@
+export { default as WhatsOnChain } from './WhatsOnChain.js'
+export type { WhatsOnChainConfig } from './WhatsOnChain.js'
+export { BlockHeadersService } from './BlockHeadersService.js'
+export { defaultChainTracker } from './DefaultChainTracker.js'

package/mobile/node_modules/@bsv/sdk/src/transaction/fee-models/LivePolicy.ts

@@ -0,0 +1,97 @@
+import SatoshisPerKilobyte from './SatoshisPerKilobyte.js'
+import Transaction from '../Transaction.js'
+
+/**
+ * Represents a live fee policy that fetches current rates from ARC GorillaPool.
+ * Extends SatoshisPerKilobyte to reuse transaction size calculation logic.
+ */
+export default class LivePolicy extends SatoshisPerKilobyte {
+  private static readonly ARC_POLICY_URL = 'https://arc.gorillapool.io/v1/policy'
+  private static instance: LivePolicy | null = null
+  private cachedRate: number | null = null
+  private cacheTimestamp: number = 0
+  private readonly cacheValidityMs: number
+
+  /**
+   * Constructs an instance of the live policy fee model.
+   *
+   * @param {number} cacheValidityMs - How long to cache the fee rate in milliseconds (default: 5 minutes)
+   */
+  constructor(cacheValidityMs: number = 5 * 60 * 1000) {
+    super(100) // Initialize with dummy value, will be overridden by fetchFeeRate
+    this.cacheValidityMs = cacheValidityMs
+  }
+
+  /**
+   * Gets the singleton instance of LivePolicy to ensure cache sharing across the application.
+   *
+   * @param {number} cacheValidityMs - How long to cache the fee rate in milliseconds (default: 5 minutes)
+   * @returns The singleton LivePolicy instance
+   */
+  static getInstance(cacheValidityMs: number = 5 * 60 * 1000): LivePolicy {
+    if (!LivePolicy.instance) {
+      LivePolicy.instance = new LivePolicy(cacheValidityMs)
+    }
+    return LivePolicy.instance
+  }
+
+  /**
+   * Fetches the current fee rate from ARC GorillaPool API.
+   * 
+   * @returns The current satoshis per kilobyte rate
+   */
+  private async fetchFeeRate(): Promise<number> {
+    const now = Date.now()
+    
+    // Return cached rate if still valid
+    if (this.cachedRate !== null && (now - this.cacheTimestamp) < this.cacheValidityMs) {
+      return this.cachedRate
+    }
+
+    try {
+      const response = await fetch(LivePolicy.ARC_POLICY_URL)
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
+      
+      const response_data = await response.json()
+      
+      if (!response_data.policy?.miningFee || typeof response_data.policy.miningFee.satoshis !== 'number' || typeof response_data.policy.miningFee.bytes !== 'number') {
+        throw new Error('Invalid policy response format')
+      }
+      
+      // Convert to satoshis per kilobyte
+      const rate = (response_data.policy.miningFee.satoshis / response_data.policy.miningFee.bytes) * 1000
+      
+      // Cache the result
+      this.cachedRate = rate
+      this.cacheTimestamp = now
+      
+      return rate
+    } catch (error) {
+      // If we have a cached rate, use it as fallback
+      if (this.cachedRate !== null) {
+        console.warn('Failed to fetch live fee rate, using cached value:', error)
+        return this.cachedRate
+      }
+      
+      // Otherwise, use a reasonable default (100 sat/kb)
+      console.warn('Failed to fetch live fee rate, using default 100 sat/kb:', error)
+      return 100
+    }
+  }
+
+  /**
+   * Computes the fee for a given transaction using the current live rate.
+   * Overrides the parent method to use dynamic rate fetching.
+   *
+   * @param tx The transaction for which a fee is to be computed.
+   * @returns The fee in satoshis for the transaction.
+   */
+  async computeFee(tx: Transaction): Promise<number> {
+    const rate = await this.fetchFeeRate()
+    // Update the value property so parent's computeFee uses the live rate
+    this.value = rate
+    return super.computeFee(tx)
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/transaction/fee-models/SatoshisPerKilobyte.ts

@@ -0,0 +1,75 @@
+import FeeModel from '../FeeModel.js'
+import Transaction from '../Transaction.js'
+
+/**
+ * Represents the "satoshis per kilobyte" transaction fee model.
+ */
+export default class SatoshisPerKilobyte implements FeeModel {
+  /**
+   * @property
+   * Denotes the number of satoshis paid per kilobyte of transaction size.
+   */
+  value: number
+
+  /**
+   * Constructs an instance of the sat/kb fee model.
+   *
+   * @param {number} value - The number of satoshis per kilobyte to charge as a fee.
+   */
+  constructor(value: number) {
+    this.value = value
+  }
+
+  /**
+   * Computes the fee for a given transaction.
+   *
+   * @param tx The transaction for which a fee is to be computed.
+   * @returns The fee in satoshis for the transaction, as a BigNumber.
+   */
+  async computeFee(tx: Transaction): Promise<number> {
+    const getVarIntSize = (i: number): number => {
+      if (i > 2 ** 32) {
+        return 9
+      } else if (i > 2 ** 16) {
+        return 5
+      } else if (i > 253) {
+        return 3
+      } else {
+        return 1
+      }
+    }
+    // Compute the (potentially estimated) size of the transaction
+    let size = 4 // version
+    size += getVarIntSize(tx.inputs.length) // number of inputs
+    for (let i = 0; i < tx.inputs.length; i++) {
+      const input = tx.inputs[i]
+      size += 40 // txid, output index, sequence number
+      let scriptLength: number
+      if (typeof input.unlockingScript === 'object') {
+        scriptLength = input.unlockingScript.toBinary().length
+      } else if (typeof input.unlockingScriptTemplate === 'object') {
+        scriptLength = await input.unlockingScriptTemplate.estimateLength(
+          tx,
+          i
+        )
+      } else {
+        throw new Error(
+          'All inputs must have an unlocking script or an unlocking script template for sat/kb fee computation.'
+        )
+      }
+      size += getVarIntSize(scriptLength) // unlocking script length
+      size += scriptLength // unlocking script
+    }
+    size += getVarIntSize(tx.outputs.length) // number of outputs
+    for (const out of tx.outputs) {
+      size += 8 // satoshis
+      const length = out.lockingScript.toBinary().length
+      size += getVarIntSize(length) // script length
+      size += length // script
+    }
+    size += 4 // lock time
+    // We'll use Math.ceil to ensure the miners get the extra satoshi.
+    const fee = Math.ceil((size / 1000) * this.value)
+    return fee
+  }
+}

package/mobile/node_modules/@bsv/sdk/src/transaction/fee-models/__tests/LivePolicy.test.ts

@@ -0,0 +1,148 @@
+import LivePolicy from '../LivePolicy.js'
+
+describe('LivePolicy', () => {
+  let consoleSpy: jest.SpyInstance
+
+  const createMockTransaction = () => ({
+    inputs: [],
+    outputs: []
+  } as any)
+
+  const createSuccessfulFetchMock = (satoshis: number, bytes: number = 1000) => 
+    jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        policy: {
+          miningFee: { satoshis, bytes }
+        }
+      })
+    })
+
+  const createErrorFetchMock = (status = 500, statusText = 'Internal Server Error') =>
+    jest.fn().mockResolvedValue({
+      ok: false,
+      status,
+      statusText
+    })
+
+  const createInvalidResponseMock = () =>
+    jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ invalid: 'response' })
+    })
+
+  const createNetworkErrorMock = () =>
+    jest.fn().mockRejectedValue(new Error('Network error'))
+
+  const expectDefaultFallback = (consoleSpy: jest.SpyInstance) => {
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Failed to fetch live fee rate, using default 100 sat/kb:',
+      expect.any(Error)
+    )
+  }
+
+  const expectCachedFallback = (consoleSpy: jest.SpyInstance) => {
+    expect(consoleSpy).toHaveBeenCalledWith(
+      'Failed to fetch live fee rate, using cached value:',
+      expect.any(Error)
+    )
+  }
+
+  beforeEach(() => {
+    ;(LivePolicy as any).instance = null
+    jest.clearAllMocks()
+    consoleSpy = jest.spyOn(console, 'warn').mockImplementation()
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+  })
+
+  it('should return the same instance when getInstance is called multiple times', () => {
+    const instance1 = LivePolicy.getInstance()
+    const instance2 = LivePolicy.getInstance()
+    
+    expect(instance1).toBe(instance2)
+    expect(instance1).toBeInstanceOf(LivePolicy)
+  })
+
+  it('should share cache between singleton instances', async () => {
+    const instance1 = LivePolicy.getInstance()
+    const instance2 = LivePolicy.getInstance()
+    
+    global.fetch = createSuccessfulFetchMock(5)
+    const mockTx = createMockTransaction()
+
+    const fee1 = await instance1.computeFee(mockTx)
+    const fee2 = await instance2.computeFee(mockTx)
+    
+    expect(fee1).toBe(fee2)
+    expect(fee1).toBe(1) // 5 sat/kb rate, minimum tx size gets 1 sat
+    expect(global.fetch).toHaveBeenCalledTimes(1)
+  })
+
+  it('should allow different cache validity when creating singleton', () => {
+    const instance1 = LivePolicy.getInstance(10000)
+    const instance2 = LivePolicy.getInstance(20000)
+    
+    expect(instance1).toBe(instance2)
+    expect((instance1 as any).cacheValidityMs).toBe(10000)
+  })
+
+  it('should create instance with custom cache validity', () => {
+    const instance = new LivePolicy(30000)
+    expect((instance as any).cacheValidityMs).toBe(30000)
+  })
+
+  it('should handle HTTP error responses', async () => {
+    const instance = LivePolicy.getInstance()
+    global.fetch = createErrorFetchMock()
+    const mockTx = createMockTransaction()
+
+    const fee = await instance.computeFee(mockTx)
+    
+    expect(fee).toBe(1)
+    expectDefaultFallback(consoleSpy)
+  })
+
+  it('should handle invalid API response format', async () => {
+    const instance = LivePolicy.getInstance()
+    global.fetch = createInvalidResponseMock()
+    const mockTx = createMockTransaction()
+
+    const fee = await instance.computeFee(mockTx)
+    
+    expect(fee).toBe(1)
+    expectDefaultFallback(consoleSpy)
+  })
+
+  it('should use cached value when API fails after successful fetch', async () => {
+    const instance = LivePolicy.getInstance()
+    const mockTx = createMockTransaction()
+    
+    // First call - successful fetch
+    global.fetch = createSuccessfulFetchMock(10)
+    const fee1 = await instance.computeFee(mockTx)
+    expect(fee1).toBe(1)
+
+    // Expire cache and simulate API failure
+    ;(instance as any).cacheTimestamp = Date.now() - (6 * 60 * 1000)
+    global.fetch = createNetworkErrorMock()
+    
+    const fee2 = await instance.computeFee(mockTx)
+    
+    expect(fee2).toBe(1)
+    expectCachedFallback(consoleSpy)
+  })
+
+  it('should handle network errors with no cached value', async () => {
+    const instance = LivePolicy.getInstance()
+    global.fetch = createNetworkErrorMock()
+    const mockTx = createMockTransaction()
+
+    const fee = await instance.computeFee(mockTx)
+    
+    expect(fee).toBe(1)
+    expectDefaultFallback(consoleSpy)
+  })
+})

package/mobile/node_modules/@bsv/sdk/src/transaction/fee-models/index.ts

@@ -0,0 +1,2 @@
+export { default as SatoshisPerKilobyte } from './SatoshisPerKilobyte.js'
+export { default as LivePolicy } from './LivePolicy.js'