fixed merge issue

Author: rg911

src/model/transaction/AggregateTransaction.ts

@@ -96,7 +96,7 @@ export class AggregateTransaction extends Transaction {
      * @param {InnerTransaction[]} innerTransactions
      * @param {NetworkType} networkType
      * @param {AggregateTransactionCosignature[]} cosignatures
-     * @param {UInt64} maxFee - (Optional) Max fee defined by the sender
+     * @param {UInt64} maxFee - (Optional) Max fee defined by the sender
      * @return {AggregateTransaction}
      */
     public static createBonded(deadline: Deadline,
@@ -150,13 +150,16 @@ export class AggregateTransaction extends Transaction {
      * For off chain Aggregated Complete Transaction co-signing.
      * @param initiatorAccount - Initiator account
      * @param {CosignatureSignedTransaction[]} cosignatureSignedTransactions - Array of cosigned transaction
+     * @param generationHash - Network generation hash hex
      * @return {SignedTransaction}
      */
     public signTransactionGivenSignatures(initiatorAccount: Account,
-                                          cosignatureSignedTransactions: CosignatureSignedTransaction[]) {
+                                          cosignatureSignedTransactions: CosignatureSignedTransaction[],
+                                          generationHash: string) {
         const aggregateTransaction = this.buildTransaction();
         const signedTransactionRaw = aggregateTransaction.signTransactionGivenSignatures(initiatorAccount,
-                                                                                         cosignatureSignedTransactions);
+                                                                                         cosignatureSignedTransactions,
+                                                                                         generationHash);
         return new SignedTransaction(signedTransactionRaw.payload, signedTransactionRaw.hash, initiatorAccount.publicKey,
                                      this.type, this.networkType);
     }
@@ -191,4 +194,4 @@ export class AggregateTransaction extends Transaction {
 
         return byteSize + byteTransactionsSize + byteTransactions;
     }
-}
+}

src/model/transaction/CosignatureTransaction.ts

@@ -18,6 +18,7 @@ import {CosignatureTransaction as CosignaturetransactionLibrary} from '../../inf
 import {Account} from '../account/Account';
 import {AggregateTransaction} from './AggregateTransaction';
 import {CosignatureSignedTransaction} from './CosignatureSignedTransaction';
+import { VerifiableTransaction } from '../../infrastructure/builders/VerifiableTransaction';
 
 /**
  * Cosignature transaction is used to sign an aggregate transactions with missing cosignatures.
@@ -50,13 +51,14 @@ export class CosignatureTransaction {
      * Creating a new CosignatureSignedTransaction
      * @param account - The signing account
      * @param payload - off transaction payload (aggregated transaction is unannounced)
+     * @param gernationHash - Network generation hash
      * @returns {CosignatureSignedTransaction}
      */
-    public static signTransactionPayload(account: Account, payload: string): CosignatureSignedTransaction {
+    public static signTransactionPayload(account: Account, payload: string, gernationHash: string): CosignatureSignedTransaction {
         /**
          * For aggregated complete transaction, cosignatories are gathered off chain announced.
          */
-        const transactionHash = VerifiableTransaction.createTransactionHash(payload);
+        const transactionHash = VerifiableTransaction.createTransactionHash(payload, gernationHash);
         const aggregateSignatureTransaction = new CosignaturetransactionLibrary(transactionHash);
         const signedTransactionRaw = aggregateSignatureTransaction.signCosignatoriesTransaction(account);
         return new CosignatureSignedTransaction(signedTransactionRaw.parentHash,
@@ -77,4 +79,4 @@ export class CosignatureTransaction {
             signedTransactionRaw.signature,
             signedTransactionRaw.signer);
     }
-}
+}

test/model/transaction/AggregateTransaction.spec.ts

@@ -16,7 +16,6 @@
 
 import {expect} from 'chai';
 import {ChronoUnit} from 'js-joda';
-import { VerifiableTransaction } from 'nem2-library';
 import { TransactionMapping } from '../../../src/core/utils/TransactionMapping';
 import {CreateTransactionFromDTO} from '../../../src/infrastructure/transaction/CreateTransactionFromDTO';
 import {Account} from '../../../src/model/account/Account';
@@ -423,10 +422,10 @@ describe('AggregateTransaction', () => {
         ).serialize();
 
         // 02.1 Bob cosigns the tx and sends it back to Alice
-        const signedTxBob = CosignatureTransaction.signTransactionPayload(accountBob, aggregateTransactionPayload);
+        const signedTxBob = CosignatureTransaction.signTransactionPayload(accountBob, aggregateTransactionPayload, generationHash);
 
         // 02.2 Carol cosigns the tx and sends it back to Alice
-        const signedTxCarol = CosignatureTransaction.signTransactionPayload(accountCarol, aggregateTransactionPayload);
+        const signedTxCarol = CosignatureTransaction.signTransactionPayload(accountCarol, aggregateTransactionPayload, generationHash);
 
         // 03. Alice collects the cosignatures, recreate, sign, and announces the transaction
 
@@ -438,7 +437,7 @@ describe('AggregateTransaction', () => {
 
         const recreatedTx = TransactionMapping.createFromPayload(aggregateTransactionPayload) as AggregateTransaction;
 
-        const signedTransaction = recreatedTx.signTransactionGivenSignatures(accountAlice, cosignatureSignedTransactions);
+        const signedTransaction = recreatedTx.signTransactionGivenSignatures(accountAlice, cosignatureSignedTransactions, generationHash);
 
         expect(signedTransaction.type).to.be.equal(TransactionType.AGGREGATE_COMPLETE);
         expect(signedTransaction.signer).to.be.equal(accountAlice.publicKey);
@@ -466,4 +465,4 @@ describe('AggregateTransaction', () => {
             expect(aggregateTransaction.size).to.be.equal(120 + 4 + 158);
         });
     });
-});
+});

test/model/transaction/CosignatureTransaction.spec.ts

@@ -15,7 +15,6 @@
  */
 
 import {expect} from 'chai';
-import { VerifiableTransaction } from 'nem2-library';
 import {CreateTransactionFromDTO} from '../../../src/infrastructure/transaction/CreateTransactionFromDTO';
 import {Account} from '../../../src/model/account/Account';
 import { NetworkType } from '../../../src/model/blockchain/NetworkType';
@@ -28,7 +27,7 @@ import {TestingAccount} from '../../conf/conf.spec';
 
 describe('CosignatureTransaction', () => {
     let account: Account;
-
+    const generationHash = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6';
     before(() => {
         account = TestingAccount;
     });
@@ -125,9 +124,9 @@ describe('CosignatureTransaction', () => {
                                               PlainMessage.create('a to b'),
                                               NetworkType.MIJIN_TEST).serialize();
 
-        const signedTx = CosignatureTransaction.signTransactionPayload(account, txPayload);
+        const signedTx = CosignatureTransaction.signTransactionPayload(account, txPayload, generationHash);
 
         expect(signedTx.signer).to.be.equal('C2F93346E27CE6AD1A9F8F5E3066F8326593A406BDF357ACB041E2F9AB402EFE');
         expect(signedTx.signer).to.be.equal(account.publicKey);
     });
-});
+});