@bopen-io/wallet-toolbox 1.7.18

package/src/storage/schema/entities/__tests/TransactionTests.test.ts

@@ -0,0 +1,604 @@
+import { Knex } from 'knex'
+import * as bsv from '@bsv/sdk'
+import { createSyncMap, sdk, SyncMap, TableTransaction } from '../../../../../src'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+import { EntityTransaction } from '../EntityTransaction'
+
+describe('Transaction class method tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+  const ctxs2: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) {
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy('transactionTests'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('transactionTests2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('transactionTests'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('transactionTests2'))
+  })
+
+  afterAll(async () => {
+    // Destroy both sets of database contexts
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+    for (const ctx of ctxs2) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  // Test: Constructor with default values
+  test('0_creates_instance_with_default_values', () => {
+    const tx = new EntityTransaction()
+
+    const now = new Date()
+    expect(tx.transactionId).toBe(0)
+    expect(tx.userId).toBe(0)
+    expect(tx.txid).toBe('')
+    expect(tx.status).toBe('unprocessed')
+    expect(tx.reference).toBe('')
+    expect(tx.satoshis).toBe(0)
+    expect(tx.description).toBe('')
+    expect(tx.isOutgoing).toBe(false)
+    expect(tx.rawTx).toBeUndefined()
+    expect(tx.inputBEEF).toBeUndefined()
+    expect(tx.created_at).toBeInstanceOf(Date)
+    expect(tx.updated_at).toBeInstanceOf(Date)
+    expect(tx.created_at.getTime()).toBeLessThanOrEqual(now.getTime())
+    expect(tx.updated_at.getTime()).toBeLessThanOrEqual(now.getTime())
+  })
+
+  // Test: Constructor with provided API object
+  test('1_creates_instance_with_provided_api_object', () => {
+    const now = new Date()
+    const apiObject: TableTransaction = {
+      transactionId: 123,
+      userId: 456,
+      txid: 'testTxid',
+      status: 'completed',
+      reference: 'testReference',
+      satoshis: 789,
+      description: 'testDescription',
+      isOutgoing: true,
+      rawTx: [1, 2, 3],
+      inputBEEF: [4, 5, 6],
+      created_at: now,
+      updated_at: now
+    }
+
+    const tx = new EntityTransaction(apiObject)
+
+    expect(tx.transactionId).toBe(123)
+    expect(tx.userId).toBe(456)
+    expect(tx.txid).toBe('testTxid')
+    expect(tx.status).toBe('completed')
+    expect(tx.reference).toBe('testReference')
+    expect(tx.satoshis).toBe(789)
+    expect(tx.description).toBe('testDescription')
+    expect(tx.isOutgoing).toBe(true)
+    expect(tx.rawTx).toEqual([1, 2, 3])
+    expect(tx.inputBEEF).toEqual([4, 5, 6])
+    expect(tx.created_at).toBe(now)
+    expect(tx.updated_at).toBe(now)
+  })
+
+  // Test: Getters and setters
+  test('2_getters_and_setters_work_correctly', () => {
+    const tx = new EntityTransaction()
+
+    const now = new Date()
+    tx.transactionId = 123
+    tx.userId = 456
+    tx.txid = 'testTxid'
+    tx.status = 'processed' as sdk.TransactionStatus
+    tx.reference = 'testReference'
+    tx.satoshis = 789
+    tx.description = 'testDescription'
+    tx.isOutgoing = true
+    tx.rawTx = [1, 2, 3]
+    tx.inputBEEF = [4, 5, 6]
+    tx.created_at = now
+    tx.updated_at = now
+
+    // New setters
+    tx.version = 2
+    tx.lockTime = 5000
+
+    expect(tx.transactionId).toBe(123)
+    expect(tx.userId).toBe(456)
+    expect(tx.txid).toBe('testTxid')
+    expect(tx.status).toBe('processed')
+    expect(tx.reference).toBe('testReference')
+    expect(tx.satoshis).toBe(789)
+    expect(tx.description).toBe('testDescription')
+    expect(tx.isOutgoing).toBe(true)
+    expect(tx.rawTx).toEqual([1, 2, 3])
+    expect(tx.inputBEEF).toEqual([4, 5, 6])
+    expect(tx.created_at).toBe(now)
+    expect(tx.updated_at).toBe(now)
+
+    // Check new properties
+    expect(tx.version).toBe(2) // Ensure version is set correctly
+    expect(tx.lockTime).toBe(5000) // Ensure lockTime is set correctly
+  })
+
+  // Test: `getBsvTx` returns parsed transaction
+  test('3_getBsvTx_returns_parsed_transaction', () => {
+    const rawTx = Uint8Array.from([1, 2, 3])
+    const tx = new EntityTransaction({
+      rawTx: Array.from(rawTx)
+    } as TableTransaction)
+
+    const bsvTx = tx.getBsvTx()
+    expect(bsvTx).toBeInstanceOf(bsv.Transaction)
+  })
+
+  // Test: `getBsvTx` returns undefined if rawTx is not set
+  test('4_getBsvTx_returns_undefined_if_no_rawTx', () => {
+    const tx = new EntityTransaction()
+    const bsvTx = tx.getBsvTx()
+    expect(bsvTx).toBeUndefined()
+  })
+
+  // Test: `getBsvTxIns` returns parsed inputs
+  test('5_getBsvTxIns_returns_inputs', () => {
+    const rawTx = Uint8Array.from([1, 2, 3])
+    const tx = new EntityTransaction({
+      rawTx: Array.from(rawTx)
+    } as TableTransaction)
+
+    const inputs = tx.getBsvTxIns()
+    expect(inputs).toBeInstanceOf(Array)
+  })
+
+  // Test: getInputs combines spentBy and rawTx inputs
+  test('6_getInputs_combines_spentBy_and_rawTx_inputs', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Insert the transaction into the database
+      const txData = await _tu.insertTestTransaction(activeStorage, undefined, true)
+      const tx = new EntityTransaction(txData.tx)
+
+      // Assign rawTx to simulate transaction inputs
+      const rawTx = Uint8Array.from([1, 2, 3])
+      tx.rawTx = Array.from(rawTx)
+
+      // Insert test outputs with spentBy linked to the transaction
+      const output1 = await _tu.insertTestOutput(activeStorage, tx, 0, 100)
+      await activeStorage.updateOutput(output1.outputId, {
+        spentBy: tx.transactionId
+      })
+
+      const output2 = await _tu.insertTestOutput(activeStorage, tx, 1, 200)
+      await activeStorage.updateOutput(output2.outputId, {
+        spentBy: tx.transactionId
+      })
+
+      // Debugging: Log inserted outputs
+      const outputs = await activeStorage.findOutputs({
+        partial: { spentBy: tx.transactionId }
+      })
+      //console.log('Inserted Outputs:', outputs)
+
+      // Get inputs from the transaction
+      const inputs = await tx.getInputs(activeStorage)
+      //console.log('Transaction Inputs:', inputs)
+
+      // Validate the inputs
+      expect(inputs).toHaveLength(2)
+      expect(inputs).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ vout: 0, satoshis: 100 }),
+          expect.objectContaining({ vout: 1, satoshis: 200 })
+        ])
+      )
+    }
+  })
+
+  // Test: 'mergeExisting' updates when ei updated at is newer
+  /*****************************************************************************************************/
+  // Actually currently fails because mergeExisting is currently setting the date to the current date
+  // rather than the udpated_at from the incoming entity
+  /*****************************************************************************************************/
+  test('9_mergeExisting_updates_when_ei_updated_at_is_newer', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Insert a test transaction into the database
+      const txData = await _tu.insertTestTransaction(activeStorage, undefined, true)
+
+      // Create the `Transaction` instance with an earlier updated_at timestamp
+      const tx = new EntityTransaction({
+        ...txData.tx,
+        updated_at: new Date(2022, 1, 1)
+      })
+
+      // Create an incoming entity object (`ei`) with a newer updated_at timestamp
+      const ei: TableTransaction = {
+        ...txData.tx,
+        updated_at: new Date(2023, 1, 1),
+        txid: 'newTxId'
+      }
+
+      const syncMap = createSyncMap()
+      syncMap.transaction.idMap = { 456: 123 }
+      syncMap.transaction.count = 1
+
+      const expectedMergeUpdatedAt = Math.max(ei.updated_at.getTime(), tx.updated_at.getTime())
+
+      // Execute `mergeExisting`
+      const result = await tx.mergeExisting(activeStorage, new Date(), ei, syncMap)
+
+      // Validate the result and check that the transaction was updated in the database
+      expect(result).toBe(true)
+
+      const updatedTx = await activeStorage.findTransactions({
+        partial: { transactionId: tx.transactionId }
+      })
+
+      expect(updatedTx[0]?.txid).toBe('newTxId')
+      // Currently expecting current time and date, but should be the updated_at from the incoming entity
+      const updatedAtTime = updatedTx[0]?.updated_at.getTime()
+      expect(updatedAtTime).toBe(expectedMergeUpdatedAt)
+    }
+  })
+
+  // Test: getBsvTx handles undefined rawTx
+  test('10_getBsvTx_handles_undefined_rawTx', () => {
+    const tx = new EntityTransaction() // No rawTx provided
+    const bsvTx = tx.getBsvTx()
+    expect(bsvTx).toBeUndefined()
+  })
+
+  // Test: getInputs handles storage lookups and input merging
+  test('11_getInputs_handles_storage_lookups_and_input_merging', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Insert a test transaction into the database
+      const { tx } = await _tu.insertTestTransaction(activeStorage, undefined, true)
+
+      // Create a Transaction instance with the inserted transaction's data
+      const transaction = new EntityTransaction(tx)
+
+      // Insert known inputs into the database and set the `spentBy` column to the transaction ID
+      const input1 = await _tu.insertTestOutput(activeStorage, tx, 0, 100) // vout = 0
+      const input2 = await _tu.insertTestOutput(activeStorage, tx, 2, 200) // vout = 2
+      input1.spentBy = tx.transactionId
+      input2.spentBy = tx.transactionId
+
+      // Update the outputs in the database to reflect `spentBy`
+      await activeStorage.updateOutput(input1.outputId, input1)
+      await activeStorage.updateOutput(input2.outputId, input2)
+
+      // Simulate external input for rawTx parsing
+      const externalInput = await _tu.insertTestOutput(
+        activeStorage,
+        tx, // Reference the same transaction
+        3, // vout = 3
+        150 // Satoshis
+      )
+
+      // Assign rawTx to the transaction and simulate `getBsvTxIns` behavior
+      transaction.rawTx = Array.from(Uint8Array.from([1, 2, 3]))
+      transaction.getBsvTxIns = () => [
+        {
+          sourceTXID: externalInput.txid,
+          sourceOutputIndex: 3
+        } as bsv.TransactionInput
+      ]
+
+      // Call `getInputs` to retrieve and merge inputs
+      const inputs = await transaction.getInputs(activeStorage)
+
+      // Validate the merged inputs
+      expect(inputs).toHaveLength(3) // Known inputs + external input
+      expect(inputs).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ outputId: input1.outputId }),
+          expect.objectContaining({ outputId: input2.outputId }),
+          expect.objectContaining({ txid: externalInput.txid, vout: 3 })
+        ])
+      )
+    }
+  })
+
+  // Test: getProvendTx retrieves proven transaction
+  test('15_getProvenTx_retrieves_proven_transaction', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Insert a test proven transaction into the storage
+      const provenTx = await _tu.insertTestProvenTx(activeStorage)
+
+      // Create a Transaction instance with a valid provenTxId
+      const tx = new EntityTransaction({
+        provenTxId: provenTx.provenTxId
+      } as TableTransaction)
+
+      // Retrieve the ProvenTx using the getProvenTx method
+      const retrievedProvenTx = await tx.getProvenTx(activeStorage)
+
+      // Assert the retrieved ProvenTx is defined and matches the expected values
+      expect(retrievedProvenTx).toBeDefined()
+      expect(retrievedProvenTx?.provenTxId).toBe(provenTx.provenTxId)
+    }
+  })
+
+  // Test: getProvenTx returns undefined when provenTxId is not set
+  test('16_getProvenTx_returns_undefined_when_provenTxId_is_not_set', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Create a Transaction instance with no provenTxId
+      const tx = new EntityTransaction()
+
+      // Attempt to retrieve a ProvenTx
+      const retrievedProvenTx = await tx.getProvenTx(activeStorage)
+
+      // Assert the result is undefined
+      expect(retrievedProvenTx).toBeUndefined()
+    }
+  })
+
+  // Test: getProvenTx returns undefined when no matching ProvenTx is found
+  test('17_getProvenTx_returns_undefined_when_no_matching_ProvenTx_is_found', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Create a Transaction instance with a provenTxId that doesn't exist in storage
+      const tx = new EntityTransaction({ provenTxId: 9999 } as TableTransaction) // Use an ID unlikely to exist
+
+      // Attempt to retrieve a ProvenTx
+      const retrievedProvenTx = await tx.getProvenTx(activeStorage)
+
+      // Assert the result is undefined
+      expect(retrievedProvenTx).toBeUndefined()
+    }
+  })
+
+  // Test: getInputs merges known inputs correctly
+  test('18_getInputs_merges_known_inputs_correctly', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Step 1: Insert a Transaction
+      const { tx } = await _tu.insertTestTransaction(activeStorage, undefined, true)
+
+      // Step 2: Insert outputs associated with the transaction
+      const output1 = await _tu.insertTestOutput(activeStorage, tx, 0, 100) // vout = 0
+      const output2 = await _tu.insertTestOutput(activeStorage, tx, 1, 200) // vout = 1
+
+      // Step 3: Create a Transaction instance with rawTx
+      const rawTx = Uint8Array.from([1, 2, 3]) // Example raw transaction
+      const transaction = new EntityTransaction({
+        ...tx,
+        rawTx: Array.from(rawTx)
+      } as TableTransaction)
+
+      // Step 4: Simulate rawTx inputs
+      transaction.getBsvTxIns = () => [
+        {
+          sourceTXID: output1.txid,
+          sourceOutputIndex: output1.vout
+        } as bsv.TransactionInput,
+        {
+          sourceTXID: output2.txid,
+          sourceOutputIndex: output2.vout
+        } as bsv.TransactionInput
+      ]
+
+      // Step 5: Call `getInputs` to retrieve and merge known inputs
+      const inputs = await transaction.getInputs(activeStorage)
+
+      // Step 6: Assertions
+      expect(inputs).toHaveLength(2) // Ensure both outputs are retrieved
+      expect(inputs).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ outputId: output1.outputId }), // vout = 0
+          expect.objectContaining({ outputId: output2.outputId }) // vout = 1
+        ])
+      )
+    }
+  })
+
+  // Test: getVersion returns API version
+  test('19_get_version_returns_api_version', () => {
+    const tx = new EntityTransaction({ version: 2 } as TableTransaction)
+    expect(tx.version).toBe(2)
+  })
+
+  // Test: getLockTime returns API lockTime
+  test('20_get_lockTime_returns_api_lockTime', () => {
+    const tx = new EntityTransaction({ lockTime: 500 } as TableTransaction)
+    expect(tx.lockTime).toBe(500)
+  })
+
+  // Test: set id updates transactionId
+  test('21_set_id_updates_transactionId', () => {
+    const tx = new EntityTransaction()
+    tx.id = 123
+    expect(tx.transactionId).toBe(123)
+  })
+
+  // Test: get entityName returns correct value
+  test('22_get_entityName_returns_correct_value', () => {
+    const tx = new EntityTransaction()
+    expect(tx.entityName).toBe('transaction')
+  })
+
+  // Test: get entityTable returns correct value
+  test('23_get_entityTable_returns_correct_value', () => {
+    const tx = new EntityTransaction()
+    expect(tx.entityTable).toBe('transactions')
+  })
+
+  // Test: `equals` returns false for mismatched other properties
+  test('25_equals_returns_false_for_mismatched_other_properties', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Insert a test transaction to use as the baseline
+      const txData = await _tu.insertTestTransaction(activeStorage, undefined, true)
+
+      const syncMap = createSyncMap()
+      syncMap.transaction.idMap = {
+        [txData.tx.transactionId]: txData.tx.transactionId
+      }
+      syncMap.transaction.count = 1
+
+      const tx = new EntityTransaction({
+        ...txData.tx, // Base transaction
+        version: 2,
+        lockTime: 500,
+        satoshis: 789,
+        txid: 'txid1',
+        rawTx: [1, 2, 3],
+        inputBEEF: [4, 5, 6],
+        description: 'desc1',
+        status: 'completed',
+        reference: 'ref1'
+      } as TableTransaction)
+
+      const other = {
+        transactionId: txData.tx.transactionId, // Matching transactionId
+        reference: 'ref1', // Matching reference
+        version: 1, // Different version
+        lockTime: 100, // Different lockTime
+        status: 'unprocessed', // Different status
+        satoshis: 100, // Different satoshis
+        description: 'desc2', // Different description
+        txid: 'txid2', // Different txid
+        rawTx: [7, 8, 9], // Different rawTx
+        inputBEEF: [10, 11, 12] // Different inputBEEF
+      } as TableTransaction
+
+      expect(tx.equals(other, syncMap)).toBe(false) // Should return false due to mismatched properties
+    }
+  })
+
+  // Test: `getInputs` handles known and unknown inputs
+  test('26_getInputs_handles_known_and_unknown_inputs', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Step 1: Insert a Transaction into the database
+      const { tx } = await _tu.insertTestTransaction(activeStorage, undefined, true)
+
+      // Step 2: Insert test outputs associated with the transaction
+      const output1 = await _tu.insertTestOutput(activeStorage, tx, 0, 100) // vout = 0, satoshis = 100
+      const output2 = await _tu.insertTestOutput(activeStorage, tx, 1, 200) // vout = 1, satoshis = 200
+
+      // Step 3: Simulate rawTx inputs directly without creating a Transaction instance
+      const rawTxInputs = [
+        { sourceTXID: tx.txid, sourceOutputIndex: 0 },
+        { sourceTXID: tx.txid, sourceOutputIndex: 1 }
+      ]
+
+      // Step 4: Query the inputs from storage individually
+      const inputs = await Promise.all(
+        rawTxInputs.map(input =>
+          activeStorage.findOutputs({
+            partial: {
+              transactionId: tx.transactionId,
+              vout: input.sourceOutputIndex
+            }
+          })
+        )
+      )
+
+      // Flatten the array of inputs (since `findOutputs` likely returns arrays for each query)
+      const flattenedInputs = inputs.flat()
+
+      // Step 5: Assertions
+      expect(flattenedInputs).toHaveLength(2) // Ensure both outputs are retrieved
+      expect(flattenedInputs).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ outputId: output1.outputId }), // vout = 0
+          expect.objectContaining({ outputId: output2.outputId }) // vout = 1
+        ])
+      )
+    }
+  })
+
+  // Test: equals identifies matching entities
+  test('27_equals_identifies_matching_entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert a transaction into the first database
+    const tx1 = new EntityTransaction({
+      transactionId: 405,
+      userId: 1,
+      txid: 'txid1',
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      status: 'completed',
+      reference: 'ref1',
+      isOutgoing: true,
+      satoshis: 789,
+      description: 'desc1',
+      version: 2,
+      lockTime: 500,
+      rawTx: [1, 2, 3],
+      inputBEEF: [4, 5, 6]
+    })
+
+    await ctx1.activeStorage.insertTransaction(tx1.toApi())
+
+    // Insert a matching transaction into the second database
+    const tx2 = new EntityTransaction({
+      transactionId: 405,
+      userId: 1, // Matching userId
+      txid: 'txid1', // Matching txid
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      status: 'completed', // Matching status
+      reference: 'ref1', // Matching reference
+      isOutgoing: true, // Matching isOutgoing
+      satoshis: 789, // Matching satoshis
+      description: 'desc1', // Matching description
+      version: 2, // Matching version
+      lockTime: 500, // Matching lockTime
+      rawTx: [1, 2, 3], // Matching rawTx
+      inputBEEF: [4, 5, 6] // Matching inputBEEF
+    })
+    await ctx2.activeStorage.insertTransaction(tx2.toApi())
+
+    const syncMap = createSyncMap()
+    syncMap.transaction.idMap = { [tx1.transactionId]: tx2.transactionId }
+    syncMap.transaction.count = 1
+
+    // Verify the transactions match
+    expect(tx1.equals(tx2.toApi(), syncMap)).toBe(true)
+  })
+
+  // Test: `equals` identifies non-matching entities
+  test('28_equals_identifies_non_matching_entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert a transaction into the first database
+    const tx1 = new EntityTransaction({
+      transactionId: 303,
+      userId: 1,
+      txid: 'tx456',
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      status: 'unprocessed', // Default status
+      reference: 'ref125',
+      isOutgoing: false, // Default isOutgoing
+      satoshis: 0, // Default satoshis
+      description: '' // Default description
+    })
+    await ctx1.activeStorage.insertTransaction(tx1.toApi())
+
+    // Insert a non-matching transaction into the second database
+    const tx2 = new EntityTransaction({
+      transactionId: 304,
+      userId: 1,
+      txid: 'tx789',
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      status: 'unprocessed', // Default status
+      reference: 'ref126',
+      isOutgoing: false, // Default isOutgoing
+      satoshis: 0, // Default satoshis
+      description: '' // Default description
+    })
+    await ctx2.activeStorage.insertTransaction(tx2.toApi())
+
+    const syncMap = createSyncMap()
+    syncMap.transaction.idMap = { [tx1.transactionId]: tx2.transactionId }
+    syncMap.transaction.count = 1
+
+    // Verify the transactions do not match
+    expect(tx1.equals(tx2.toApi(), syncMap)).toBe(false)
+  })
+})