@bsv/wallet-toolbox 1.1.13 → 1.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/wallet-toolbox",
-  "version": "1.1.13",
+  "version": "1.1.14",
   "description": "BRC100 conforming wallet, wallet storage and wallet signer components",
   "main": "./out/src/index.js",
   "types": "./out/src/index.d.ts",
@@ -20,7 +20,7 @@
     "test": "npm run build && jest --testPathIgnorePatterns=man.test.ts",
     "test:watch": "npm run build && jest --testPathIgnorePatterns=man.test.ts --watch",
     "test:coverage": "npm run build && jest --testPathIgnorePatterns=man.test.ts --coverage",
-    "lint": "prettier --write 'src/**/*.ts' --write 'test/**/*.ts' --loglevel silent",
+    "lint": "prettier --write 'src/**/*.ts' --write 'test/**/*.ts' --log-level silent",
     "build": "tsc --build",
     "prepublish": "npm run lint && npm run build && npm run doc",
     "doc": "ts2md"
@@ -32,12 +32,12 @@
   "dependencies": {
     "@bsv/auth-express-middleware": "^1.0.1",
     "@bsv/payment-express-middleware": "^1.0.1",
-    "@bsv/sdk": "^1.3.16",
+    "@bsv/sdk": "^1.3.18",
     "axios": "^0.29.0",
     "express": "^4.21.2",
     "knex": "^3.1.0",
-    "mysql2": "^3.12.0",
-    "whatsonchain": "^0.2.0"
+    "sqlite3": "^5.1.7",
+    "mysql2": "^3.12.0"
   },
   "devDependencies": {
     "@types/diff": "^6.0.0",
@@ -53,8 +53,6 @@
     "jest-diff": "^29.7.0",
     "jest-simple-summary": "^1.0.2",
     "prettier": "^3.4.2",
-    "sqlite3": "^5.1.7",
-    "standard": "^17.1.0",
     "ts-jest": "^29.0.5",
     "ts-node": "^10.9.1",
     "ts2md": "^0.2.8",

package/src/Setup.ts

@@ -21,7 +21,6 @@ import { SetupWallet, SetupWalletArgs, StorageKnex } from './index.all'
  *
  */
 export abstract class Setup extends SetupClient {
-
   /**
    * Adds `Knex` based storage to a `Wallet` configured by `Setup.createWalletOnly`
    *

package/src/SetupClient.ts

@@ -35,6 +35,20 @@ dotenv.config()
  *
  */
 export abstract class SetupClient {
+
+  /**
+   * @param chain
+   * @returns true if .env is not valid for chain
+   */
+  static noEnv(chain: sdk.Chain): boolean {
+    try {
+      SetupClient.getEnv(chain)
+      return false
+    } catch {
+      return true
+    }
+  }
+
   /**
    * Creates content for .env file with some private keys, identity keys, sample API keys, and sample MySQL connection string.
    *
@@ -98,6 +112,10 @@ DEV_KEYS = '{
       chain === 'main'
         ? process.env.MY_MAIN_IDENTITY2
         : process.env.MY_TEST_IDENTITY2
+    const filePath =
+      chain === 'main'
+        ? process.env.MY_MAIN_FILEPATH
+        : process.env.MY_TEST_FILEPATH
     const DEV_KEYS = process.env.DEV_KEYS || '{}'
     const mySQLConnection = process.env.MYSQL_CONNECTION || '{}'
     const taalApiKey = verifyTruthy(
@@ -116,6 +134,7 @@ DEV_KEYS = '{
       chain,
       identityKey,
       identityKey2,
+      filePath,
       taalApiKey,
       devKeys: JSON.parse(DEV_KEYS) as Record<string, string>,
       mySQLConnection
@@ -185,14 +204,11 @@ DEV_KEYS = '{
     args: SetupWalletClientArgs
   ): Promise<SetupWalletClient> {
     const wo = await SetupClient.createWallet(args)
-    if (wo.chain === 'main')
-      throw new sdk.WERR_INVALID_PARAMETER(
-        'chain',
-        `'test' for now, 'main' is not yet supported.`
-      )
 
     const endpointUrl =
-      args.endpointUrl || 'https://staging-dojo.babbage.systems'
+      args.endpointUrl ||
+      `https://${args.env.chain !== 'main' ? 'staging-' : ''}storage.babbage.systems`
+
     const client = new StorageClient(wo.wallet, endpointUrl)
     await wo.storage.addWalletStorageProvider(client)
     await wo.storage.makeAvailable()
@@ -350,6 +366,10 @@ export interface SetupEnv {
    * A secondary identity key (public key), used to test exchanges with other users.
    */
   identityKey2: string
+  /**
+   * Filepath to sqlite file to be used for identityKey wallet.
+   */
+  filePath: string | undefined
   /**
    * A vaild TAAL API key for use by `Services`
    */

package/src/Wallet.ts

@@ -69,14 +69,16 @@ import {
   toWalletNetwork,
   Monitor,
   WalletStorageManager,
-  WalletSigner
+  WalletSigner,
+  randomBytesBase64,
+  ScriptTemplateBRC29
 } from './index.client'
 import { acquireDirectCertificate } from './signer/methods/acquireDirectCertificate'
 import { proveCertificate } from './signer/methods/proveCertificate'
 import { createAction } from './signer/methods/createAction'
 import { signAction } from './signer/methods/signAction'
 import { internalizeAction } from './signer/methods/internalizeAction'
-import { ValidAcquireDirectCertificateArgs } from './sdk'
+import { maxPossibleSatoshis } from './storage/methods/generateChange'
 
 export interface WalletArgs {
   chain: sdk.Chain
@@ -769,6 +771,68 @@ export class Wallet implements WalletInterface, ProtoWallet {
     sdk.validateOriginator(originator)
     return { version: 'wallet-brc100-1.0.0' }
   }
+
+  /**
+   * Transfer all possible satoshis held by this wallet to `toWallet`.
+   *
+   * @param toWallet wallet which will receive this wallet's satoshis.
+   */
+  async sweepTo(toWallet: Wallet): Promise<void> {
+    const derivationPrefix = randomBytesBase64(8)
+    const derivationSuffix = randomBytesBase64(8)
+    const keyDeriver = this.keyDeriver
+
+    const t = new ScriptTemplateBRC29({
+      derivationPrefix,
+      derivationSuffix,
+      keyDeriver
+    })
+
+    const label = 'sweep'
+
+    const satoshis = maxPossibleSatoshis
+
+    const car = await this.createAction({
+      outputs: [
+        {
+          lockingScript: t
+            .lock(keyDeriver.rootKey.toString(), toWallet.identityKey)
+            .toHex(),
+          satoshis,
+          outputDescription: label,
+          tags: ['relinquish'],
+          customInstructions: JSON.stringify({
+            derivationPrefix,
+            derivationSuffix,
+            type: 'BRC29'
+          })
+        }
+      ],
+      options: {
+        randomizeOutputs: false,
+        acceptDelayedBroadcast: false
+      },
+      labels: [label],
+      description: label
+    })
+
+    const iar = await toWallet.internalizeAction({
+      tx: car.tx!,
+      outputs: [
+        {
+          outputIndex: 0,
+          protocol: 'wallet payment',
+          paymentRemittance: {
+            derivationPrefix,
+            derivationSuffix,
+            senderIdentityKey: this.identityKey
+          }
+        }
+      ],
+      description: label,
+      labels: [label]
+    })
+  }
 }
 
 export interface PendingStorageInput {

package/src/sdk/WalletServices.interfaces.ts

@@ -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
 }
 
 /**
@@ -230,11 +224,25 @@ export interface PostTxResultForTxid {
    */
   alreadyKnown?: boolean
 
+  /**
+   * service indicated this broadcast double spends at least one input
+   * `competingTxs` may be an array of txids that were first seen spends of at least one input.
+   */
+  doubleSpend?: boolean
+
   blockHash?: string
   blockHeight?: number
   merklePath?: MerklePath
 
-  data?: object
+  competingTxs?: string[]
+
+  data?: object | string | PostTxResultForTxidError
+}
+
+export interface PostTxResultForTxidError {
+  status?: string
+  detail?: string
+  more?: object
 }
 
 export interface PostBeefResult extends PostTxsResult {}
@@ -366,13 +374,11 @@ export interface BlockHeader extends BaseBlockHeader {
 
 export type GetUtxoStatusService = (
   output: string,
-  chain: sdk.Chain,
   outputFormat?: GetUtxoStatusOutputFormat
 ) => Promise<GetUtxoStatusResult>
 
 export type GetMerklePathService = (
   txid: string,
-  chain: sdk.Chain,
   services: WalletServices
 ) => Promise<GetMerklePathResult>
 
@@ -389,8 +395,7 @@ export type PostTxsService = (
 
 export type PostBeefService = (
   beef: Beef,
-  txids: string[],
-  services: WalletServices
+  txids: string[]
 ) => Promise<PostBeefResult>
 
 export type UpdateFiatExchangeRateService = (

package/src/services/Services.ts

@@ -13,24 +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 {
-  getMerklePathFromWhatsOnChainTsc,
-  getRawTxFromWhatsOnChain,
-  getUtxoStatusFromWhatsOnChain,
-  updateBsvExchangeRate
-} from './providers/whatsonchain'
+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 {
@@ -38,10 +28,11 @@ 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,36 +48,32 @@ export class Services implements sdk.WalletServices {
         ? Services.createDefaultOptions(this.chain)
         : optionsOrChain
 
+    this.whatsonchain = new WhatsOnChain(this.chain, {
+      apiKey: this.options.taalApiKey
+    })
+
+    this.arc = new ARC(this.options.arcUrl, this.options.arcConfig)
+
     this.getMerklePathServices =
       new ServiceCollection<sdk.GetMerklePathService>().add({
-        name: 'WhatsOnChainTsc',
-        service: getMerklePathFromWhatsOnChainTsc
+        name: 'WhatsOnChain',
+        service: this.whatsonchain.getMerklePath.bind(this.whatsonchain)
       })
-    //.add({ name: 'Taal', service: makeGetMerklePathFromTaalARC(getTaalArcServiceConfig(this.chain, this.options.taalApiKey!)) })
 
     this.getRawTxServices = new ServiceCollection<sdk.GetRawTxService>().add({
       name: 'WhatsOnChain',
-      service: getRawTxFromWhatsOnChain
-    })
-
-    this.postTxsServices = new ServiceCollection<sdk.PostTxsService>().add({
-      name: 'TaalArcTxs',
-      service: makePostTxsToTaalARC(
-        getTaalArcServiceConfig(this.chain, this.options.taalApiKey!)
-      )
+      service: this.whatsonchain.getRawTxResult.bind(this.whatsonchain)
     })
 
     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 =
       new ServiceCollection<sdk.GetUtxoStatusService>().add({
         name: 'WhatsOnChain',
-        service: getUtxoStatusFromWhatsOnChain
+        service: this.whatsonchain.getUtxoStatus.bind(this.whatsonchain)
       })
 
     this.updateFiatExchangeRateServices =
@@ -108,10 +95,11 @@ export class Services implements sdk.WalletServices {
   }
 
   async getBsvExchangeRate(): Promise<number> {
-    this.options.bsvExchangeRate = await updateBsvExchangeRate(
-      this.options.bsvExchangeRate,
-      this.options.bsvUpdateMsecs
-    )
+    this.options.bsvExchangeRate =
+      await this.whatsonchain.updateBsvExchangeRate(
+        this.options.bsvExchangeRate,
+        this.options.bsvUpdateMsecs
+      )
     return this.options.bsvExchangeRate.rate
   }
 
@@ -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
   }
@@ -166,7 +151,7 @@ export class Services implements sdk.WalletServices {
     for (let retry = 0; retry < 2; retry++) {
       for (let tries = 0; tries < services.count; tries++) {
         const service = services.service
-        const r = await service(output, this.chain, outputFormat)
+        const r = await service(output, outputFormat)
         if (r.status === 'success') {
           r0 = r
           break
@@ -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
   }
 
@@ -313,7 +274,7 @@ export class Services implements sdk.WalletServices {
 
     for (let tries = 0; tries < this.getMerklePathServices.count; tries++) {
       const service = this.getMerklePathServices.service
-      const r = await service(txid, this.chain, this)
+      const r = await service(txid, this)
       if (r.merklePath) {
         // If we have a proof, call it done.
         r0.merklePath = r.merklePath

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

@@ -0,0 +1,110 @@
+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'
+import { Setup } from '../../index.all'
+
+describe('ARC tests', () => {
+  jest.setTimeout(99999999)
+
+  const envTest = _tu.getEnv('test')
+  const arcTest = new ARC(arcDefaultUrl(envTest.chain), {
+    apiKey: envTest.taalApiKey
+  })
+
+  const envMain = _tu.getEnv('main')
+  const arcMain = new ARC(arcDefaultUrl(envMain.chain), {
+    apiKey: envMain.taalApiKey
+  })
+
+  test.skip('7 postRawTx testnet', async () => {
+    await postRawTxTest('test', arcTest)
+  })
+
+  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}`)
+  })
+})
+
+async function postBeefTest(chain: sdk.Chain, arc: ARC): Promise<string> {
+  if (Setup.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): Promise<void> {
+  if (Setup.noEnv(chain)) return
+  const c = await _tu.createNoSendTxPair(chain)
+
+  const rawTxDo = c.beef.findTxid(c.txidDo)!.tx!.toHex()
+  const rawTxUndo = c.beef.findTxid(c.txidUndo)!.tx!.toHex()
+
+  const rDo = await arc.postRawTx(rawTxDo)
+  expect(rDo.status).toBe('success')
+  expect(rDo.txid).toBe(c.txidDo)
+
+  await wait(1000)
+
+  const rUndo = await arc.postRawTx(rawTxUndo)
+  expect(rUndo.status).toBe('success')
+  expect(rUndo.txid).toBe(c.txidUndo)
+  expect(rUndo.doubleSpend).not.toBe(true)
+
+  await wait(1000)
+
+  {
+    // Send same transaction again...
+    const rUndo = await arc.postRawTx(rawTxUndo)
+    expect(rUndo.status).toBe('success')
+    expect(rUndo.txid).toBe(c.txidUndo)
+    expect(rUndo.doubleSpend).not.toBe(true)
+  }
+
+  await wait(1000)
+
+  // Confirm double spend detection.
+  const rDouble = await arc.postRawTx(c.doubleSpendTx.toHex())
+  expect(rDouble.status).toBe('error')
+  expect(rDouble.doubleSpend).toBe(true)
+  expect(rDouble.competingTxs![0]).toBe(c.txidUndo)
+}

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

@@ -0,0 +1,8 @@
+import { Beef } from '@bsv/sdk'
+import { Services } from '../../index.all'
+
+describe.skip('arcServices tests', () => {
+  jest.setTimeout(99999999)
+
+  test('0 ', async () => {})
+})

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

@@ -1,19 +1,57 @@
-import { Beef } from '@bsv/sdk'
+import { BeefTx } from '@bsv/sdk'
 import { Services } from '../../index.client'
+import { _tu } from '../../../test/utils/TestUtilsWalletStorage'
+import { Setup } from '../../index.all'
 
 describe('postBeef service tests', () => {
   jest.setTimeout(99999999)
 
-  test('0', async () => {
+  test('0 postBeef mainnet', async () => {
+    if (Setup.noEnv('main')) return
     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 () => {
+    if (Setup.noEnv('test')) return
+    const options = Services.createDefaultOptions('test')
+    const services = new Services(options)
+    await postBeefTest(services)
   })
 })
+
+async function postBeefTest(services: Services) {
+  const chain = services.chain
+  if (Setup.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])
+    }
+  }
+}

package/src/services/createDefaultWalletServicesOptions.ts

@@ -1,15 +1,17 @@
-import { sdk } from '../index.client'
+import { randomBytesHex, sdk } from '../index.client'
 import { ChaintracksServiceClient } from './chaintracker'
 
 export function createDefaultWalletServicesOptions(
   chain: sdk.Chain
 ): sdk.WalletServicesOptions {
+  const taalApiKey =
+    chain === 'main'
+      ? 'mainnet_9596de07e92300c6287e4393594ae39c' // no plan
+      : 'testnet_0e6cf72133b43ea2d7861da2a38684e3' // personal "starter" key
+
   const o: sdk.WalletServicesOptions = {
     chain,
-    taalApiKey:
-      chain === 'main'
-        ? 'mainnet_9596de07e92300c6287e4393594ae39c' // Tone's key, no plan
-        : 'testnet_0e6cf72133b43ea2d7861da2a38684e3', // Tone's personal "starter" key
+    taalApiKey,
     bsvExchangeRate: {
       timestamp: new Date('2023-12-13'),
       base: 'USD',
@@ -32,7 +34,18 @@ export function createDefaultWalletServicesOptions(
     chaintracks: new ChaintracksServiceClient(
       chain,
       `https://npm-registry.babbage.systems:${chain === 'main' ? 8084 : 8083}`
-    )
+    ),
+    arcUrl: arcDefaultUrl(chain),
+    arcConfig: {
+      apiKey: taalApiKey,
+      deploymentId: `wallet-toolbox-${randomBytesHex(16)}`
+    }
   }
   return o
 }
+
+export function arcDefaultUrl(chain: sdk.Chain): string {
+  const url =
+    chain === 'main' ? 'https://api.taal.com/arc' : 'https://arc-test.taal.com'
+  return url
+}