fix: voided token addr balance

packages/daemon/__tests__/db/index.test.ts

@@ -1225,7 +1225,7 @@ describe('voidTransaction', () => {
     };
 
     await voidTransaction(mysql, txId);
-    await voidAddressTransaction(mysql, txId, addressBalance);
+    await voidAddressTransaction(mysql, txId, addressBalance, 1);
 
     await expect(checkAddressBalanceTable(mysql, 2, addr1, token2, 1n, 0n, null, 3)).resolves.toBe(true);
     await expect(checkAddressBalanceTable(mysql, 2, addr1, token1, 1n, 0n, null, 4)).resolves.toBe(true);

packages/daemon/__tests__/integration/balances.test.ts

@@ -29,6 +29,8 @@ import customScriptBalances from './scenario_configs/custom_script.balances';
 import ncEventsBalances from './scenario_configs/nc_events.balances';
 import transactionVoidingChainBalances from './scenario_configs/transaction_voiding_chain.balances';
 import voidedTokenAuthorityBalances from './scenario_configs/voided_token_authority.balances';
+import singleVoidedCreateTokenTransactionBalances from './scenario_configs/single_voided_create_token_transaction.balances';
+import singleVoidedRegularTransactionBalances from './scenario_configs/single_voided_regular_transaction.balances';
 
 import {
   DB_NAME,
@@ -54,6 +56,10 @@ import {
   TRANSACTION_VOIDING_CHAIN_LAST_EVENT,
   VOIDED_TOKEN_AUTHORITY_PORT,
   VOIDED_TOKEN_AUTHORITY_LAST_EVENT,
+  SINGLE_VOIDED_CREATE_TOKEN_TRANSACTION_PORT,
+  SINGLE_VOIDED_CREATE_TOKEN_TRANSACTION_LAST_EVENT,
+  SINGLE_VOIDED_REGULAR_TRANSACTION_PORT,
+  SINGLE_VOIDED_REGULAR_TRANSACTION_LAST_EVENT,
 } from './config';
 
 jest.mock('../../src/config', () => {
@@ -207,7 +213,7 @@ describe('single chain blocks and transactions scenario', () => {
     });
 
     const machine = interpret(SyncMachine);
-    
+
     // @ts-expect-error
     await transitionUntilEvent(mysql, machine, SINGLE_CHAIN_BLOCKS_AND_TRANSACTIONS_LAST_EVENT);
     const addressBalances = await fetchAddressBalances(mysql);
@@ -384,7 +390,6 @@ describe('transaction voiding chain scenario', () => {
     });
 
     const machine = interpret(SyncMachine);
-
     // @ts-ignore
     await transitionUntilEvent(mysql, machine, TRANSACTION_VOIDING_CHAIN_LAST_EVENT);
     const addressBalances = await fetchAddressBalances(mysql);
@@ -527,3 +532,338 @@ describe('voided token authority scenario', () => {
     validateVoidingConsistency(voidingChecks);
   }, 30000); // 30 second timeout for voided token authority test
 });
+
+describe('single voided create token transaction scenario', () => {
+  const initializeWallet = async (mysql: Connection): Promise<void> => {
+    // Insert wallet records
+    const walletSQL = `
+      INSERT INTO wallet (
+          id,
+          xpubkey,
+          status,
+          max_gap,
+          created_at,
+          ready_at,
+          retry_count,
+          auth_xpubkey,
+          last_used_address_index
+      ) VALUES
+      (
+          'test-wallet-voided-token',
+          'xpub6F81iNtH5HVknoJ65cK2XAGA5F3okdJK7WHwVAAPZnSir2sfwbhvB9ffNKQ4wLor75QxPe9p12tqt8xUZSG8i8AAPMpkFho7fbWkBJQ5s1x',
+          'ready',
+          20,
+          UNIX_TIMESTAMP(),
+          UNIX_TIMESTAMP(),
+          0,
+          'xpub6F81iNtH5HVknoJ65cK2XAGA5F3okdJK7WHwVAAPZnSir2sfwbhvB9ffNKQ4wLor75QxPe9p12tqt8xUZSG8i8AAPMpkFho7fbWkBJQ5s1x',
+          -1
+      )`;
+
+    // Insert address records that will receive the voided token
+    const addressSQL = `
+      INSERT INTO address (address, \`index\`, wallet_id, transactions, seqnum) VALUES
+      ('HRQe4CXj8AZXzSmuNztU8iQR74QTQMbnTs', 0, 'test-wallet-voided-token', 0, 0)`;
+
+    await mysql.query(walletSQL);
+    await mysql.query(addressSQL);
+  };
+
+  beforeAll(async () => {
+    jest.spyOn(Services, 'fetchMinRewardBlocks').mockImplementation(async () => 300);
+    await cleanDatabase(mysql);
+  });
+
+  it('should do a full sync and the balances should match', async () => {
+    // @ts-expect-error
+    getConfig.mockReturnValue({
+      NETWORK: 'testnet',
+      SERVICE_NAME: 'daemon-test',
+      CONSOLE_LEVEL: 'debug',
+      TX_CACHE_SIZE: 100,
+      BLOCK_REWARD_LOCK: 300,
+      FULLNODE_PEER_ID: 'simulator_peer_id',
+      STREAM_ID: 'simulator_stream_id',
+      FULLNODE_NETWORK: 'unittests',
+      FULLNODE_HOST: `127.0.0.1:${SINGLE_VOIDED_CREATE_TOKEN_TRANSACTION_PORT}`,
+      USE_SSL: false,
+      DB_ENDPOINT,
+      DB_NAME,
+      DB_USER,
+      DB_PASS,
+      DB_PORT,
+    });
+
+    const machine = interpret(SyncMachine);
+
+    // @ts-expect-error
+    await transitionUntilEvent(mysql, machine, SINGLE_VOIDED_CREATE_TOKEN_TRANSACTION_LAST_EVENT);
+    const addressBalances = await fetchAddressBalances(mysql);
+    await expect(validateBalances(addressBalances, singleVoidedCreateTokenTransactionBalances.addressBalances)).resolves.not.toThrow();
+  }, 30000);
+
+  it('addresses_balance and address_tx_history row length must match after a void transaction scenario', async () => {
+    // @ts-expect-error
+    getConfig.mockReturnValue({
+      NETWORK: 'testnet',
+      SERVICE_NAME: 'daemon-test',
+      CONSOLE_LEVEL: 'debug',
+      TX_CACHE_SIZE: 100,
+      BLOCK_REWARD_LOCK: 300,
+      FULLNODE_PEER_ID: 'simulator_peer_id',
+      STREAM_ID: 'simulator_stream_id',
+      FULLNODE_NETWORK: 'unittests',
+      FULLNODE_HOST: `127.0.0.1:${SINGLE_VOIDED_CREATE_TOKEN_TRANSACTION_PORT}`,
+      USE_SSL: false,
+      DB_ENDPOINT,
+      DB_NAME,
+      DB_USER,
+      DB_PASS,
+      DB_PORT,
+    });
+
+    // Initialize wallet before processing events
+    await initializeWallet(mysql);
+
+    const machine = interpret(SyncMachine);
+
+    // @ts-expect-error
+    await transitionUntilEvent(mysql, machine, SINGLE_VOIDED_CREATE_TOKEN_TRANSACTION_LAST_EVENT);
+
+    const voidedTokenId = 'efb08b3e79e0ddaa6bc288183f66fe49a07ba0b7b2595861000478cc56447539';
+
+    // Check for addresses that have balances for a specific token
+    const addressBalanceResults = await mysql.query(`
+      SELECT token_id,
+             SUM(total_received) AS total_received,
+             SUM(unlocked_balance) AS unlocked_balance,
+             SUM(locked_balance) AS locked_balance,
+             MIN(timelock_expires) AS timelock_expires,
+             BIT_OR(unlocked_authorities) AS unlocked_authorities,
+             BIT_OR(locked_authorities) AS locked_authorities
+        FROM address_balance
+       WHERE token_id = ?
+    GROUP BY token_id
+    ORDER BY token_id
+    `, [voidedTokenId]);
+
+    // Check for transaction history for the same tokens (excluding voided)
+    const txHistoryResults = await mysql.query(`
+      SELECT token_id,
+             SUM(balance) AS balance,
+             COUNT(DISTINCT tx_id) AS transactions
+        FROM address_tx_history
+       WHERE voided = FALSE
+         AND token_id = ?
+    GROUP BY token_id
+    ORDER BY token_id
+    `, [voidedTokenId]);
+
+    // Cast to array to access length property
+    const addressRows = addressBalanceResults[0] as any[];
+    const txHistoryRows = txHistoryResults[0] as any[];
+
+    expect(addressRows.length).toEqual(txHistoryRows.length);
+
+    // Verify that the voided token was removed from the token table
+    const tokenResults = await mysql.query(
+      'SELECT * FROM token WHERE id = ?',
+      [voidedTokenId]
+    );
+
+    // Token should not exist in the database after being voided
+    expect(tokenResults[0]).toHaveLength(0);
+
+    // Verify that the wallet_balance table doesn't contain the voided token
+    const walletBalanceResults = await mysql.query(
+      'SELECT * FROM wallet_balance WHERE token_id = ?',
+      [voidedTokenId]
+    );
+
+    // Wallet balance should not exist for the voided token
+    expect(walletBalanceResults[0]).toHaveLength(0);
+  }, 30000);
+});
+
+describe('single voided regular transaction scenario', () => {
+  const initializeWallet = async (mysql: Connection): Promise<void> => {
+    // Insert wallet records
+    const walletSQL = `
+      INSERT INTO wallet (
+          id,
+          xpubkey,
+          status,
+          max_gap,
+          created_at,
+          ready_at,
+          retry_count,
+          auth_xpubkey,
+          last_used_address_index
+      ) VALUES
+      (
+          'test-wallet-voided-regular',
+          'xpub6F81iNtH5HVknoJ65cK2XAGA5F3okdJK7WHwVAAPZnSir2sfwbhvB9ffNKQ4wLor75QxPe9p12tqt8xUZSG8i8AAPMpkFho7fbWkBJQ5s1x',
+          'ready',
+          20,
+          UNIX_TIMESTAMP(),
+          UNIX_TIMESTAMP(),
+          0,
+          'xpub6F81iNtH5HVknoJ65cK2XAGA5F3okdJK7WHwVAAPZnSir2sfwbhvB9ffNKQ4wLor75QxPe9p12tqt8xUZSG8i8AAPMpkFho7fbWkBJQ5s1x',
+          -1
+      )`;
+
+    // Insert address record for the voided transaction address
+    const addressSQL = `
+      INSERT INTO address (address, \`index\`, wallet_id, transactions, seqnum) VALUES
+      ('HFtz2f59Lms4p3Jfgtsr73s97MbJHsRENh', 0, 'test-wallet-voided-regular', 0, 0)`;
+
+    await mysql.query(walletSQL);
+    await mysql.query(addressSQL);
+  };
+
+  beforeAll(async () => {
+    jest.spyOn(Services, 'fetchMinRewardBlocks').mockImplementation(async () => 300);
+    await cleanDatabase(mysql);
+  });
+
+  it('should do a full sync and the balances should match', async () => {
+    // @ts-expect-error
+    getConfig.mockReturnValue({
+      NETWORK: 'testnet',
+      SERVICE_NAME: 'daemon-test',
+      CONSOLE_LEVEL: 'debug',
+      TX_CACHE_SIZE: 100,
+      BLOCK_REWARD_LOCK: 300,
+      FULLNODE_PEER_ID: 'simulator_peer_id',
+      STREAM_ID: 'simulator_stream_id',
+      FULLNODE_NETWORK: 'unittests',
+      FULLNODE_HOST: `127.0.0.1:${SINGLE_VOIDED_REGULAR_TRANSACTION_PORT}`,
+      USE_SSL: false,
+      DB_ENDPOINT,
+      DB_NAME,
+      DB_USER,
+      DB_PASS,
+      DB_PORT,
+    });
+
+    const machine = interpret(SyncMachine);
+
+    // @ts-expect-error
+    await transitionUntilEvent(mysql, machine, SINGLE_VOIDED_REGULAR_TRANSACTION_LAST_EVENT);
+    const addressBalances = await fetchAddressBalances(mysql);
+    await expect(validateBalances(addressBalances, singleVoidedRegularTransactionBalances.addressBalances)).resolves.not.toThrow();
+  }, 30000);
+
+  it('addresses_balance and address_tx_history row length must match after a void transaction scenario', async () => {
+    // @ts-expect-error
+    getConfig.mockReturnValue({
+      NETWORK: 'testnet',
+      SERVICE_NAME: 'daemon-test',
+      CONSOLE_LEVEL: 'debug',
+      TX_CACHE_SIZE: 100,
+      BLOCK_REWARD_LOCK: 300,
+      FULLNODE_PEER_ID: 'simulator_peer_id',
+      STREAM_ID: 'simulator_stream_id',
+      FULLNODE_NETWORK: 'unittests',
+      FULLNODE_HOST: `127.0.0.1:${SINGLE_VOIDED_REGULAR_TRANSACTION_PORT}`,
+      USE_SSL: false,
+      DB_ENDPOINT,
+      DB_NAME,
+      DB_USER,
+      DB_PASS,
+      DB_PORT,
+    });
+
+    const machine = interpret(SyncMachine);
+
+    // @ts-expect-error
+    await transitionUntilEvent(mysql, machine, SINGLE_VOIDED_REGULAR_TRANSACTION_LAST_EVENT);
+
+    const voidedAddress = 'HFtz2f59Lms4p3Jfgtsr73s97MbJHsRENh';
+
+    // Check for address balances for the specific address
+    const addressBalanceResults = await mysql.query(`
+      SELECT address,
+             COUNT(*) AS balance_rows
+        FROM address_balance
+       WHERE address = ?
+    GROUP BY address
+    ORDER BY address
+    `, [voidedAddress]);
+
+    // Check for transaction history for the same address (excluding voided)
+    const txHistoryResults = await mysql.query(`
+      SELECT address,
+             COUNT(*) AS history_rows
+        FROM address_tx_history
+       WHERE voided = FALSE
+         AND address = ?
+    GROUP BY address
+    ORDER BY address
+    `, [voidedAddress]);
+
+    // Cast to array to access length property
+    const addressRows = addressBalanceResults[0] as any[];
+    const txHistoryRows = txHistoryResults[0] as any[];
+
+    expect(addressRows.length).toEqual(txHistoryRows.length);
+  }, 30000);
+
+  it('wallet_balance and wallet_tx_history row length must match after a void transaction scenario', async () => {
+    // @ts-expect-error
+    getConfig.mockReturnValue({
+      NETWORK: 'testnet',
+      SERVICE_NAME: 'daemon-test',
+      CONSOLE_LEVEL: 'debug',
+      TX_CACHE_SIZE: 100,
+      BLOCK_REWARD_LOCK: 300,
+      FULLNODE_PEER_ID: 'simulator_peer_id',
+      STREAM_ID: 'simulator_stream_id',
+      FULLNODE_NETWORK: 'unittests',
+      FULLNODE_HOST: `127.0.0.1:${SINGLE_VOIDED_REGULAR_TRANSACTION_PORT}`,
+      USE_SSL: false,
+      DB_ENDPOINT,
+      DB_NAME,
+      DB_USER,
+      DB_PASS,
+      DB_PORT,
+    });
+
+    // Initialize wallet before processing events
+    await initializeWallet(mysql);
+
+    const machine = interpret(SyncMachine);
+
+    // @ts-expect-error
+    await transitionUntilEvent(mysql, machine, SINGLE_VOIDED_REGULAR_TRANSACTION_LAST_EVENT);
+
+    const walletId = 'test-wallet-voided-regular';
+
+    // Check for wallet balances for the specific wallet
+    const walletBalanceResults = await mysql.query(`
+      SELECT wallet_id,
+             COUNT(*) AS balance_rows
+        FROM wallet_balance
+       WHERE wallet_id = ?
+    GROUP BY wallet_id
+    ORDER BY wallet_id
+    `, [walletId]);
+
+    // Check for wallet transaction history for the same wallet (excluding voided)
+    const walletTxHistoryResults = await mysql.query(`
+      SELECT wallet_id,
+             COUNT(*) AS history_rows
+        FROM wallet_tx_history
+       WHERE voided = FALSE
+         AND wallet_id = ?
+    GROUP BY wallet_id
+    ORDER BY wallet_id
+    `, [walletId]);
+
+    // Cast to array to access length property
+    const walletBalanceRows = walletBalanceResults[0] as any[];
+    const walletTxHistoryRows = walletTxHistoryResults[0] as any[];
+
+    expect(walletBalanceRows.length).toEqual(walletTxHistoryRows.length);
+  }, 30000);
+});