@bopen-io/wallet-toolbox 1.7.18

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

@@ -0,0 +1,361 @@
+import { EntityTxLabelMap } from '../EntityTxLabelMap'
+import { createSyncMap, sdk, SyncMap, TableTxLabelMap } from '../../../../../src'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+import { EntityTransaction } from '../EntityTransaction'
+import { EntityTxLabel } from '../EntityTxLabel'
+
+describe('TxLabelMap Class Tests', () => {
+  jest.setTimeout(99999999) // Extend timeout for database operations
+
+  const env = _tu.getEnv('test') // Test environment
+  const ctxs: TestWalletNoSetup[] = [] // Context for primary databases
+  const ctxs2: TestWalletNoSetup[] = [] // Context for secondary databases
+
+  beforeAll(async () => {
+    // Set up MySQL and SQLite databases for testing
+    if (env.runMySQL) {
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy('txLabelMapTests_db1'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('txLabelMapTests_db2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('txLabelMapTests_db1'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('txLabelMapTests_db2'))
+  })
+
+  afterAll(async () => {
+    // Clean up primary databases
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+    // Clean up secondary databases
+    for (const ctx of ctxs2) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  // Test: Constructor with default values
+  test('1_creates_instance_with_default_values', () => {
+    const txLabelMap = new EntityTxLabelMap()
+
+    const now = new Date()
+    expect(txLabelMap.transactionId).toBe(0)
+    expect(txLabelMap.txLabelId).toBe(0)
+    expect(txLabelMap.isDeleted).toBe(false)
+    expect(txLabelMap.created_at).toBeInstanceOf(Date)
+    expect(txLabelMap.updated_at).toBeInstanceOf(Date)
+    expect(txLabelMap.created_at.getTime()).toBeLessThanOrEqual(now.getTime())
+    expect(txLabelMap.updated_at.getTime()).toBeLessThanOrEqual(now.getTime())
+  })
+
+  // Test: Constructor with provided API object
+  test('2_creates_instance_with_provided_api_object', () => {
+    const now = new Date()
+    const apiObject: TableTxLabelMap = {
+      transactionId: 123,
+      txLabelId: 456,
+      created_at: now,
+      updated_at: now,
+      isDeleted: true
+    }
+    const txLabelMap = new EntityTxLabelMap(apiObject)
+
+    expect(txLabelMap.transactionId).toBe(123)
+    expect(txLabelMap.txLabelId).toBe(456)
+    expect(txLabelMap.isDeleted).toBe(true)
+    expect(txLabelMap.created_at).toBe(now)
+    expect(txLabelMap.updated_at).toBe(now)
+  })
+
+  // Test: Getters and setters
+  test('3_getters_and_setters_work_correctly', () => {
+    const txLabelMap = new EntityTxLabelMap()
+
+    const now = new Date()
+    txLabelMap.transactionId = 1001
+    txLabelMap.txLabelId = 2002
+    txLabelMap.isDeleted = true
+    txLabelMap.created_at = now
+    txLabelMap.updated_at = now
+
+    expect(txLabelMap.transactionId).toBe(1001)
+    expect(txLabelMap.txLabelId).toBe(2002)
+    expect(txLabelMap.isDeleted).toBe(true)
+    expect(txLabelMap.created_at).toBe(now)
+    expect(txLabelMap.updated_at).toBe(now)
+  })
+
+  // Test: `updateApi` does nothing
+  test('4_updateApi_does_nothing', () => {
+    const txLabelMap = new EntityTxLabelMap()
+    expect(() => txLabelMap.updateApi()).not.toThrow() // Method does nothing, so no errors should occur
+  })
+
+  // Test: `id` getter throws an error
+  test('5_get_id_throws_error', () => {
+    const txLabelMap = new EntityTxLabelMap()
+    expect(() => txLabelMap.id).toThrow(sdk.WERR_INVALID_OPERATION) // Entity has no "id"
+  })
+
+  // Test: Equality check
+  test('6_equals_checks_equality_correctly', () => {
+    const syncMap: any = {
+      transaction: { idMap: { 123: 123 } },
+      txLabel: { idMap: { 456: 456 } }
+    }
+
+    const txLabelMap = new EntityTxLabelMap({
+      transactionId: 123,
+      txLabelId: 456,
+      isDeleted: false,
+      created_at: new Date(),
+      updated_at: new Date()
+    })
+
+    const other = {
+      transactionId: 123, // Use mapped ID from syncMap
+      txLabelId: 456, // Use mapped ID from syncMap
+      isDeleted: false
+    }
+
+    const result = txLabelMap.equals(other as TableTxLabelMap, syncMap)
+    expect(result).toBe(true)
+  })
+
+  // Test: `mergeFind` with storage
+  test('7_mergeFind_finds_or_creates_entity', async () => {
+    const storage: any = {
+      findTxLabelMaps: async () => [{ transactionId: 999, txLabelId: 888 }]
+    }
+    const syncMap: any = {
+      transaction: { idMap: { 123: 999 } },
+      txLabel: { idMap: { 456: 888 } }
+    }
+
+    const ei = {
+      transactionId: 123,
+      txLabelId: 456
+    }
+
+    const result = await EntityTxLabelMap.mergeFind(storage, 1, ei as TableTxLabelMap, syncMap)
+    expect(result.found).toBe(true)
+    expect(result.eo.transactionId).toBe(999)
+    expect(result.eo.txLabelId).toBe(888)
+  })
+
+  // Test: `mergeNew` inserts entity
+  test('8_mergeNew_inserts_entity', async () => {
+    const storage: any = {
+      insertTxLabelMap: jest.fn()
+    }
+    const syncMap: any = {
+      transaction: { idMap: { 123: 999 } },
+      txLabel: { idMap: { 456: 888 } }
+    }
+
+    const txLabelMap = new EntityTxLabelMap({
+      transactionId: 123,
+      txLabelId: 456,
+      created_at: new Date(2022, 1, 1),
+      updated_at: new Date(2022, 1, 1),
+      isDeleted: false
+    })
+
+    await txLabelMap.mergeNew(storage, 1, syncMap)
+    expect(storage.insertTxLabelMap).toHaveBeenCalledWith(
+      expect.objectContaining({
+        transactionId: 999,
+        txLabelId: 888
+      }),
+      undefined
+    )
+  })
+
+  // Test: `mergeExisting` updates entity
+  test('9_mergeExisting_updates_entity', async () => {
+    const storage: any = {
+      updateTxLabelMap: jest.fn()
+    }
+
+    const txLabelMap = new EntityTxLabelMap({
+      transactionId: 123,
+      txLabelId: 456,
+      created_at: new Date(2022, 1, 1),
+      updated_at: new Date(2022, 1, 1),
+      isDeleted: false
+    })
+
+    const ei: TableTxLabelMap = {
+      transactionId: 123,
+      txLabelId: 456,
+      isDeleted: true,
+      created_at: new Date(),
+      updated_at: new Date(2023, 1, 1)
+    }
+
+    const syncMap: any = {
+      transaction: { idMap: { 123: 999 } },
+      txLabel: { idMap: { 456: 888 } }
+    }
+
+    const result = await txLabelMap.mergeExisting(storage, new Date(), ei, syncMap)
+    expect(result).toBe(true)
+    expect(storage.updateTxLabelMap).toHaveBeenCalledWith(
+      123,
+      456,
+      expect.objectContaining({
+        isDeleted: true
+      }),
+      undefined
+    )
+  })
+
+  // Test: `entityName` getter
+  test('10_entityName_returns_correct_value', () => {
+    const txLabelMap = new EntityTxLabelMap()
+    expect(txLabelMap.entityName).toBe('txLabelMap') // Ensure entityName returns the correct string
+  })
+
+  // Test: `entityTable` getter
+  test('11_entityTable_returns_correct_value', () => {
+    const txLabelMap = new EntityTxLabelMap()
+    expect(txLabelMap.entityTable).toBe('tx_labels_map') // Ensure entityTable returns the correct table name
+  })
+
+  test('12_equals_identifies_matching_entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert necessary foreign key references 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 necessary foreign key references into the second database
+    const tx2 = new EntityTransaction({
+      transactionId: 406,
+      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 ctx2.activeStorage.insertTransaction(tx2.toApi())
+
+    // Insert a TxLabel into the first database
+    const txLabel1 = new EntityTxLabel({
+      txLabelId: 306,
+      userId: 1,
+      label: 'Label B',
+      isDeleted: true, // Different isDeleted value
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx1.activeStorage.insertTxLabel(txLabel1.toApi())
+
+    // Insert a matching TxLabel into the second database
+    const txLabel2 = new EntityTxLabel({
+      txLabelId: 307,
+      userId: 1,
+      label: 'Label B',
+      isDeleted: true, // Different isDeleted value
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx2.activeStorage.insertTxLabel(txLabel2.toApi())
+
+    // Insert a TxLabelMap into the first database
+    const txLabelMap1 = new EntityTxLabelMap({
+      transactionId: 405,
+      txLabelId: 306,
+      isDeleted: false,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx1.activeStorage.insertTxLabelMap(txLabelMap1.toApi())
+
+    // Insert a matching TxLabelMap into the second database
+    const txLabelMap2 = new EntityTxLabelMap({
+      transactionId: 406, // Different transaction ID mapped in syncMap
+      txLabelId: 307, // Different label ID mapped in syncMap
+      isDeleted: false,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx2.activeStorage.insertTxLabelMap(txLabelMap2.toApi())
+
+    const syncMap = createSyncMap()
+    syncMap.transaction.idMap = { 406: 405 }
+    syncMap.transaction.count = 1
+    syncMap.txLabel.idMap = { 307: 306 }
+    syncMap.txLabel.count = 1
+
+    // Verify the entities match
+    expect(txLabelMap1.equals(txLabelMap2.toApi(), syncMap)).toBe(true)
+  })
+
+  // Test: equals method identifies non-matching entities
+  test('13_equals_identifies_non_matching_entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert a TxLabelMap into the first database
+    const txLabelMap1 = new EntityTxLabelMap({
+      transactionId: 103,
+      txLabelId: 1,
+      isDeleted: false,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx1.activeStorage.insertTxLabelMap(txLabelMap1.toApi())
+
+    // Insert a non-matching TxLabelMap into the second database
+    const txLabelMap2 = new EntityTxLabelMap({
+      transactionId: 104, // Different transaction ID not mapped in syncMap
+      txLabelId: 1, // Different label ID not mapped in syncMap
+      isDeleted: true, // Different isDeleted value
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx2.activeStorage.insertTxLabelMap(txLabelMap2.toApi())
+
+    const syncMap = createSyncMap()
+    syncMap.transaction.idMap = {
+      [txLabelMap1.transactionId]: txLabelMap2.transactionId
+    }
+    syncMap.transaction.count = 1
+    syncMap.txLabel.idMap = { [txLabelMap1.txLabelId]: txLabelMap2.txLabelId }
+    syncMap.txLabel.count = 1
+
+    // Verify the entities do not match
+    expect(txLabelMap1.equals(txLabelMap2.toApi(), syncMap)).toBe(false)
+  })
+})

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

@@ -0,0 +1,198 @@
+import { EntityTxLabel } from '../EntityTxLabel'
+import { createSyncMap, sdk, SyncMap, TableTxLabel } from '../../../../../src'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+
+describe('TxLabel Class Tests', () => {
+  jest.setTimeout(99999999) // Extend timeout for database operations
+
+  const env = _tu.getEnv('test') // Test environment
+  const ctxs: TestWalletNoSetup[] = [] // Context for primary databases
+  const ctxs2: TestWalletNoSetup[] = [] // Context for secondary databases
+
+  beforeAll(async () => {
+    // Set up MySQL and SQLite databases for testing
+    if (env.runMySQL) {
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy('txLabelTests_db1'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('txLabelTests_db2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('txLabelTests_db1'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('txLabelTests_db2'))
+  })
+
+  afterAll(async () => {
+    // Clean up primary databases
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+    // Clean up secondary databases
+    for (const ctx of ctxs2) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  // Test: Default constructor behavior
+  test('1_creates_txLabel_with_default_values', () => {
+    const txLabel = new EntityTxLabel()
+
+    // Default values
+    expect(txLabel.txLabelId).toBe(0)
+    expect(txLabel.label).toBe('')
+    expect(txLabel.userId).toBe(0)
+    expect(txLabel.isDeleted).toBe(false)
+    expect(txLabel.created_at).toBeInstanceOf(Date)
+    expect(txLabel.updated_at).toBeInstanceOf(Date)
+    expect(txLabel.created_at <= txLabel.updated_at).toBe(true)
+  })
+
+  // Test: Constructor with provided API object
+  test('2_creates_txLabel_with_provided_api_object', () => {
+    const now = new Date()
+    const apiObject: TableTxLabel = {
+      txLabelId: 42,
+      label: 'Test Label',
+      userId: 101,
+      isDeleted: false,
+      created_at: now,
+      updated_at: now
+    }
+    const txLabel = new EntityTxLabel(apiObject)
+
+    // Verify all properties match the API object
+    expect(txLabel.txLabelId).toBe(42)
+    expect(txLabel.label).toBe('Test Label')
+    expect(txLabel.userId).toBe(101)
+    expect(txLabel.isDeleted).toBe(false)
+    expect(txLabel.created_at).toBe(now)
+    expect(txLabel.updated_at).toBe(now)
+  })
+
+  // Test: Getters and setters behavior
+  test('3_getters_and_setters_work_correctly', () => {
+    const txLabel = new EntityTxLabel()
+
+    const now = new Date()
+    txLabel.txLabelId = 1
+    txLabel.label = 'New Label'
+    txLabel.userId = 200
+    txLabel.isDeleted = true
+    txLabel.created_at = now
+    txLabel.updated_at = now
+    txLabel.id = 2
+
+    expect(txLabel.id).toBe(2)
+    expect(txLabel.entityName).toBe('txLabel')
+    expect(txLabel.entityTable).toBe('tx_labels')
+    expect(txLabel.txLabelId).toBe(2)
+    expect(txLabel.label).toBe('New Label')
+    expect(txLabel.userId).toBe(200)
+    expect(txLabel.isDeleted).toBe(true)
+    expect(txLabel.created_at).toBe(now)
+    expect(txLabel.updated_at).toBe(now)
+  })
+
+  // Test: mergeExisting does not update TxLabel when `ei.updated_at` is older
+  test('5_mergeExisting_does_not_update_txLabel_when_ei_updated_at_is_older', async () => {
+    for (const { activeStorage } of ctxs) {
+      const txLabel = new EntityTxLabel({
+        txLabelId: 302,
+        label: 'Original Label',
+        userId: 1,
+        isDeleted: false,
+        created_at: new Date('2023-01-01'),
+        updated_at: new Date('2023-02-01')
+      })
+
+      await activeStorage.insertTxLabel(txLabel.toApi())
+
+      const olderEi: TableTxLabel = {
+        txLabelId: 302,
+        label: 'Outdated Label',
+        userId: 1,
+        isDeleted: true,
+        created_at: new Date('2023-01-01'),
+        updated_at: new Date('2023-01-01')
+      }
+
+      const result = await txLabel.mergeExisting(activeStorage, undefined, olderEi, {} as any)
+
+      const reloadedTxLabel = await activeStorage.findTxLabelById(txLabel.id)
+
+      expect(result).toBe(false)
+      expect(reloadedTxLabel?.label).toBe('Original Label')
+      expect(reloadedTxLabel?.isDeleted).toBe(false)
+      expect(reloadedTxLabel?.updated_at).toEqual(new Date('2023-02-01'))
+    }
+  })
+
+  test('6_equals_identifies_matching_entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert a TxLabel into the first database
+    const txLabel1 = new EntityTxLabel({
+      txLabelId: 303,
+      userId: 1,
+      label: 'Test Label',
+      isDeleted: false,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx1.activeStorage.insertTxLabel(txLabel1.toApi())
+
+    // Insert a matching TxLabel into the second database
+    const txLabel2 = new EntityTxLabel({
+      txLabelId: 304,
+      userId: 1, // Different userId to simulate syncMap usage
+      label: 'Test Label',
+      isDeleted: false,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx2.activeStorage.insertTxLabel(txLabel2.toApi())
+
+    const syncMap = createSyncMap()
+    syncMap.txLabel.idMap = { [txLabel2.userId]: txLabel1.userId }
+    syncMap.txLabel.count = 1
+
+    // Verify the entities match
+    expect(txLabel1.equals(txLabel2.toApi(), syncMap)).toBe(true)
+  })
+
+  test('7_equals_identifies_non_matching_entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert a TxLabel into the first database
+    const txLabel1 = new EntityTxLabel({
+      txLabelId: 305,
+      userId: 1,
+      label: 'Label A',
+      isDeleted: false,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx1.activeStorage.insertTxLabel(txLabel1.toApi())
+
+    // Insert a non-matching TxLabel into the second database
+    const txLabel2 = new EntityTxLabel({
+      txLabelId: 306, // Different txLabelId
+      userId: 1, // Different userId
+      label: 'Label B', // Different label
+      isDeleted: true, // Different isDeleted value
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02')
+    })
+
+    await ctx2.activeStorage.insertTxLabel(txLabel2.toApi())
+
+    const syncMap = createSyncMap()
+    syncMap.txLabel.idMap = { [txLabel2.userId]: txLabel1.userId }
+    syncMap.txLabel.count = 1
+
+    // Verify the entities do not match
+    expect(txLabel1.equals(txLabel2.toApi(), syncMap)).toBe(false)
+  })
+})

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

@@ -0,0 +1,90 @@
+import { stampLog, stampLogFormat } from '../../../../../src/utility/stampLog'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+
+describe('stampLog and stampLogFormat Tests', () => {
+  jest.setTimeout(99999999)
+
+  const ctxs: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    // Set up test contexts for MySQL and SQLite
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('stampLogTests'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  // Test: Appending to string logs
+  test('0_appends_to_string_log', async () => {
+    for (const { wallet } of ctxs) {
+      const initialLog = '2025-01-10T10:00:00.000Z Event 1\n'
+      const lineToAdd = 'Event 2'
+      const updatedLog = stampLog(initialLog, lineToAdd)
+      expect(updatedLog).toContain('Event 2')
+      expect(updatedLog).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z Event 2\n$/)
+    }
+  })
+
+  // Test: Appending to object logs
+  test('1_appends_to_object_log', async () => {
+    for (const { wallet } of ctxs) {
+      const initialLog = { log: '2025-01-10T10:00:00.000Z Event 1\n' }
+      const lineToAdd = 'Event 2'
+      const updatedLog = stampLog(initialLog, lineToAdd)
+      expect(updatedLog).toContain('Event 2')
+      expect(updatedLog).toMatch(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z Event 2\n$/)
+    }
+  })
+
+  // Test: Returns undefined for invalid input
+  test('2_returns_undefined_for_invalid_input', async () => {
+    for (const { wallet } of ctxs) {
+      const updatedLog = stampLog(undefined, 'Event 1')
+      expect(updatedLog).toBeUndefined()
+    }
+  })
+
+  // Test: Formatting valid log without **NETWORK**
+  test('3_formats_valid_log_without_network', async () => {
+    for (const { wallet } of ctxs) {
+      const log = `2025-01-10T10:00:00.000Z Event 1\n2025-01-10T10:00:01.000Z Event 2\n2025-01-10T10:00:03.000Z Event 3`
+      const output = stampLogFormat(log)
+      expect(output).toContain('Total = 3000 msecs')
+      expect(output).toContain(' 1000 Event 2')
+      expect(output).toContain(' 2000 Event 3')
+    }
+  })
+
+  // Test: Formatting valid log with **NETWORK** entries
+  test('4_formats_log_with_network_entries', async () => {
+    for (const { wallet } of ctxs) {
+      const log = `2025-01-10T10:00:00.000Z Event 1\n2025-01-10T10:00:01.000Z **NETWORK**\n2025-01-10T10:00:02.000Z Event 2\n2025-01-10T10:00:03.000Z **NETWORK**\n2025-01-10T10:00:05.000Z Event 3`
+      const output = stampLogFormat(log)
+      expect(output).toContain('Total = 5000 msecs')
+      expect(output).toContain(' 1000 **NETWORK**')
+      expect(output).toContain(' 2000 Event 3')
+    }
+  })
+
+  // Test: Handles improperly formatted log entries
+  test('5_handles_invalid_log_entries_gracefully', async () => {
+    for (const { wallet } of ctxs) {
+      const log = `Invalid Timestamp Event 1\n2025-01-10T10:00:01.000Z Event 2`
+
+      // Expect the function to throw a RangeError due to invalid timestamp
+      expect(() => stampLogFormat(log)).toThrow(RangeError)
+    }
+  })
+
+  // Test: Handles non-string input
+  test('6_handles_non-string_log_gracefully', () => {
+    const nonStringInputs = [undefined, null, 123, {}, [], true] // Different non-string values
+    for (const input of nonStringInputs) {
+      const result = stampLogFormat(input as unknown as string)
+      expect(result).toBe('') // Should return an empty string for non-string inputs
+    }
+  })
+})