@bsv/wallet-toolbox 1.7.16 → 1.7.17

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

@@ -1,102 +0,0 @@
-
-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

@@ -1,198 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

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