The transaction historical past made to the tackle by way of the Electrum Testnet pockets will not be displayed

I’m new to this enterprise, so I apologize for such a presumably primary and silly query, I attempted to search out any info, however I could not.

I made numerous transfers to the tackle proven within the following instance.

I even have these transfers in my historical past, and they’re marked as profitable. For reference, I made a switch from my pockets to the tackle that’s linked to mywallet.

I even have a connection to the check community.

Within the pockets, as proven, all the pieces is there, all the pieces is okay, however while you attempt to verify the knowledge of my tackle, there’s nothing there.

Right here I checked the tackle by means of a particular website.

I wrote a small program to verify the historical past of the tackle, steadiness, however nothing is displayed there.

Connecting to Electrum server...
Efficiently linked to Electrum server.
Deal with: tb1qc7j5j80s02gupl0qa3svg5kr99smjdq9a7yezd
ScriptHash: bb72dcabbea723d56aa49cd29575e53aaabf832f9dbdb45f251b56e187ce915a
Uncooked historical past response: []
Fetching transaction historical past...
Discovered 0 transactions.
Whole steadiness for tb1qc7j5j80s02gupl0qa3svg5kr99smjdq9a7yezd: 0 satoshis (0 BTC)
Present block top: 900621
Disconnected from Electrum server.

Right here is the code of this system itself:

import * as bitcoin from 'bitcoinjs-lib';
import { ElectrumClient, ElectrumClientEvents } from '@electrum-cash/community';

const ELECTRUM_HOST = 'blackie.c3-soft.com';
const ADDRESS = 'tb1qc7j5j80s02gupl0qa3svg5kr99smjdq9a7yezd';
const NETWORK = bitcoin.networks.testnet;

perform addressToElectrumScriptHash(tackle: string, community: bitcoin.Community): string | null {
  strive {
    const outputScript = bitcoin.tackle.toOutputScript(tackle, community);
    const hash = bitcoin.crypto.sha256(outputScript);
    return Buffer.from(hash.reverse()).toString('hex');
  } catch (e) {
    console.error(`Didn't convert tackle ${tackle} to scripthash: ${e.message}`);
    return null;
  }
}

async perform debugScripthashHistory(consumer: ElectrumClient<ElectrumClientEvents>, scriptHash: string) {
  strive {
    const historical past = await consumer.request('blockchain.scripthash.get_history', scriptHash);
    console.log('Uncooked historical past response:', JSON.stringify(historical past, null, 2));
  } catch (error) {
    console.error('Error fetching uncooked historical past:', error.message);
  }
}

async perform checkAddress() {
  const consumer = new ElectrumClient(
    'Deal with Checker',
    '1.4.1',
    ELECTRUM_HOST,
  );

  strive {
    console.log('Connecting to Electrum server...');
    await consumer.join();
    console.log('Efficiently linked to Electrum server.');

    const scriptHash = addressToElectrumScriptHash(ADDRESS, NETWORK);
    if (!scriptHash) {
      console.error('Didn't generate scripthash for tackle.');
      return;
    }
    console.log(`Deal with: ${ADDRESS}`);
    console.log(`ScriptHash: ${scriptHash}`);
    await debugScripthashHistory(consumer, scriptHash);

    console.log('Fetching transaction historical past...');
    const historyResult = await consumer.request('blockchain.scripthash.get_history', scriptHash);
    if (historyResult instanceof Error) {
      console.error(`Error fetching historical past: ${historyResult.message}`);
      return;
    }
    if (!Array.isArray(historyResult)) {
      console.error('Sudden historical past response:', historyResult);
      return;
    }

    const historical past = historyResult as { tx_hash: string; top: quantity }[];
    console.log(`Discovered ${historical past.size} transactions.`);

    let totalBalance = 0;
    for (const tx of historical past) {
      const txHash = tx.tx_hash;
      console.log(`Processing transaction: ${txHash} (Block top: ${tx.top})`);

      const txDataResult = await consumer.request('blockchain.transaction.get', txHash, true);
      if (txDataResult instanceof Error) {
        console.error(`Error fetching transaction ${txHash}: ${txDataResult.message}`);
        proceed;
      }
      if (!txDataResult || typeof txDataResult !== 'object') {
        console.error(`Invalid transaction knowledge for ${txHash}`);
        proceed;
      }

      const txData = txDataResult as { vout: { worth: string; scriptPubKey: { hex: string } }[] };
      const outputScriptHex = bitcoin.tackle.toOutputScript(ADDRESS, NETWORK).toString('hex');

      for (const vout of txData.vout) {
        if (vout.scriptPubKey.hex === outputScriptHex) {
          const quantity = Math.spherical(parseFloat(vout.worth) * 1e8); // Конвертация BTC в сатоши
          totalBalance += quantity;
          console.log(`Discovered output to handle: ${quantity} satoshis`);
        }
      }
    }

    console.log(`Whole steadiness for ${ADDRESS}: ${totalBalance} satoshis (${totalBalance / 1e8} BTC)`);

    const blockHeightResponse = await consumer.request('blockchain.headers.subscribe');
    if (blockHeightResponse && typeof blockHeightResponse === 'object' && 'top' in blockHeightResponse) {
      console.log(`Present block top: ${blockHeightResponse.top}`);
    }

  } catch (error) {
    console.error('Error throughout tackle verify:', error.message);
  } lastly {
    strive {
      await consumer.disconnect();
      console.log('Disconnected from Electrum server.');
    } catch (e) {
      console.error('Error throughout disconnection:', e.message);
    }
  }
}

checkAddress().catch(console.error);