@bopen-io/wallet-toolbox 1.7.18

package/test/Wallet/action/createActionToGenerateBeefs.man.test.ts

@@ -0,0 +1,293 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import * as bsv from '@bsv/sdk'
+import { sdk, Wallet } from '../../../src/index.all'
+
+import {
+  _tu,
+  logTransaction,
+  TestKeyPair,
+  TestWalletNoSetup,
+  cleanUnsentTransactionsUsingAbort,
+  cleanUnsignedTransactionsUsingAbort,
+  cleanUnprocessedTransactionsUsingAbort
+} from '../../utils/TestUtilsWalletStorage'
+
+describe('createActionToGenerateBeefs test', () => {
+  jest.setTimeout(99999999)
+
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    ctxs.push(await _tu.createLiveWalletSQLiteWARNING())
+    for (const { services } of ctxs) {
+      // Mock the services postBeef to avoid actually broadcasting new transactions and collect beef data.
+      services.postBeef = jest
+        .fn()
+        .mockImplementation((beef: bsv.Beef, txids: string[]): Promise<sdk.PostBeefResult[]> => {
+          const r: sdk.PostBeefResult = {
+            name: 'mock',
+            status: 'success',
+            txidResults: txids.map(txid => ({ txid, status: 'success' }))
+          }
+          return Promise.resolve([r])
+        })
+    }
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('1_send 2 txs in a beef', async () => {
+    const root = '02135476'
+    const kp = _tu.getKeyPair(root.repeat(8))
+
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      const {
+        txidPair: [txid1, txid2],
+        Beef: beef1
+      } = await createAndConsume(wallet, root, kp)
+
+      {
+        const createArgs: bsv.CreateActionArgs = {
+          description: `${kp.address} of ${root}`,
+          options: {
+            acceptDelayedBroadcast: false,
+            sendWith: [txid1, txid2]
+          }
+        }
+
+        const cr = await wallet.createAction(createArgs)
+
+        expect(cr.noSendChange).not.toBeTruthy()
+        expect(cr.sendWithResults?.length).toBe(2)
+        const [swr1, swr2] = cr.sendWithResults!
+        expect(swr1.status !== 'failed').toBe(true)
+        expect(swr2.status !== 'failed').toBe(true)
+        expect(swr1.txid).toBe(txid1)
+        expect(swr2.txid).toBe(txid2)
+        const r1 = await cleanUnsentTransactionsUsingAbort(wallet, storage)
+        await expect(Promise.resolve(r1)).resolves.toBe(true)
+        const r2 = await cleanUnsignedTransactionsUsingAbort(wallet, storage)
+        await expect(Promise.resolve(r2)).resolves.toBe(true)
+        const r3 = await cleanUnprocessedTransactionsUsingAbort(wallet, storage)
+        await expect(Promise.resolve(r3)).resolves.toBe(true)
+      }
+    }
+  })
+
+  test('2_send 4 txs in a single beef ', async () => {
+    const root1 = '02135476'
+    const kp1 = _tu.getKeyPair(root1.repeat(8))
+    const root2 = '02135478'
+    const kp2 = _tu.getKeyPair(root2.repeat(8))
+
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      const {
+        txidPair: [txid1, txid2],
+        Beef: beef1
+      } = await createAndConsume(wallet, root1, kp1)
+      expect(txid1).toBeTruthy()
+      expect(txid2).toBeTruthy()
+
+      const {
+        txidPair: [txid3, txid4],
+        Beef: beef2
+      } = await createAndConsume(wallet, root2, kp2)
+      expect(txid3).toBeTruthy()
+      expect(txid4).toBeTruthy()
+
+      {
+        const createArgs: bsv.CreateActionArgs = {
+          description: `${root1} & ${root2}`,
+          options: {
+            acceptDelayedBroadcast: false,
+            sendWith: [txid1, txid2, txid3, txid4]
+          }
+        }
+
+        const cr = await wallet.createAction(createArgs)
+
+        expect(cr.noSendChange).not.toBeTruthy()
+        expect(cr.sendWithResults?.length).toBe(2)
+        const [swr1, swr2, swr3, swr4] = cr.sendWithResults!
+        expect(swr1.status !== 'failed').toBe(true)
+        expect(swr2.status !== 'failed').toBe(true)
+        expect(swr3.status !== 'failed').toBe(true)
+        expect(swr4.status !== 'failed').toBe(true)
+        expect(swr1.txid).toBe(txid1)
+        expect(swr2.txid).toBe(txid2)
+        expect(swr3.txid).toBe(txid3)
+        expect(swr4.txid).toBe(txid4)
+        const r1 = await cleanUnsentTransactionsUsingAbort(wallet, storage)
+        await expect(Promise.resolve(r1)).resolves.toBe(true)
+        const r2 = await cleanUnsignedTransactionsUsingAbort(wallet, storage)
+        await expect(Promise.resolve(r2)).resolves.toBe(true)
+        const r3 = await cleanUnprocessedTransactionsUsingAbort(wallet, storage)
+        await expect(Promise.resolve(r3)).resolves.toBe(true)
+      }
+    }
+  })
+
+  test('3_test tranaction log', async () => {
+    for (const { activeStorage: storage } of ctxs) {
+      const txid: bsv.HexString = 'ed11e4b7402e38bac0ec7431063ae7c14ee82370e5f1963d48ae27a70527f784'
+      const rl = await logTransaction(storage, txid)
+      console.log(rl)
+      break
+    }
+  })
+  test('4_abort set of nosend transactions', async () => {
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      const r = await cleanUnsentTransactionsUsingAbort(wallet, storage)
+      await expect(Promise.resolve(r)).resolves.toBe(true)
+    }
+  })
+
+  test('5_abort a set of unsigned transactions', async () => {
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      const r = await cleanUnsignedTransactionsUsingAbort(wallet, storage)
+      await expect(Promise.resolve(r)).resolves.toBe(true)
+    }
+  })
+
+  test('6_abort a set of unprocessed transactions', async () => {
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      const r = await cleanUnprocessedTransactionsUsingAbort(wallet, storage)
+      await expect(Promise.resolve(r)).resolves.toBe(true)
+    }
+  })
+
+  test('7_abort all transactions', async () => {
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      const r1 = await cleanUnsentTransactionsUsingAbort(wallet, storage)
+      await expect(Promise.resolve(r1)).resolves.toBe(true)
+      const r2 = await cleanUnsignedTransactionsUsingAbort(wallet, storage)
+      await expect(Promise.resolve(r2)).resolves.toBe(true)
+      const r3 = await cleanUnprocessedTransactionsUsingAbort(wallet, storage)
+      await expect(Promise.resolve(r3)).resolves.toBe(true)
+    }
+  })
+})
+
+async function createAndConsume(
+  wallet: Wallet,
+  root: string,
+  kp: TestKeyPair
+): Promise<{ txidPair: bsv.TXIDHexString[]; Beef: bsv.Beef }> {
+  let txid1: bsv.TXIDHexString
+  let txid2: bsv.TXIDHexString
+  const outputSatoshis = 42
+  let noSendChange: string[] | undefined
+  let inputBEEF: bsv.AtomicBEEF | undefined
+
+  {
+    const createArgs: bsv.CreateActionArgs = {
+      description: `${kp.address} of ${root}`,
+      outputs: [
+        {
+          satoshis: outputSatoshis,
+          lockingScript: _tu.getLockP2PKH(kp.address).toHex(),
+          outputDescription: 'pay fred'
+        }
+      ],
+      options: {
+        randomizeOutputs: false,
+        signAndProcess: false,
+        noSend: true
+      }
+    }
+
+    const cr = await wallet.createAction(createArgs)
+
+    noSendChange = cr.noSendChange
+
+    expect(cr.noSendChange).toBeTruthy()
+    expect(cr.sendWithResults).toBeUndefined()
+    expect(cr.tx).toBeUndefined()
+    expect(cr.txid).toBeUndefined()
+
+    expect(cr.signableTransaction).toBeTruthy()
+    const st = cr.signableTransaction!
+    expect(st.reference).toBeTruthy()
+    // const tx = Transaction.fromAtomicBEEF(st.tx) // Transaction doesn't support V2 Beef yet.
+    const atomicBeef = bsv.Beef.fromBinary(st.tx)
+    const tx = atomicBeef.txs[atomicBeef.txs.length - 1].tx!
+    for (const input of tx.inputs) {
+      expect(atomicBeef.findTxid(input.sourceTXID!)).toBeTruthy()
+    }
+
+    // Spending authorization check happens here...
+    //expect(st.amount > 242 && st.amount < 300).toBe(true)
+
+    // sign and complete
+    const signArgs: bsv.SignActionArgs = {
+      reference: st.reference,
+      spends: {},
+      options: {
+        returnTXIDOnly: false,
+        noSend: true
+      }
+    }
+
+    const sr = await wallet.signAction(signArgs)
+    inputBEEF = sr.tx
+
+    txid1 = sr.txid!
+    // Update the noSendChange txid to final signed value.
+    noSendChange = noSendChange!.map(op => `${txid1}.${op.split('.')[1]}`)
+  }
+  {
+    const unlock = _tu.getUnlockP2PKH(kp.privateKey, outputSatoshis)
+    const unlockingScriptLength = await unlock.estimateLength()
+
+    const createArgs: bsv.CreateActionArgs = {
+      description: `${kp.address} of ${root}`,
+      inputs: [
+        {
+          outpoint: `${txid1}.0`,
+          inputDescription: 'spend ${kp.address} of ${root}',
+          unlockingScriptLength
+        }
+      ],
+      inputBEEF,
+      options: {
+        noSendChange,
+        // signAndProcess: false, // Not required as an input lacks unlock script...
+        noSend: true
+      }
+    }
+
+    const cr = await wallet.createAction(createArgs)
+
+    expect(cr.noSendChange).toBeTruthy()
+    expect(cr.sendWithResults).toBeUndefined()
+    expect(cr.tx).toBeUndefined()
+    expect(cr.txid).toBeUndefined()
+    expect(cr.signableTransaction).toBeTruthy()
+    const st = cr.signableTransaction!
+    expect(st.reference).toBeTruthy()
+    const atomicBeef: bsv.Beef = bsv.Beef.fromBinary(st.tx)
+    const tx = atomicBeef.txs[atomicBeef.txs.length - 1].tx!
+
+    tx.inputs[0].unlockingScriptTemplate = unlock
+    await tx.sign()
+    const unlockingScript = tx.inputs[0].unlockingScript!.toHex()
+
+    const signArgs: bsv.SignActionArgs = {
+      reference: st.reference,
+      spends: { 0: { unlockingScript } },
+      options: {
+        returnTXIDOnly: true,
+        noSend: true
+      }
+    }
+    const sr = await wallet.signAction(signArgs)
+
+    txid2 = sr.txid!
+    //expect(atomicBeef.isValid()).toBe(true)
+    return { txidPair: [txid1, txid2], Beef: atomicBeef }
+  }
+}

