refactor Transaction.createTransactionHash and add unit test for networkType switch

Author: Greg S

src/model/transaction/Transaction.ts

@@ -33,6 +33,13 @@ import { TransactionType } from './TransactionType';
  */
 export abstract class Transaction {
 
+    /**
+     * Transaction header size
+     *
+     * @var {number}
+     */
+    public static readonly Header_Size = 8 + 64 + 32 + 4;
+
     /**
      * @constructor
      * @param type
@@ -81,29 +88,54 @@ export abstract class Transaction {
 
     /**
      * Generate transaction hash hex
+     *
+     * @see https://github.com/nemtech/catapult-server/blob/master/src/catapult/model/EntityHasher.cpp#L32
+     * @see https://github.com/nemtech/catapult-server/blob/master/src/catapult/model/EntityHasher.cpp#L35
+     * @see https://github.com/nemtech/catapult-server/blob/master/sdk/src/extensions/TransactionExtensions.cpp#L46
      * @param {string} transactionPayload HexString Payload
      * @param {Array<number>} generationHashBuffer Network generation hash byte
      * @param {NetworkType} networkType Catapult network identifier
      * @returns {string} Returns Transaction Payload hash
      */
     public static createTransactionHash(transactionPayload: string, generationHashBuffer: number[], networkType: NetworkType): string {
-        const type = parseInt(Convert.uint8ToHex(Convert.hexToUint8(transactionPayload.substring(220, 224)).reverse()), 16);
-        const byteBuffer = Array.from(Convert.hexToUint8(transactionPayload));
-        const byteBufferWithoutHeader = byteBuffer.slice(4 + 64 + 32 + 8);
-        const dataBytes = type === TransactionType.AGGREGATE_BONDED || type === TransactionType.AGGREGATE_COMPLETE ?
-            generationHashBuffer.concat(byteBufferWithoutHeader.slice(0, 52)) :
-            generationHashBuffer.concat(byteBufferWithoutHeader);
-        const signingBytes = byteBuffer
-            .slice(8, 40) // first half of signature
-            .concat(byteBuffer
-                .slice(4 + 4 + 64, 8 + 64 + 32)) // signer
-            .concat(dataBytes);
 
-        const hash = new Uint8Array(32);
-        const signSchema = SHA3Hasher.resolveSignSchema(networkType);
-        SHA3Hasher.func(hash, signingBytes, 32, signSchema);
+        // prepare
+        const entityHash: Uint8Array = new Uint8Array(32);
+        const signSchema: SignSchema = SHA3Hasher.resolveSignSchema(networkType);
+        const transactionBytes: Uint8Array = Convert.hexToUint8(transactionPayload);
+
+        // 1) take "R" part of a signature (first 32 bytes)
+        const signatureR: Uint8Array = transactionBytes.slice(8, 8 + 32);
+
+        // 2) add public key to match sign/verify behavior (32 bytes)
+        const pubKeyIdx: number = signatureR.length;
+        const publicKey: Uint8Array = transactionBytes.slice(8 + 64, 8 + 64 + 32);
+
+        // 3) add generationHash (32 bytes)
+        const generationHashIdx: number = pubKeyIdx + publicKey.length;
+        const generationHash: Uint8Array = Uint8Array.from(generationHashBuffer);
+
+        // 4) add transaction data without header (EntityDataBuffer)
+        // @link https://github.com/nemtech/catapult-server/blob/master/src/catapult/model/EntityHasher.cpp#L30
+        const transactionBodyIdx: number = generationHashIdx + generationHash.length;
+        const transactionBody: Uint8Array = transactionBytes.slice(Transaction.Header_Size);
+
+        // 5) concatenate binary hash parts
+        // layout: `signature_R || signerPublicKey || generationHash || EntityDataBuffer`
+        const entityHashBytes: Uint8Array = new Uint8Array(
+            signatureR.length
+          + publicKey.length
+          + generationHash.length
+          + transactionBody.length,
+        );
+        entityHashBytes.set(signatureR, 0);
+        entityHashBytes.set(publicKey, pubKeyIdx);
+        entityHashBytes.set(generationHash, generationHashIdx);
+        entityHashBytes.set(transactionBody, transactionBodyIdx);
 
-        return Convert.uint8ToHex(hash);
+        // 6) create SHA3 or Keccak hash depending on `signSchema`
+        SHA3Hasher.func(entityHash, entityHashBytes, 32, signSchema);
+        return Convert.uint8ToHex(entityHash);
     }
 
     /**

test/model/transaction/Transaction.spec.ts

@@ -28,6 +28,7 @@ import { TransactionType } from '../../../src/model/transaction/TransactionType'
 import { TransferTransaction } from '../../../src/model/transaction/TransferTransaction';
 import { UInt64 } from '../../../src/model/UInt64';
 import { TestingAccount } from '../../conf/conf.spec';
+import { Convert } from '../../../src/core/format/Convert';
 
 describe('Transaction', () => {
     let account: Account;
@@ -227,6 +228,55 @@ describe('Transaction', () => {
             expect(transaction.versionToHex()).to.be.equal('0x9001');
         });
     });
+
+    describe('createTransactionHash() should', () => {
+
+        // shortcut
+        const knownPayload = (
+            '970000000000000075DAC796D500CEFDFBD582BC6E0580401FE6DB02FBEA9367'
+          + '3DF47844246CDEA93715EB700F295A459E59D96A2BC6B7E36C79016A96B9FA38'
+          + '7E8B8937342FE30C6BE37B726EEE24C4B0E3C943E09A44691553759A89E92C4A'
+          + '84BBC4AD9AF5D49C0000000001984E4140420F0000000000E4B580B11A000000'
+          + 'A0860100000000002AD8FC018D9A49E100056576696173'
+        );
+
+        // expected values
+        const knownHash_sha3 = '709373248659274C5933BEA2920942D6C7B48B9C2DA4BAEE233510E71495931F';
+        const knownHash_keccak = '787423372BEC0CB2BE3EEA58E773074E121989AF29E5E5BD9EE660C1E3A0AF93';
+        const generationHashBytes = Array.from(Convert.hexToUint8('988C4CDCE4D188013C13DE7914C7FD4D626169EF256722F61C52EFBE06BD5A2C'));
+
+        it('create correct SHA3 transaction hash given network type MIJIN or MIJIN_TEST', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+            const hash2 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN,
+            );
+
+            expect(hash1).to.equal(knownHash_sha3);
+            expect(hash2).to.equal(knownHash_sha3);
+        });
+
+        it('create correct KECCAK transaction hash given network type MAIN_NET or TEST_NET', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.TEST_NET,
+            );
+            const hash2 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MAIN_NET,
+            );
+
+            expect(hash1).to.equal(knownHash_keccak);
+            expect(hash2).to.equal(knownHash_keccak);
+        });
+    });
 });
 
 class FakeTransaction extends Transaction {