Größe eines Objektes in Byte berechnen

[Encera]

Hallo zusammen,
ich hab mal wieder eine Frage und zwar geht es mir um folgendes:
Mir geht es darum die Größe einer eines Objektes in bytes zu berechnen.

Laut Buch müsste eine Transaktion (mein Objekt) eine Größe von 242 bytes haben zuzüglich maximal 72 bytes für die Kryptografische Signatur welche angehängt wird, also insgesamt um die 314 bytes.
Nur leider kann ich überhauptnicht nachvollziehen wie diese Größe zustandekommen soll.
Hier mal die Attribute der Transaktionsklasse:

private transient byte[] txId;
    private byte[] sender;
    private byte[] receiver;
    private double amount;
    private int nonce;
    private transient long receivedTimeStamp;
    private transient byte[] blockId;
    private double transactionFeeBasePrice;
    private double transactionFeeLimit;
    private transient double transactionFee;
    private transient int sizeInByte;
    private byte[] signature;

Die Adressen des Sender und Empfängers haben je 130 Zeichen und der Blockhash 64.

Die Transaktion selbst wird mittels JSON an die anderen Teilnehmer des Netzwerks verschickt. Ich hab mir testweise die Größe mal anhand vom serialisieren berechnen lassen nur komme ich da auf 514 bzw. 699 für die Adapter-Klasse (Die Adapter Klasse wird verwendet um eine Transaktion intern zu übertragen, da in der „originalen“ Transaction Klasse einige Attribute für die WebApi mittels JSON Ignore ausgeblendet wurden welche aber intern gebraucht werden. Der Adapter kapselt quasi eine Trx samt ihren Attributen. Ist aber e nicht so relevant da die Größe ja bei beiden bei weitem nicht stimmt xD)

private byte[] transactionToJSON( Transaction transaction )
    {
        byte[] serializedTransaction = genson.serializeBytes(transaction);
        System.out.println(serializedTransaction);
        System.out.println(serializedTransaction.length);
        
        byte[] serializedTA = genson.serializeBytes(new TransactionAdapter(transaction));
        System.out.println(serializedTA);
        System.out.println(serializedTA.length);
        System.out.println(serializedTA.toString());
        
        return genson.serializeBytes( new TransactionAdapter( transaction ) );
    }

Im Buch selbst wird nur folgendermaßen darauf eingegangen:

IMG-20221117-123900-edit-8611984639310

Image IMG-20221117-123900-edit-8611984639310 hosted in ImgBB

ibb.co

Die ursprüngliche Transaktionsgröße aus Abschnitt 4.3 von der die Rede ist war 128.

Villeicht kommt von euch ja wer drauf wie diese 242 bzw. 314 zustande kommen sollen und ob „meine“ Methode zur Berechnung generell falsch ist oder das einfach ein Fehler im Buch ist?

Beste Grüße~

 

[mihe7]

Ich kenne mich mit Blockchains nicht aus und auch das Buch ist mir fremd aber ich gehe mal davon aus, dass die Daten binär definiert sind. Eine textuelle Darstellung hat somit eine völlig andere Größe.

Der "Block Hash" könnte z. B. nur 32 Bytes (SHA-256 -> 256 Bit) groß sein. Stellt man die Bytes textuell als Hexadezimalzahlen dar, erhält man 64 Zeichen. Wenn für ein int-Feld 4 Bytes vorgesehen werden, käme die textuelle Darstellung mit weniger als 4 Byte aus, wenn der Wert zwischen 0 und 999 (incl.) liegt und ab 10000 hätte man dagegen schon 5 Bytes.

 

[Encera]

Ich kenne mich mit Blockchains nicht aus und auch das Buch ist mir fremd aber ich gehe mal davon aus, dass die Daten binär definiert sind. Eine textuelle Darstellung hat somit eine völlig andere Größe.

Der "Block Hash" könnte z. B. nur 32 Bytes (SHA-256 -> 256 Bit) groß sein. Stellt man die Bytes textuell als Hexadezimalzahlen dar, erhält man 64 Zeichen. Wenn für ein int-Feld 4 Bytes vorgesehen werden, käme die textuelle Darstellung mit weniger als 4 Byte aus, wenn der Wert zwischen 0 und 999 (incl.) liegt und ab 10000 hätte man dagegen schon 5 Bytes.

Wenn ich das ganze so durchrechne komme ich auf 226 bytes, das ist zumindest schonmal um einiges näher dran👍😅