@bsv/sdk 1.0.1 → 1.0.2

package/src/transaction/broadcasters/__tests/ARC.test.ts

@@ -0,0 +1,115 @@
+import ARC from '../../../../dist/cjs/src/transaction/broadcasters/ARC.js'
+import Transaction from '../../../../dist/cjs/src/transaction/Transaction.js'
+
+// Mock Transaction
+jest.mock('../../Transaction', () => {
+  return {
+    default: jest.fn().mockImplementation(() => {
+      return {
+        toHex: () => 'mocked_transaction_hex'
+      }
+    })
+  }
+})
+
+describe('ARC Broadcaster', () => {
+  const URL = 'https://example.com'
+  const apiKey = 'test_api_key'
+  let broadcaster: ARC
+  let transaction: Transaction
+
+  beforeEach(() => {
+    broadcaster = new ARC(URL, apiKey)
+    transaction = new Transaction()
+  })
+
+  it('should broadcast successfully using window.fetch', async () => {
+    // Mocking window.fetch
+    const mockFetch = jest.fn().mockResolvedValue({
+      ok: true,
+      json: async () => await Promise.resolve({
+        txid: 'mocked_txid',
+        txStatus: 'success',
+        extraInfo: 'received'
+      })
+    })
+    global.window = { fetch: mockFetch } as any
+
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'success received'
+    })
+  })
+
+  it('should broadcast successfully using Node.js https', async () => {
+    // Mocking Node.js https module
+    jest.mock('https', () => ({
+      request: (url, options, callback) => {
+        // eslint-disable-next-line
+        callback({
+          statusCode: 200,
+          on: (event, handler) => {
+            if (event === 'data') handler(JSON.stringify({
+              txid: 'mocked_txid',
+              txStatus: 'success',
+              extraInfo: 'received'
+            }))
+            if (event === 'end') handler()
+          }
+        })
+        return {
+          on: jest.fn(),
+          write: jest.fn(),
+          end: jest.fn()
+        }
+      }
+    }))
+
+    delete global.window
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(response).toEqual({
+      status: 'success',
+      txid: 'mocked_txid',
+      message: 'success received'
+    })
+  })
+
+  it('should handle network errors', async () => {
+    const mockFetch = jest.fn().mockRejectedValue(new Error('Network error'))
+    global.window = { fetch: mockFetch } as any
+
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'error',
+      code: '500',
+      description: 'Network error'
+    })
+  })
+
+  it('should handle non-200 responses', async () => {
+    const mockFetch = jest.fn().mockResolvedValue({
+      ok: false,
+      json: async () => await Promise.resolve({
+        status: '400',
+        detail: 'Bad request'
+      })
+    })
+    global.window = { fetch: mockFetch } as any
+
+    const response = await broadcaster.broadcast(transaction)
+
+    expect(mockFetch).toHaveBeenCalled()
+    expect(response).toEqual({
+      status: 'error',
+      code: '400',
+      description: 'Bad request'
+    })
+  })
+})

package/src/transaction/broadcasters/index.ts

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

package/src/transaction/fee-models/SatoshisPerKilobyte.ts

@@ -0,0 +1,71 @@
+import FeeModel from '../FeeModel.js'
+import Transaction from '../Transaction.js'
+import BigNumber from '../../primitives/BigNumber.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/src/transaction/fee-models/index.ts

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

package/src/transaction/index.ts

@@ -0,0 +1,6 @@
+export { default as Transaction } from './Transaction.js'
+export { default as MerklePath } from './MerklePath.js'
+export type { default as TransactionInput } from './TransactionInput.js'
+export type { default as TransactionOutput } from './TransactionOutput.js'
+export type * as Broadcaster from './Broadcaster.js'
+export type { default as ChainTracker } from './ChainTracker.js'