@bsv/message-box-client 2.0.4 → 2.0.6

package/src/PeerPayClient.ts

@@ -12,10 +12,14 @@
 
 import { MessageBoxClient } from './MessageBoxClient.js'
 import { PeerMessage } from './types.js'
-import { WalletInterface, P2PKH, PublicKey, createNonce, AtomicBEEF, AuthFetch, Base64String, OriginatorDomainNameStringUnder250Bytes } from '@bsv/sdk'
+import { WalletInterface, AtomicBEEF, AuthFetch, Base64String, OriginatorDomainNameStringUnder250Bytes, Brc29RemittanceModule } from '@bsv/sdk'
 
 import * as Logger from './Utils/logger.js'
 
+function toNumberArray (tx: AtomicBEEF): number[] {
+  return Array.isArray(tx) ? tx : Array.from(tx)
+}
+
 function safeParse<T> (input: any): T {
   try {
     return typeof input === 'string' ? JSON.parse(input) : input
@@ -79,6 +83,7 @@ export class PeerPayClient extends MessageBoxClient {
   private readonly peerPayWalletClient: WalletInterface
   private _authFetchInstance?: AuthFetch
   private readonly messageBox: string
+  private readonly settlementModule: Brc29RemittanceModule
 
   constructor (config: PeerPayClientConfig) {
     const { messageBoxHost = 'https://messagebox.babbage.systems', walletClient, enableLogging = false, originator } = config
@@ -89,6 +94,16 @@ export class PeerPayClient extends MessageBoxClient {
     this.messageBox = config.messageBox ?? STANDARD_PAYMENT_MESSAGEBOX
     this.peerPayWalletClient = walletClient
     this.originator = originator
+
+    this.settlementModule = new Brc29RemittanceModule({
+      protocolID: [2, '3241645161d8'],
+      labels: ['peerpay'],
+      description: 'PeerPay payment',
+      outputDescription: 'Payment for PeerPay transaction',
+      internalizeProtocol: 'wallet payment',
+      refundFeeSatoshis: 1000,
+      minRefundSatoshis: 1000
+    })
   }
 
   private get authFetchInstance (): AuthFetch {
@@ -115,62 +130,40 @@ export class PeerPayClient extends MessageBoxClient {
       throw new Error('Invalid payment details: recipient and valid amount are required')
     };
 
-    // Generate derivation paths using correct nonce function
-    const derivationPrefix = await createNonce(this.peerPayWalletClient, 'self', this.originator)
-    const derivationSuffix = await createNonce(this.peerPayWalletClient, 'self', this.originator)
-
-    Logger.log(`[PP CLIENT] Derivation Prefix: ${derivationPrefix}`)
-    Logger.log(`[PP CLIENT] Derivation Suffix: ${derivationSuffix}`)
-    // Get recipient's derived public key
-    const { publicKey: derivedKeyResult } = await this.peerPayWalletClient.getPublicKey({
-      protocolID: [2, '3241645161d8'],
-      keyID: `${derivationPrefix} ${derivationSuffix}`,
-      counterparty: payment.recipient
-    }, this.originator)
-
-    Logger.log(`[PP CLIENT] Derived Public Key: ${derivedKeyResult}`)
-
-    if (derivedKeyResult == null || derivedKeyResult.trim() === '') {
-      throw new Error('Failed to derive recipient’s public key')
-    }
-
-    // Create locking script using recipient's public key
-    const lockingScript = new P2PKH().lock(PublicKey.fromString(derivedKeyResult).toAddress()).toHex()
-
-    Logger.log(`[PP CLIENT] Locking Script: ${lockingScript}`)
-
-    // Create the payment action
-    const paymentAction = await this.peerPayWalletClient.createAction({
-      description: 'PeerPay payment',
-      labels: ['peerpay'],
-      outputs: [{
-        satoshis: payment.amount,
-        lockingScript,
-        customInstructions: JSON.stringify({
-          derivationPrefix,
-          derivationSuffix,
-          payee: payment.recipient
-        }),
-        outputDescription: 'Payment for PeerPay transaction'
-      }],
-      options: {
-        randomizeOutputs: false
+    const result = await this.settlementModule.buildSettlement(
+      {
+        threadId: 'peerpay',
+        option: {
+          amountSatoshis: payment.amount,
+          payee: payment.recipient,
+          labels: ['peerpay'],
+          description: 'PeerPay payment'
+        }
+      },
+      {
+        wallet: this.peerPayWalletClient,
+        originator: this.originator,
+        now: () => Date.now(),
+        logger: Logger
       }
-    }, this.originator)
+    )
 
-    if (paymentAction.tx === undefined) {
-      throw new Error('Transaction creation failed!')
+    if (result.action === 'terminate') {
+      if (result.termination.code === 'brc29.public_key_missing') {
+        throw new Error('Failed to derive recipient’s public key')
+      }
+      throw new Error(result.termination.message)
     }
 
-    Logger.log('[PP CLIENT] Payment Action:', paymentAction)
+    Logger.log('[PP CLIENT] Payment Action Settlement Artifact:', result.artifact)
 
     return {
       customInstructions: {
-        derivationPrefix,
-        derivationSuffix
+        derivationPrefix: result.artifact.customInstructions.derivationPrefix as Base64String,
+        derivationSuffix: result.artifact.customInstructions.derivationSuffix as Base64String
       },
-      transaction: paymentAction.tx,
-      amount: payment.amount
+      transaction: result.artifact.transaction as AtomicBEEF,
+      amount: result.artifact.amountSatoshis
     }
   }
 
@@ -290,20 +283,33 @@ export class PeerPayClient extends MessageBoxClient {
     try {
       Logger.log(`[PP CLIENT] Processing payment: ${JSON.stringify(payment, null, 2)}`)
 
-      const paymentResult = await this.peerPayWalletClient.internalizeAction({
-        tx: payment.token.transaction,
-        outputs: [{
-          paymentRemittance: {
-            derivationPrefix: payment.token.customInstructions.derivationPrefix,
-            derivationSuffix: payment.token.customInstructions.derivationSuffix,
-            senderIdentityKey: payment.sender
-          },
-          outputIndex: payment.token.outputIndex ?? STANDARD_PAYMENT_OUTPUT_INDEX,
-          protocol: 'wallet payment'
-        }],
-        labels: ['peerpay'],
-        description: 'PeerPay Payment'
-      }, this.originator)
+      const acceptResult = await this.settlementModule.acceptSettlement(
+        {
+          threadId: 'peerpay',
+          sender: payment.sender,
+          settlement: {
+            customInstructions: {
+              derivationPrefix: payment.token.customInstructions.derivationPrefix,
+              derivationSuffix: payment.token.customInstructions.derivationSuffix
+            },
+            transaction: toNumberArray(payment.token.transaction),
+            amountSatoshis: payment.token.amount,
+            outputIndex: payment.token.outputIndex ?? STANDARD_PAYMENT_OUTPUT_INDEX
+          }
+        },
+        {
+          wallet: this.peerPayWalletClient,
+          originator: this.originator,
+          now: () => Date.now(),
+          logger: Logger
+        }
+      )
+
+      if (acceptResult.action === 'terminate') {
+        throw new Error(acceptResult.termination.message)
+      }
+
+      const paymentResult = acceptResult.receiptData?.internalizeResult
 
       Logger.log(`[PP CLIENT] Payment internalized successfully: ${JSON.stringify(paymentResult, null, 2)}`)
       Logger.log(`[PP CLIENT] Acknowledging payment with messageId: ${payment.messageId}`)

package/src/__tests/MessageBoxClient.test.ts

@@ -1,6 +1,6 @@
 /* eslint-env jest */
 import { MessageBoxClient } from '../MessageBoxClient.js'
-import { WalletClient, AuthFetch, Transaction, LockingScript } from '@bsv/sdk'
+import { WalletClient, AuthFetch, Transaction, LockingScript, PushDrop, TopicBroadcaster, Beef } from '@bsv/sdk'
 
 // MOCK: WalletClient methods globally
 jest.spyOn(WalletClient.prototype, 'createHmac').mockResolvedValue({
@@ -168,11 +168,11 @@ describe('MessageBoxClient', () => {
     // Bypass the real connection logic
     jest.spyOn(messageBoxClient, 'initializeConnection').mockImplementation(async () => { })
 
-    // Manually set identity key
-    ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+      // Manually set identity key
+      ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
 
-    // Simulate WebSocket not initialized
-    ; (messageBoxClient as any).socket = null
+      // Simulate WebSocket not initialized
+      ; (messageBoxClient as any).socket = null
 
     // Expect it to fall back to HTTP and succeed
     const result = await messageBoxClient.sendLiveMessage({
@@ -282,7 +282,7 @@ describe('MessageBoxClient', () => {
       enableLogging: true
     })
     await messageBoxClient.init()
-    ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+      ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
     jest.spyOn(messageBoxClient.authFetch, 'fetch').mockResolvedValue({
       json: async () => ({
         status: 'success',
@@ -309,7 +309,7 @@ describe('MessageBoxClient', () => {
       enableLogging: true
     })
     await messageBoxClient.init()
-    ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+      ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
 
     jest.spyOn(messageBoxClient.authFetch, 'fetch').mockResolvedValue({
       json: async () => JSON.parse(VALID_LIST_AND_READ_RESULT.body),
@@ -330,7 +330,7 @@ describe('MessageBoxClient', () => {
       enableLogging: true
     })
     await messageBoxClient.init()
-    ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+      ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
 
     jest.spyOn(messageBoxClient.authFetch, 'fetch').mockResolvedValue({
       json: async () => JSON.parse(VALID_ACK_RESULT.body),
@@ -352,7 +352,7 @@ describe('MessageBoxClient', () => {
     })
     await messageBoxClient.init()
 
-    ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+      ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
 
     jest.spyOn(messageBoxClient.authFetch, 'fetch')
       .mockResolvedValue({
@@ -425,7 +425,7 @@ describe('MessageBoxClient', () => {
       enableLogging: true
     })
     await messageBoxClient.init()
-    ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+      ; (messageBoxClient as any).myIdentityKey = '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
 
     jest.spyOn(messageBoxClient.authFetch, 'fetch')
       .mockResolvedValue({
@@ -715,10 +715,10 @@ describe('MessageBoxClient', () => {
     })
     await client.init()
 
-    // For this ONE call return two adverts – the first is selected
-    ; (MessageBoxClient.prototype as any).queryAdvertisements
-      .mockResolvedValueOnce([
-        { host: 'https://peer.box' }, { host: 'https://second.box' }])
+      // For this ONE call return two adverts – the first is selected
+      ; (MessageBoxClient.prototype as any).queryAdvertisements
+        .mockResolvedValueOnce([
+          { host: 'https://peer.box' }, { host: 'https://second.box' }])
 
     const result = await client.resolveHostForRecipient('02aa…deadbeef')
     expect(result).toBe('https://peer.box')
@@ -730,11 +730,124 @@ describe('MessageBoxClient', () => {
       host: 'https://default.box'
     })
     await client.init()
-    ; (MessageBoxClient.prototype as any).queryAdvertisements
-      .mockResolvedValueOnce([])
+      ; (MessageBoxClient.prototype as any).queryAdvertisements
+        .mockResolvedValueOnce([])
 
     const result = await client.resolveHostForRecipient('03bb…cafef00d')
 
     expect(result).toBe('https://default.box')
   })
+
+  it('anointHost queries advertisements for existing host records', async () => {
+    const anointMock = MessageBoxClient.prototype.anointHost as unknown as jest.Mock
+    anointMock.mockRestore()
+
+    const client = new MessageBoxClient({
+      walletClient: mockWalletClient,
+      host: 'https://default.box'
+    })
+
+    const querySpy = jest.spyOn(client as any, 'queryAdvertisements').mockResolvedValue([])
+    jest.spyOn(mockWalletClient, 'listOutputs').mockResolvedValue({ outputs: [] } as any)
+    jest.spyOn(PushDrop.prototype, 'lock').mockResolvedValue({
+      toHex: () => '00',
+      toASM: () => 'OP_FALSE'
+    } as any)
+    jest.spyOn(Transaction, 'fromAtomicBEEF').mockReturnValue({} as any)
+    jest.spyOn(TopicBroadcaster.prototype as any, 'broadcast').mockResolvedValue({ txid: 'broadcasted-txid' })
+
+    await client.anointHost('https://fresh.host')
+
+    expect(querySpy).toHaveBeenCalledWith(
+      '02b463b8ef7f03c47fba2679c7334d13e4939b8ca30dbb6bbd22e34ea3e9b1b0e4'
+    )
+  })
+
+  it('anointHost signs all revoke inputs when multiple spendable advertisements exist', async () => {
+    const client = new MessageBoxClient({
+      walletClient: mockWalletClient,
+      host: 'https://default.box'
+    })
+
+    const tokenA = {
+      host: 'http://localhost:8080',
+      txid: 'tx-a',
+      outputIndex: 0,
+      lockingScript: {} as any,
+      beef: [1, 2, 3]
+    }
+    const tokenB = {
+      host: 'https://valid.host',
+      txid: 'tx-b',
+      outputIndex: 1,
+      lockingScript: {} as any,
+      beef: [4, 5, 6]
+    }
+
+    jest.spyOn(client as any, 'queryAdvertisements').mockResolvedValue([tokenA, tokenB])
+    jest.spyOn(mockWalletClient, 'listOutputs').mockResolvedValue({
+      outputs: [
+        { spendable: true, outpoint: 'tx-a.0' },
+        { spendable: true, outpoint: 'tx-b.1' }
+      ]
+    } as any)
+
+    jest.spyOn(PushDrop.prototype, 'lock').mockResolvedValue({
+      toHex: () => '00',
+      toASM: () => 'OP_FALSE'
+    } as any)
+
+    const unlockSignMock = jest
+      .fn()
+      .mockImplementation(async (_tx: unknown, inputIndex: number) => ({ toHex: () => `unlock-${inputIndex}` }))
+    jest.spyOn(PushDrop.prototype, 'unlock').mockReturnValue({ sign: unlockSignMock } as any)
+
+    const mergedBeef = {
+      mergeBeef: jest.fn(),
+      toBinary: jest.fn().mockReturnValue([9, 9, 9])
+    }
+    jest.spyOn(Beef, 'fromBinary').mockImplementation(() => mergedBeef as any)
+
+    const fromAtomicSpy = jest.spyOn(Transaction, 'fromAtomicBEEF')
+    fromAtomicSpy
+      .mockReturnValueOnce({} as any)
+      .mockReturnValueOnce({} as any)
+    jest.spyOn(Transaction, 'fromBEEF').mockReturnValue({ outputs: [{ satoshis: 1 }, { satoshis: 1 }] } as any)
+
+    const createActionSpy = jest.spyOn(mockWalletClient, 'createAction').mockResolvedValue({
+      signableTransaction: {
+        tx: [7, 7, 7],
+        reference: 'sign-ref'
+      }
+    } as any)
+    const signActionSpy = jest.spyOn(mockWalletClient, 'signAction').mockResolvedValue({
+      tx: [8, 8, 8],
+      txid: 'signed-txid'
+    } as any)
+    jest.spyOn(TopicBroadcaster.prototype as any, 'broadcast').mockResolvedValue({ txid: 'broadcasted-txid' })
+
+    const result = await client.anointHost('https://new.host')
+
+    expect(createActionSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        inputBEEF: [9, 9, 9],
+        inputs: [
+          expect.objectContaining({ outpoint: 'tx-a.0' }),
+          expect.objectContaining({ outpoint: 'tx-b.1' })
+        ]
+      }),
+      undefined
+    )
+    expect(signActionSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reference: 'sign-ref',
+        spends: {
+          0: { unlockingScript: 'unlock-0' },
+          1: { unlockingScript: 'unlock-1' }
+        }
+      }),
+      undefined
+    )
+    expect(result).toEqual({ txid: 'broadcasted-txid' })
+  })
 })