package/test/Wallet/action/internalizeAction.a.test.ts

@@ -0,0 +1,286 @@
+import { Beef, InternalizeOutput } from '@bsv/sdk'
+import { sdk, StorageKnex } from '../../../src/index.all'
+import { _tu, expectToThrowWERR, TestWalletNoSetup } from '../../utils/TestUtilsWalletStorage'
+import { getBeefForTransaction } from '../../../src/storage/methods/getBeefForTransaction'
+
+/**
+ * NOT PASSING YET
+ */
+describe.skip('internalizeAction tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnvFlags('test')
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) ctxs.push(await _tu.createLegacyWalletMySQLCopy('internalizeActionTests'))
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('internalizeActionTests'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  // Check:  'unproven' or 'completed' status. Any other status is an error.
+  // When the transaction already exists, the description is updated. The isOutgoing sense is not changed.
+
+  test.skip('1_default real wallet data', async () => {
+    // 1. construct a normal transaction with user supplied output.
+    // 2. dito but user input
+    // 3..Repeat 1 & 2  but use sign action
+    // Repeat 1-3 but use noSend and then a sendWith.
+    // Figure the exact fee cost for transactions 1-3 and start with a noSend transaction that creates a change output with just the right fee amount. Then rebuild 1-3, as second tx, feed it the noSend change from the first tx, confirm no additional change is added or produced, use sendWith to send both as a batch.
+    // "basket insertion" Merge Rules:
+    // The "default" basket may not be specified as the insertion basket.
+    // A change output in the "default" basket may not be target of an insertion into a different basket.
+    // These baskets do not affect the wallet's balance and are typed "custom".
+    // "wallet payment" Merge Rules:
+    // Targetting an existing change "default" basket output results in a no-op. No error. No alterations made.
+    // Targetting a previously "custom" non-change output converts it into a change output. This alters the transaction's amount, and the wallet balance.
+
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      try {
+        // Prepare StorageGetBeefOptions
+        const options: sdk.StorageGetBeefOptions = {
+          // Setting 'known' tells it not to include rawTxs it already knows about, just their txids.
+          // trustSelf: 'known',
+          // Setting knownTxids tells it not to include these rawTxs, just their txids.
+          // knownTxids: ['2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122'],
+          // False and undefined are equal here so no need for this.
+          // ignoreStorage: false,
+          // Yes, you expect storage to have the info, so don't use services.
+          ignoreServices: true
+          // Since you aren't using services and there won't be any newProven (rawTx's with merklePaths previously unknown to storage but required for this beef)
+          // ignoreNewProven: false,
+          // You don't expect infinitely deep nonsense
+          // minProofLevel: 0
+        }
+
+        // Fetch Beef object
+        const beef = await storage.getBeefForTransaction(
+          '2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122',
+          options
+        )
+
+        //console.log('Beef Object:\n', beef.toLogString())
+
+        // Ensure Beef object contains valid transactions
+        if (beef.txs.length === 0) {
+          throw new Error('Beef contains no transactions')
+        }
+
+        // Validate the first transaction in the Beef object
+        const firstTx = beef.txs[0]
+        if (!firstTx.isValid) {
+          console.error('First transaction is invalid:', firstTx)
+          throw new Error('Beef contains an invalid transaction')
+        }
+
+        expect(beef.atomicTxid).toBeUndefined()
+
+        // Convert to AtomicBEEF transaction
+        const atomicTx = beef.toBinaryAtomic('2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122')
+        //console.log('Atomic Transaction:', atomicTx)
+
+        // {
+        //   const abeef = Beef.fromBinary(atomicTx)
+        //   expect(abeef.atomicTxid).toBe('2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122')
+        // }
+
+        // This needs to be a real output (the locking script and derivation bits / key need to work with each other)
+        // But it is still a valid test to see what the reaction is to this nonsense :-)
+        // Prepare output for internalization
+        const output: InternalizeOutput = {
+          outputIndex: 2,
+          protocol: 'wallet payment',
+          paymentRemittance: {
+            derivationPrefix: 'y0tgyMJbVWKhds2/MWkDBA==',
+            derivationSuffix: 'J1Q1E8re2RbvKONkEiEHDA==',
+            senderIdentityKey: '03ac2d10bdb0023f4145cc2eba2fcd2ad3070cb2107b0b48170c46a9440e4cc3fe'
+          }
+        }
+
+        // Internalize Action
+        const r = await wallet.internalizeAction({
+          tx: atomicTx,
+          outputs: [output],
+          description: 'Default wallet payment'
+        })
+
+        // Validate result
+        //console.log('Internalize Action Result:', r)
+        expect(r).toBeDefined()
+      } catch (error) {
+        console.error('Test failed with error:', error)
+        throw error
+      }
+    }
+  })
+
+  test('2_default real basket insertion', async () => {
+    // 1. construct a normal transaction with user supplied output.
+    // 2. dito but user input
+    // 3..Repeat 1 & 2  but use sign action
+    // Repeat 1-3 but use noSend and then a sendWith.
+    // Figure the exact fee cost for transactions 1-3 and start with a noSend transaction that creates a change output with just the right fee amount. Then rebuild 1-3, as second tx, feed it the noSend change from the first tx, confirm no additional change is added or produced, use sendWith to send both as a batch.
+    // "basket insertion" Merge Rules:
+    // The "default" basket may not be specified as the insertion basket.
+    // A change output in the "default" basket may not be target of an insertion into a different basket.
+    // These baskets do not affect the wallet's balance and are typed "custom".
+    // "wallet payment" Merge Rules:
+    // Targetting an existing change "default" basket output results in a no-op. No error. No alterations made.
+    // Targetting a previously "custom" non-change output converts it into a change output. This alters the transaction's amount, and the wallet balance.
+
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      try {
+        // Prepare StorageGetBeefOptions
+        const options: sdk.StorageGetBeefOptions = {
+          // Setting 'known' tells it not to include rawTxs it already knows about, just their txids.
+          // trustSelf: 'known',
+          // Setting knownTxids tells it not to include these rawTxs, just their txids.
+          // knownTxids: ['2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122'],
+          // False and undefined are equal here so no need for this.
+          // ignoreStorage: false,
+          // Yes, you expect storage to have the info, so don't use services.
+          ignoreServices: true
+          // Since you aren't using services and there won't be any newProven (rawTx's with merklePaths previously unknown to storage but required for this beef)
+          // ignoreNewProven: false,
+          // You don't expect infinitely deep nonsense
+          // minProofLevel: 0
+        }
+
+        // Fetch Beef object
+        const beef = await storage.getBeefForTransaction(
+          'a3b2f0935c7b5bb7a841a09e535c13be86f4df0e7a91cebdc33812bfcc0eb9d7',
+          options
+        )
+
+        //console.log('Beef Object:\n', beef.toLogString())
+
+        // Ensure Beef object contains valid transactions
+        if (beef.txs.length === 0) {
+          throw new Error('Beef contains no transactions')
+        }
+
+        // Validate the first transaction in the Beef object
+        const firstTx = beef.txs[0]
+        if (!firstTx.isValid) {
+          console.error('First transaction is invalid:', firstTx)
+          throw new Error('Beef contains an invalid transaction')
+        }
+
+        expect(beef.atomicTxid).toBeUndefined()
+
+        // Convert to AtomicBEEF transaction
+        const atomicTx = beef.toBinaryAtomic('a3b2f0935c7b5bb7a841a09e535c13be86f4df0e7a91cebdc33812bfcc0eb9d7')
+        //console.log('Atomic Transaction:', atomicTx)
+
+        {
+          const abeef = Beef.fromBinary(atomicTx)
+          expect(abeef.atomicTxid).toBe('a3b2f0935c7b5bb7a841a09e535c13be86f4df0e7a91cebdc33812bfcc0eb9d7')
+        }
+
+        // This needs to be a real output (the locking script and derivation bits / key need to work with each other)
+        // But it is still a valid test to see what the reaction is to this nonsense :-)
+        // Prepare output for internalization
+        const output: InternalizeOutput = {
+          outputIndex: 0,
+          protocol: 'basket insertion',
+          // export interface BasketInsertion {
+          //   basket: BasketStringUnder300Bytes
+          //   customInstructions?: string
+          //   tags?: OutputTagStringUnder300Bytes[]
+          // }
+          insertionRemittance: {
+            basket: 'babbage-token-access',
+            tags: [
+              'babbage_originator todo.babbage.systems',
+              'babbage_action_originator projectbabbage.com',
+              'babbage_protocolname todo list',
+              'babbage_protocolsecuritylevel 2',
+              'babbage_counterparty self'
+            ]
+          }
+        }
+
+        // Internalize Action
+        const r = await wallet.internalizeAction({
+          tx: atomicTx,
+          outputs: [output],
+          description: 'Default basket insertion'
+        })
+
+        // Validate result
+        //console.log('Internalize Action Result:', r)
+        expect(r).toBeDefined()
+      } catch (error) {
+        console.error('Test failed with error:', error)
+        throw error
+      }
+    }
+  })
+
+  test.skip('3_default', async () => {
+    for (const { wallet, activeStorage: storage } of ctxs) {
+      try {
+        // Prepare StorageGetBeefOptions
+        const options: sdk.StorageGetBeefOptions = {
+          ignoreServices: true
+        }
+
+        // Fetch Beef object
+        const beef = await storage.getBeefForTransaction(
+          '2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122',
+          options
+        )
+
+        //console.log('Beef Object:', beef)
+
+        // Ensure Beef object contains valid transactions
+        if (beef.txs.length === 0) {
+          throw new Error('Beef contains no transactions')
+        }
+
+        // Validate the first transaction in the Beef object
+        const firstTx = beef.txs[0]
+        if (!firstTx.isValid) {
+          console.error('First transaction is invalid:', firstTx)
+          throw new Error('Beef contains an invalid transaction')
+        }
+
+        expect(beef.atomicTxid).toBeDefined()
+
+        // Convert to AtomicBEEF transaction
+        const atomicTx = beef.toBinaryAtomic('2795b293c698b2244147aaba745db887a632d21990c474df46d842ec3e52f122')
+        //console.log('Atomic Transaction:', atomicTx)
+
+        // Prepare output for internalization
+        const output: InternalizeOutput = {
+          outputIndex: 2,
+          protocol: 'basket insertion',
+          paymentRemittance: {
+            derivationPrefix: 'y0tgyMJbVWKhds2/MWkDBA==',
+            derivationSuffix: 'J1Q1E8re2RbvKONkEiEHDA==',
+            senderIdentityKey: '03ac2d10bdb0023f4145cc2eba2fcd2ad3070cb2107b0b48170c46a9440e4cc3fe'
+          }
+        }
+
+        // Internalize Action
+        const r = await wallet.internalizeAction({
+          tx: atomicTx,
+          outputs: [output],
+          description: 'Default test description'
+        })
+
+        // Validate result
+        //console.log('Internalize Action Result:', r)
+        expect(r).toBeDefined()
+      } catch (error) {
+        console.error('Test failed with error:', error)
+        throw error
+      }
+    }
+  })
+})