The transaction historical past made to the deal with through the Electrum Testnet pockets shouldn’t be displayed

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

I made a variety of transfers to the deal with 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 deal with that’s linked to mywallet.

I even have a connection to the take a look at community.

Within the pockets, as proven, the whole lot is there, the whole lot is ok, however while you attempt to examine the knowledge of my deal with, there’s nothing there.

Right here I checked the deal with by a particular web site.

I wrote a small program to examine the historical past of the deal with, steadiness, however nothing is displayed there.

Connecting to Electrum server...
Efficiently related to Electrum server.
Handle: tb1qc7j5j80s02gupl0qa3svg5kr99smjdq9a7yezd
ScriptHash: bb72dcabbea723d56aa49cd29575e53aaabf832f9dbdb45f251b56e187ce915a
Uncooked historical past response: []
Fetching transaction historical past...
Discovered 0 transactions.
Complete steadiness for tb1qc7j5j80s02gupl0qa3svg5kr99smjdq9a7yezd: 0 satoshis (0 BTC)
Present block peak: 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;

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

async operate debugScripthashHistory(consumer: ElectrumClient<ElectrumClientEvents>, scriptHash: string) {
  attempt {
    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 operate checkAddress() {
  const consumer = new ElectrumClient(
    'Handle Checker',
    '1.4.1',
    ELECTRUM_HOST,
  );

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

    const scriptHash = addressToElectrumScriptHash(ADDRESS, NETWORK);
    if (!scriptHash) {
      console.error('Didn't generate scripthash for deal with.');
      return;
    }
    console.log(`Handle: ${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('Surprising historical past response:', historyResult);
      return;
    }

    const historical past = historyResult as { tx_hash: string; peak: 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 peak: ${tx.peak})`);

      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.deal with.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 deal with: ${quantity} satoshis`);
        }
      }
    }

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

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

  } catch (error) {
    console.error('Error throughout deal with examine:', error.message);
  } lastly {
    attempt {
      await consumer.disconnect();
      console.log('Disconnected from Electrum server.');
    } catch (e) {
      console.error('Error throughout disconnection:', e.message);
    }
  }
}

checkAddress().catch(console.error);