@bsv/wallet-toolbox 1.1.13 → 1.1.15

package/src/services/__tests/postTxs.test.ts

@@ -1,28 +0,0 @@
-import { Beef, Utils } from '@bsv/sdk'
-import { Services } from '../../index.client'
-
-describe('postTxs service tests', () => {
-  jest.setTimeout(99999999)
-
-  test('0', async () => {
-    const options = Services.createDefaultOptions('main')
-    const services = new Services(options)
-
-    const txid =
-      'b56ccf7dd0eb6bb0341cb92a2045d902106e4c2add0a4af057c85e9dfaaebddf'
-    const rawTx = await services.getRawTx(txid)
-    const rawTxHex = Utils.toHex(rawTx.rawTx!)
-    const beef = new Beef()
-    beef.mergeRawTx(rawTx.rawTx!)
-    const r = await services.postTxs(beef, [txid])
-    if (r[0].status === 'error') {
-      console.log(`
-${r[0].error?.message}
-${beef.toLogString()}
-${beef.toHex()}
-              `)
-    }
-    if (r[0].error?.message != 'broadcastMany error: error code: 502')
-      expect(r[0].status).toBe('success')
-  })
-})

package/src/services/providers/arcServices.ts

@@ -1,578 +0,0 @@
-import {
-  Transaction as BsvTransaction,
-  ARC,
-  ArcConfig,
-  Beef,
-  defaultHttpClient,
-  HttpClient,
-  HttpClientRequestOptions,
-  MerklePath
-} from '@bsv/sdk'
-import { asArray, randomBytesHex, sdk } from '../../index.client'
-
-import axios from 'axios'
-import { Readable } from 'stream'
-import { PostTxResultForTxid } from '../../sdk'
-
-const BEEF_V1 = 4022206465 // 0100BEEF in LE order
-const BEEF_V2 = 4022206466 // 0200BEEF in LE order
-
-// Documentation:
-// https://docs.taal.com/
-// https://docs.taal.com/core-products/transaction-processing/arc-endpoints
-// https://bitcoin-sv.github.io/arc/api.html
-
-export interface ArcServiceConfig {
-  name: string
-  url: string
-  arcConfig: ArcConfig
-}
-
-export function getTaalArcServiceConfig(
-  chain: sdk.Chain,
-  apiKey: string
-): ArcServiceConfig {
-  return {
-    name: 'TaalArc',
-    url:
-      chain === 'main'
-        ? 'https://api.taal.com/arc'
-        : 'https://arc-test.taal.com',
-    arcConfig: {
-      apiKey,
-      deploymentId: `WalletServices-${randomBytesHex(16)}`
-    }
-  }
-}
-
-export function makePostTxsToTaalARC(
-  config: ArcServiceConfig
-): sdk.PostTxsService {
-  return (beef: Beef, txids: string[], services: sdk.WalletServices) => {
-    return postTxsToTaalArcMiner(beef, txids, config, services)
-  }
-}
-
-export function makePostBeefToTaalARC(
-  config: ArcServiceConfig
-): sdk.PostBeefService {
-  return (beef: Beef, txids: string[], services: sdk.WalletServices) => {
-    return postBeefToTaalArcMiner(beef, txids, config, services)
-  }
-}
-
-export function makeGetMerklePathFromTaalARC(
-  config: ArcServiceConfig
-): sdk.GetMerklePathService {
-  return (txid: string, chain: sdk.Chain, services: sdk.WalletServices) => {
-    return getMerklePathFromTaalARC(txid, config, services)
-  }
-}
-
-class ArcServices {
-  readonly URL: string
-  readonly apiKey: string | undefined
-  readonly deploymentId: string
-  readonly callbackUrl: string | undefined
-  readonly callbackToken: string | undefined
-  readonly headers: Record<string, string> | undefined
-  private readonly httpClient: HttpClient
-
-  /**
-   * Constructs an instance of the ARC broadcaster.
-   *
-   * @param {string} URL - The URL endpoint for the ARC API.
-   * @param {ArcConfig} config - Configuration options for the ARC broadcaster.
-   */
-  constructor(URL: string, config: ArcConfig) {
-    this.URL = URL
-    const {
-      apiKey,
-      deploymentId,
-      httpClient,
-      callbackToken,
-      callbackUrl,
-      headers
-    } = config
-    this.apiKey = apiKey
-    this.httpClient = httpClient ?? defaultHttpClient()
-    this.deploymentId = deploymentId || `WalletServices-${randomBytesHex(16)}`
-    this.callbackToken = callbackToken
-    this.callbackUrl = callbackUrl
-    this.headers = headers
-  }
-
-  /**
-   * Unfortunately this seems to only work for recently submitted txids...
-   * @param txid
-   * @returns
-   */
-  async getTxStatus(txid: string): Promise<ArcMinerGetTxData> {
-    const requestOptions: HttpClientRequestOptions = {
-      method: 'GET',
-      headers: this.requestHeaders()
-    }
-
-    const response = await this.httpClient.request<ArcMinerGetTxData>(
-      `${this.URL}/v1/tx/${txid}`,
-      requestOptions
-    )
-
-    return response.data
-  }
-
-  requestHeaders() {
-    const headers: Record<string, string> = {
-      'Content-Type': 'application/json',
-      'XDeployment-ID': this.deploymentId
-    }
-    if (this.apiKey) {
-      headers.Authorization = `Bearer ${this.apiKey}`
-    }
-    if (this.callbackUrl) {
-      headers['X-CallbackUrl'] = this.callbackUrl
-    }
-    if (this.callbackToken) {
-      headers['X-CallbackToken'] = this.callbackToken
-    }
-    if (this.headers) {
-      for (const key in this.headers) {
-        headers[key] = this.headers[key]
-      }
-    }
-    return headers
-  }
-}
-
-export async function getMerklePathFromTaalARC(
-  txid: string,
-  config: ArcServiceConfig,
-  services: sdk.WalletServices
-): Promise<sdk.GetMerklePathResult> {
-  const r: sdk.GetMerklePathResult = { name: config.name }
-
-  try {
-    const arc = new ArcServices(config.url, config.arcConfig)
-
-    const rr = await arc.getTxStatus(txid)
-
-    if (rr.status === 200 && rr.merklePath) {
-      const mp = MerklePath.fromHex(rr.merklePath)
-      r.merklePath = mp
-      r.header = await services.hashToHeader(rr.blockHash)
-    }
-  } catch (eu: unknown) {
-    r.error = sdk.WalletError.fromUnknown(eu)
-  }
-  return r
-}
-
-/**
- *
- * @param txs All transactions must have source transactions. Will just source locking scripts and satoshis do?? toHexEF() is used.
- * @param config
- */
-export async function postTxsToTaalArcMiner(
-  beef: Beef,
-  txids: string[],
-  config: ArcServiceConfig,
-  services: sdk.WalletServices
-): Promise<sdk.PostTxsResult> {
-  const r: sdk.PostTxsResult = {
-    name: config.name,
-    status: 'error',
-    txidResults: []
-  }
-
-  try {
-    const arc = new ARC(config.url, config.arcConfig)
-
-    /**
-     * This service requires an array of EF serialized transactions:
-     * Pull the transactions matching txids array out of the Beef and fill in input sourceTransations,
-     * either from Beef or by external service lookup.
-     */
-    const txs: BsvTransaction[] = []
-    for (const txid of txids) {
-      const btx = beef.findTxid(txid)
-      if (btx) {
-        const tx = btx.tx!
-        for (const input of tx.inputs) {
-          if (!input.sourceTXID || input.sourceTXID === '0'.repeat(64)) continue // all zero txid is a coinbase input.
-          let itx = beef.findTxid(input.sourceTXID!)
-          if (!itx) {
-            const rawTx = await services.getRawTx(input.sourceTXID!)
-            if (!rawTx || !rawTx.rawTx)
-              throw new sdk.WERR_INVALID_PARAMETER(
-                'sourceTXID',
-                `contained in beef or found on chain. ${input.sourceTXID}`
-              )
-            beef.mergeRawTx(rawTx.rawTx!)
-            itx = beef.findTxid(input.sourceTXID!)
-          }
-          input.sourceTransaction = itx!.tx
-        }
-        txs.push(tx)
-      } else
-        throw new sdk.WERR_INVALID_PARAMETER(
-          'beef',
-          `merged with rawTxs matching txids. Missing ${txid}`
-        )
-    }
-
-    const rrs = (await arc.broadcastMany(txs)) as ArcMinerPostTxsData[] | string
-
-    if (typeof rrs === 'string') {
-      const rawTxs = txs.map(tx => {
-        return { rawTx: tx.toHexEF() }
-      })
-      console.log(`const rawTxs = '${JSON.stringify(rawTxs)}`)
-      throw new sdk.WERR_BAD_REQUEST(`broadcastMany error: ${rrs}`)
-    }
-
-    r.status = 'success'
-    for (const txid of txids) {
-      const txr: PostTxResultForTxid = { txid, status: 'success' }
-      const rr = rrs.find(r => r.txid === txid)
-      if (!rr) {
-        r.status = txr.status = 'error'
-      } else {
-        txr.data = rr
-        if (rr.status !== 200) r.status = txr.status = 'error'
-        else {
-          txr.blockHash = rr.blockHash
-          txr.blockHeight = rr.blockHeight
-          txr.merklePath = !rr.merklePath
-            ? undefined
-            : MerklePath.fromHex(rr.merklePath)
-        }
-      }
-      r.txidResults.push(txr)
-    }
-    r.data = rrs
-  } catch (eu: unknown) {
-    r.error = sdk.WalletError.fromUnknown(eu)
-  }
-  return r
-}
-
-export interface ArcMinerGetTxData {
-  status: number // 200
-  title: string // OK
-  blockHash: string
-  blockHeight: number
-  competingTxs: null | string[]
-  extraInfo: string
-  merklePath: string
-  timestamp: string // ISO Z
-  txid: string
-  txStatus: string // 'SEEN_IN_ORPHAN_MEMPOOL'
-}
-
-export interface ArcMinerPostTxsData {
-  status: number // 200
-  title: string // OK
-  blockHash: string
-  blockHeight: number
-  competingTxs: null | string[]
-  extraInfo: string
-  merklePath: string
-  timestamp: string // ISO Z
-  txid: string
-  txStatus: string // 'SEEN_IN_ORPHAN_MEMPOOL'
-}
-
-export interface ArcMinerPostBeefDataApi {
-  status: number // 200
-  title: string // "OK",
-  blockHash?: string // ""
-  blockHeight?: number // 0
-  competingTxs?: null
-  extraInfo: string // ""
-  merklePath?: string // ""
-  timestamp?: string // "2024-08-23T12:55:26.229904Z",
-  txid?: string // "272b5cdca9a0aa51846df9be29ee366ff85902691d38210e8c4be2fead3823a5",
-  txStatus?: string // "SEEN_ON_NETWORK",
-
-  type?: string // url
-  detail?: string
-  instance?: string
-}
-
-export async function postBeefToTaalArcMiner(
-  beef: Beef,
-  txids: string[],
-  config: ArcServiceConfig,
-  services: sdk.WalletServices
-): Promise<sdk.PostBeefResult> {
-  const r1 = await postBeefToArcMiner(beef, txids, config)
-  return r1
-
-  if (r1.status === 'success') return r1
-
-  const datas: object = { r1: r1.data }
-
-  const r2 = await services.postTxs(beef, txids)
-
-  const r3: sdk.PostBeefResult = {
-    name: config.name,
-    status: 'success',
-    data: {},
-    txidResults: []
-  }
-
-  for (const txid of txids) {
-    const rawTx = beef.findTxid(txid)!.rawTx!
-    const rt = await postBeefToArcMiner(rawTx, [txid], config)
-    if (rt.status === 'error') r3.status = 'error'
-    r3.data![txid] = rt.data
-    r3.txidResults.push(rt.txidResults[0])
-  }
-  datas['r3'] = r3.data
-  r3.data = datas
-  return r3
-}
-
-export async function postBeefToArcMiner(
-  beef: Beef | number[],
-  txids: string[],
-  config: ArcServiceConfig
-): Promise<sdk.PostBeefResult> {
-  const m = { ...config }
-
-  let url = ''
-
-  let r: sdk.PostBeefResult | undefined = undefined
-
-  // HACK to resolve ARC error when row has zero leaves.
-  // beef.addComputedLeaves()
-
-  let beefBinary: number[]
-
-  if (Array.isArray(beef)) beefBinary = beef
-  else {
-    // HACK to resolve ARC not handling V2 Beef after change Beef class to always serialize as V2 if default constructed:
-    beef.version = BEEF_V1
-    beefBinary = beef.toBinary()
-  }
-
-  try {
-    const length = beefBinary.length
-
-    const makeRequestHeaders = () => {
-      const headers: Record<string, string> = {
-        'Content-Type': 'application/octet-stream',
-        'Content-Length': length.toString(),
-        'XDeployment-ID':
-          m.arcConfig.deploymentId || `WalletServices-${randomBytesHex(16)}`
-      }
-
-      if (m.arcConfig.apiKey) {
-        headers['Authorization'] = `Bearer ${m.arcConfig.apiKey}`
-      }
-
-      return headers
-    }
-
-    const headers = makeRequestHeaders()
-
-    const stream = new Readable({
-      read() {
-        this.push(Buffer.from(beefBinary as number[]))
-        this.push(null)
-      }
-    })
-
-    url = `${config.url}/v1/tx`
-
-    const data = await axios.post(url, stream, {
-      headers,
-      maxBodyLength: Infinity,
-      validateStatus: () => true
-    })
-
-    if (!data || !data.data) throw new sdk.WERR_BAD_REQUEST('no response data')
-    if (
-      data.data === 'No Authorization' ||
-      data.status === 403 ||
-      data.statusText === 'Forbiden'
-    )
-      throw new sdk.WERR_BAD_REQUEST('No Authorization')
-    if (typeof data.data !== 'object')
-      throw new sdk.WERR_BAD_REQUEST('no response data object')
-
-    const dd = data.data as ArcMinerPostBeefDataApi
-
-    r = makePostBeefResult(dd, config, beefBinary, txids)
-  } catch (err: unknown) {
-    console.error(err)
-    const error = new sdk.WERR_INTERNAL(
-      `service: ${url}, error: ${JSON.stringify(sdk.WalletError.fromUnknown(err))}`
-    )
-    r = makeErrorResult(error, config, beefBinary, txids)
-  }
-
-  return r
-}
-
-export function makePostBeefResult(
-  dd: ArcMinerPostBeefDataApi,
-  miner: ArcServiceConfig,
-  beef: number[],
-  txids: string[]
-): sdk.PostBeefResult {
-  let r: sdk.PostBeefResult
-  switch (dd.status) {
-    case 200: // Success
-      r = makeSuccessResult(dd, miner, beef, txids)
-      break
-    case 400: // Bad Request
-      r = makeErrorResult(new sdk.WERR_BAD_REQUEST(), miner, beef, txids, dd)
-      break
-    case 401: // Security Failed
-      r = makeErrorResult(
-        new sdk.WERR_BAD_REQUEST(`Security Failed (401)`),
-        miner,
-        beef,
-        txids,
-        dd
-      )
-      break
-    case 409: // Generic Error
-    case 422: // RFC 7807 Error
-    case 460: // Not Extended Format
-    case 467: // Mined Ancestor Missing
-    case 468: // Invalid BUMPs
-      r = makeErrorResult(
-        new sdk.WERR_BAD_REQUEST(`status ${dd.status}, title ${dd.title}`),
-        miner,
-        beef,
-        txids,
-        dd
-      )
-      break
-    case 461: // Malformed Transaction
-    case 463: // Malformed Transaction
-    case 464: // Invalid Outputs
-      r = makeErrorResult(
-        new sdk.WERR_BAD_REQUEST(`status ${dd.status}, title ${dd.title}`),
-        miner,
-        beef,
-        txids,
-        dd
-      )
-      break
-    case 462: // Invalid Inputs
-      if (dd.txid)
-        r = makeErrorResult(
-          new sdk.WERR_BAD_REQUEST(`status ${dd.status}, title ${dd.title}`),
-          miner,
-          beef,
-          txids,
-          dd
-        )
-      else
-        r = makeErrorResult(
-          new sdk.WERR_BAD_REQUEST(`status ${dd.status}, title ${dd.title}`),
-          miner,
-          beef,
-          txids,
-          dd
-        )
-      break
-    case 465: // Fee Too Low
-    case 473: // Cumulative Fee Validation Failed
-      r = makeErrorResult(
-        new sdk.WERR_BAD_REQUEST(`status ${dd.status}, title ${dd.title}`),
-        miner,
-        beef,
-        txids,
-        dd
-      )
-      break
-    case 469: // Invalid Merkle Root
-      r = makeErrorResult(
-        new sdk.WERR_BAD_REQUEST(`status ${dd.status}, title ${dd.title}`),
-        miner,
-        beef,
-        txids,
-        dd
-      )
-      break
-    default:
-      r = makeErrorResult(
-        new sdk.WERR_BAD_REQUEST(`status ${dd.status}, title ${dd.title}`),
-        miner,
-        beef,
-        txids,
-        dd
-      )
-      break
-  }
-  return r
-}
-
-function makeSuccessResult(
-  dd: ArcMinerPostBeefDataApi,
-  miner: ArcServiceConfig,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  beef: number[],
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  txids: string[]
-): sdk.PostBeefResult {
-  const r: sdk.PostBeefResult = {
-    status: 'success',
-    name: miner.name,
-    data: dd,
-    txidResults: []
-  }
-  for (let i = 0; i < txids.length; i++) {
-    const rt: sdk.PostTxResultForTxid = {
-      txid: txids[i],
-      status: 'success'
-    }
-    if (dd.txid === txids[i]) {
-      rt.alreadyKnown =
-        !!dd.txStatus && ['SEEN_ON_NETWORK', 'MINED'].indexOf(dd.txStatus) >= 0
-      rt.txid = dd.txid
-      rt.blockHash = dd.blockHash
-      rt.blockHeight = dd.blockHeight
-      rt.merklePath = MerklePath.fromBinary(asArray(dd.merklePath!))
-    }
-    r.txidResults.push(rt)
-  }
-  return r
-}
-
-export function makeErrorResult(
-  error: sdk.WalletError,
-  miner: ArcServiceConfig,
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  beef: number[],
-  txids: string[],
-  dd?: ArcMinerPostBeefDataApi
-): sdk.PostBeefResult {
-  const r: sdk.PostBeefResult = {
-    status: 'error',
-    name: miner.name,
-    error,
-    data: dd,
-    txidResults: []
-  }
-  for (let i = 0; i < txids.length; i++) {
-    const rt: sdk.PostTxResultForTxid = {
-      txid: txids[i],
-      status: 'error'
-    }
-    if (dd?.txid === txids[i]) {
-      rt.alreadyKnown =
-        !!dd.txStatus && ['SEEN_ON_NETWORK', 'MINED'].indexOf(dd.txStatus) >= 0
-      rt.txid = dd.txid
-      rt.blockHash = dd.blockHash
-      rt.blockHeight = dd.blockHeight
-      rt.merklePath = MerklePath.fromBinary(asArray(dd.merklePath!))
-    }
-    r.txidResults.push(rt)
-  }
-  return r
-}