bring sdk WhatsOnChain in as SdkWhatsOnChain to permit releasing

Author: tonesnotes

docs/client.md

@@ -1,4 +1,5 @@
 import {
+  ArcConfig,
   Beef,
   Transaction as BsvTransaction,
   ChainTracker,
@@ -90,15 +91,6 @@ export interface WalletServices {
    */
   getMerklePath(txid: string, useNext?: boolean): Promise<GetMerklePathResult>
 
-  /**
-   *
-   * @param beef
-   * @param txids
-   * @param chain
-   * @returns
-   */
-  postTxs(beef: Beef, txids: string[]): Promise<PostTxsResult[]>
-
   /**
    *
    * @param beef
@@ -168,6 +160,8 @@ export interface WalletServicesOptions {
   exchangeratesapiKey?: string
   chaintracksFiatExchangeRatesUrl?: string
   chaintracks?: ChaintracksServiceClient
+  arcUrl: string
+  arcConfig: ArcConfig
 }
 
 /**
@@ -401,8 +395,7 @@ export type PostTxsService = (
 
 export type PostBeefService = (
   beef: Beef,
-  txids: string[],
-  services: WalletServices
+  txids: string[]
 ) => Promise<PostBeefResult>
 
 export type UpdateFiatExchangeRateService = (

docs/services.md

@@ -13,19 +13,14 @@ import {
   wait
 } from '../index.client'
 import { ServiceCollection } from './ServiceCollection'
-
 import { createDefaultWalletServicesOptions } from './createDefaultWalletServicesOptions'
 import { ChaintracksChainTracker } from './chaintracker'
-import {
-  getTaalArcServiceConfig,
-  makePostBeefToTaalARC,
-  makePostTxsToTaalARC
-} from './providers/arcServices'
 import { WhatsOnChain } from './providers/WhatsOnChain'
 import {
   updateChaintracksFiatExchangeRates,
   updateExchangeratesapi
 } from './providers/echangeRates'
+import ARC from './providers/ARC'
 
 export class Services implements sdk.WalletServices {
   static createDefaultOptions(chain: sdk.Chain): sdk.WalletServicesOptions {
@@ -34,10 +29,10 @@ export class Services implements sdk.WalletServices {
 
   options: sdk.WalletServicesOptions
   whatsonchain: WhatsOnChain
+  arc: ARC
 
   getMerklePathServices: ServiceCollection<sdk.GetMerklePathService>
   getRawTxServices: ServiceCollection<sdk.GetRawTxService>
-  postTxsServices: ServiceCollection<sdk.PostTxsService>
   postBeefServices: ServiceCollection<sdk.PostBeefService>
   getUtxoStatusServices: ServiceCollection<sdk.GetUtxoStatusService>
   updateFiatExchangeRateServices: ServiceCollection<sdk.UpdateFiatExchangeRateService>
@@ -57,6 +52,8 @@ export class Services implements sdk.WalletServices {
       apiKey: this.options.taalApiKey
     })
 
+    this.arc = new ARC(this.options.arcUrl, this.options.arcConfig)
+
     this.getMerklePathServices =
       new ServiceCollection<sdk.GetMerklePathService>().add({
         name: 'WhatsOnChain',
@@ -68,18 +65,9 @@ export class Services implements sdk.WalletServices {
       service: this.whatsonchain.getRawTxResult.bind(this.whatsonchain)
     })
 
-    this.postTxsServices = new ServiceCollection<sdk.PostTxsService>().add({
-      name: 'TaalArcTxs',
-      service: makePostTxsToTaalARC(
-        getTaalArcServiceConfig(this.chain, this.options.taalApiKey!)
-      )
-    })
-
     this.postBeefServices = new ServiceCollection<sdk.PostBeefService>().add({
       name: 'TaalArcBeef',
-      service: makePostBeefToTaalARC(
-        getTaalArcServiceConfig(this.chain, this.options.taalApiKey!)
-      )
+      service: this.arc.postBeef.bind(this.arc)
     })
 
     this.getUtxoStatusServices =
@@ -138,9 +126,6 @@ export class Services implements sdk.WalletServices {
   get getRawTxsCount() {
     return this.getRawTxServices.count
   }
-  get postTxsServicesCount() {
-    return this.postTxsServices.count
-  }
   get postBeefServicesCount() {
     return this.postBeefServices.count
   }
@@ -179,25 +164,6 @@ export class Services implements sdk.WalletServices {
     return r0
   }
 
-  /**
-   * The beef must contain at least each rawTx for each txid.
-   * Some services may require input transactions as well.
-   * These will be fetched if missing, greatly extending the service response time.
-   * @param beef
-   * @param txids
-   * @returns
-   */
-  async postTxs(beef: Beef, txids: string[]): Promise<sdk.PostTxsResult[]> {
-    const rs = await Promise.all(
-      this.postTxsServices.allServices.map(async service => {
-        const r = await service(beef, txids, this)
-        return r
-      })
-    )
-
-    return rs
-  }
-
   /**
    *
    * @param beef
@@ -207,15 +173,10 @@ export class Services implements sdk.WalletServices {
   async postBeef(beef: Beef, txids: string[]): Promise<sdk.PostBeefResult[]> {
     let rs = await Promise.all(
       this.postBeefServices.allServices.map(async service => {
-        const r = await service(beef, txids, this)
+        const r = await service(beef, txids)
         return r
       })
     )
-
-    if (rs.every(r => r.status !== 'success')) {
-      rs = await this.postTxs(beef, txids)
-    }
-
     return rs
   }
 

docs/wallet.md

@@ -1,35 +1,77 @@
-import { toBase58 } from "@bsv/sdk/dist/types/src/primitives/utils"
-import { _tu } from "../../../test/utils/TestUtilsWalletStorage"
-import { sdk, wait } from "../../index.client"
-import ARC from "../providers/ARC"
+import { _tu } from '../../../test/utils/TestUtilsWalletStorage'
+import { sdk, wait } from '../../index.client'
+import ARC from '../providers/ARC'
+import { BeefTx } from '@bsv/sdk'
+import { arcDefaultUrl } from '../createDefaultWalletServicesOptions'
 
 describe('ARC tests', () => {
   jest.setTimeout(99999999)
 
   const envTest = _tu.getEnv('test')
-  const arcTest = new ARC(arcUrl(envTest.chain), { apiKey: envTest.taalApiKey })
+  const arcTest = new ARC(arcDefaultUrl(envTest.chain), {
+    apiKey: envTest.taalApiKey
+  })
 
   const envMain = _tu.getEnv('main')
-  const arcMain = new ARC(arcUrl(envMain.chain), { apiKey: envMain.taalApiKey })
+  const arcMain = new ARC(arcDefaultUrl(envMain.chain), {
+    apiKey: envMain.taalApiKey
+  })
 
-  test('7 postRawTx testnet', async () => {
+  test.skip('7 postRawTx testnet', async () => {
     await postRawTxTest('test', arcTest)
   })
 
-  test('8 postRawTx mainnet', async () => {
+  test.skip('8 postRawTx mainnet', async () => {
     await postRawTxTest('main', arcMain)
   })
 
+  test.skip('9 postBeef testnet', async () => {
+    const r = await postBeefTest('test', arcTest)
+    console.log(`9 postBeef testnet done ${r}`)
+  })
+
+  test.skip('10 postBeef mainnet', async () => {
+    const r = await postBeefTest('main', arcMain)
+    console.log(`10 postBeef mainnet done ${r}`)
+  })
 })
 
-function arcUrl(chain: sdk.Chain): string {
-  const url = chain === 'main'
-    ? 'https://api.taal.com/arc'
-    : 'https://arc-test.taal.com'
-  return url
+async function postBeefTest(chain: sdk.Chain, arc: ARC): Promise<string> {
+  if (_tu.noEnv(chain)) return 'skipped'
+  const c = await _tu.createNoSendTxPair(chain)
+
+  const txids = [c.txidDo, c.txidUndo]
+
+  const r = await arc.postBeef(c.beef, txids)
+  expect(r.status).toBe('success')
+  for (const txid of txids) {
+    const tr = r.txidResults.find(tx => tx.txid === txid)
+    expect(tr).not.toBeUndefined()
+    expect(tr!.status).toBe('success')
+  }
+
+  // replace Undo transaction with double spend transaction and send again.
+  const beef2 = c.beef.clone()
+  beef2.txs[beef2.txs.length - 1] = BeefTx.fromTx(c.doubleSpendTx)
+  const txids2 = [c.txidDo, c.doubleSpendTx.id('hex')]
+
+  const r2 = await arc.postBeef(beef2, txids2)
+  expect(r2.status).toBe('error')
+  for (const txid of txids2) {
+    const tr = r2.txidResults.find(tx => tx.txid === txid)
+    expect(tr).not.toBeUndefined()
+    if (txid === c.txidDo) {
+      expect(tr!.status).toBe('success')
+    } else {
+      expect(tr!.status).toBe('error')
+      expect(tr!.doubleSpend).toBe(true)
+      expect(tr!.competingTxs).toEqual([c.txidUndo])
+    }
+  }
+  return 'passed'
 }
 
-async function postRawTxTest(chain: sdk.Chain, arc: ARC) {
+async function postRawTxTest(chain: sdk.Chain, arc: ARC): Promise<void> {
   if (_tu.noEnv(chain)) return
   const c = await _tu.createNoSendTxPair(chain)
 
@@ -64,4 +106,4 @@ async function postRawTxTest(chain: sdk.Chain, arc: ARC) {
   expect(rDouble.status).toBe('error')
   expect(rDouble.doubleSpend).toBe(true)
   expect(rDouble.competingTxs![0]).toBe(c.txidUndo)
-}
+}

package-lock.json

@@ -4,6 +4,5 @@ import { Services } from '../../index.all'
 describe.skip('arcServices tests', () => {
   jest.setTimeout(99999999)
 
-  test('0 ', async () => {
-  })
+  test('0 ', async () => {})
 })

src/sdk/WalletServices.interfaces.ts

@@ -1,19 +1,54 @@
-import { Beef } from '@bsv/sdk'
-import { Services } from '../../index.client'
+import { Beef, BeefTx } from '@bsv/sdk'
+import { sdk, Services } from '../../index.client'
+import { _tu } from '../../../test/utils/TestUtilsWalletStorage'
 
 describe('postBeef service tests', () => {
   jest.setTimeout(99999999)
 
-  test('0', async () => {
+  test('0 postBeef mainnet', async () => {
     const options = Services.createDefaultOptions('main')
     const services = new Services(options)
+    await postBeefTest(services)
+  })
 
-    const txid =
-      '9cce99686bc8621db439b7150dd5b3b269e4b0628fd75160222c417d6f2b95e4'
-    const rawTx = await services.getRawTx(txid)
-    const beef = new Beef()
-    beef.mergeRawTx(rawTx.rawTx!)
-    const r = await services.postTxs(beef, [txid])
-    expect(r).toBeTruthy()
+  test('1 postBeef testnet', async () => {
+    const options = Services.createDefaultOptions('test')
+    const services = new Services(options)
+    await postBeefTest(services)
   })
 })
+
+async function postBeefTest(services: Services) {
+  const chain = services.chain
+  if (_tu.noEnv(chain)) return
+  const c = await _tu.createNoSendTxPair(chain)
+
+  const txids = [c.txidDo, c.txidUndo]
+
+  const [r] = await services.postBeef(c.beef, txids)
+  expect(r.status).toBe('success')
+  for (const txid of txids) {
+    const tr = r.txidResults.find(tx => tx.txid === txid)
+    expect(tr).not.toBeUndefined()
+    expect(tr!.status).toBe('success')
+  }
+
+  // replace Undo transaction with double spend transaction and send again.
+  const beef2 = c.beef.clone()
+  beef2.txs[beef2.txs.length - 1] = BeefTx.fromTx(c.doubleSpendTx)
+  const txids2 = [c.txidDo, c.doubleSpendTx.id('hex')]
+
+  const [r2] = await services.postBeef(beef2, txids2)
+  expect(r2.status).toBe('error')
+  for (const txid of txids2) {
+    const tr = r2.txidResults.find(tx => tx.txid === txid)
+    expect(tr).not.toBeUndefined()
+    if (txid === c.txidDo) {
+      expect(tr!.status).toBe('success')
+    } else {
+      expect(tr!.status).toBe('error')
+      expect(tr!.doubleSpend).toBe(true)
+      expect(tr!.competingTxs).toEqual([c.txidUndo])
+    }
+  }
+}