Added #204

- Fixed signTransactionGivenSignatures bug
- Added e2e test for signTransactionGivenSignatures
- Improved unit test for signTransactionGivenSignatures
- Fixed typo

Author: rg911

e2e/infrastructure/TransactionHttp.spec.ts

@@ -19,6 +19,7 @@ import {ChronoUnit} from 'js-joda';
 import {keccak_256, sha3_256} from 'js-sha3';
 import {Crypto} from '../../src/core/crypto';
 import { Convert as convert } from '../../src/core/format';
+import { TransactionMapping } from '../../src/core/utils/TransactionMapping';
 import {AccountHttp} from '../../src/infrastructure/AccountHttp';
 import { NamespaceHttp } from '../../src/infrastructure/infrastructure';
 import {Listener} from '../../src/infrastructure/Listener';
@@ -44,6 +45,7 @@ import { AccountRestrictionTransaction } from '../../src/model/transaction/Accou
 import { AddressAliasTransaction } from '../../src/model/transaction/AddressAliasTransaction';
 import {AggregateTransaction} from '../../src/model/transaction/AggregateTransaction';
 import {CosignatureSignedTransaction} from '../../src/model/transaction/CosignatureSignedTransaction';
+import { CosignatureTransaction } from '../../src/model/transaction/CosignatureTransaction';
 import {Deadline} from '../../src/model/transaction/Deadline';
 import { HashLockTransaction } from '../../src/model/transaction/HashLockTransaction';
 import {HashType} from '../../src/model/transaction/HashType';
@@ -1641,6 +1643,67 @@ describe('TransactionHttp', () => {
         });
     });
 
+    describe('SignTransactionGivenSignatures', () => {
+        let listener: Listener;
+        before (() => {
+            listener = new Listener(config.apiUrl);
+            return listener.open();
+        });
+        after(() => {
+            return listener.close();
+        });
+        it('Announce cosign signatures given', (done) => {
+
+            /**
+             * @see https://github.com/nemtech/nem2-sdk-typescript-javascript/issues/112
+             */
+            // AliceAccount: account
+            // BobAccount: account
+
+            const sendAmount = NetworkCurrencyMosaic.createRelative(1000);
+            const backAmount = NetworkCurrencyMosaic.createRelative(1);
+
+            const aliceTransferTransaction = TransferTransaction.create(Deadline.create(), account2.address, [sendAmount],
+                                                                        PlainMessage.create('payout'), NetworkType.MIJIN_TEST);
+            const bobTransferTransaction   = TransferTransaction.create(Deadline.create(), account.address, [backAmount],
+                                                                        PlainMessage.create('payout'), NetworkType.MIJIN_TEST);
+
+            // 01. Alice creates the aggregated tx and sign it. Then payload send to Bob
+            const aggregateTransaction = AggregateTransaction.createComplete(
+                Deadline.create(),
+                [
+                    aliceTransferTransaction.toAggregate(account.publicAccount),
+                    bobTransferTransaction.toAggregate(account2.publicAccount),
+                ],
+                NetworkType.MIJIN_TEST,
+                [],
+            );
+
+            const aliceSignedTransaction = aggregateTransaction.signWith(account, generationHash);
+
+            // 02 Bob cosigns the tx and sends it back to Alice
+            const signedTxBob = CosignatureTransaction.signTransactionPayload(account2, aliceSignedTransaction.payload, generationHash);
+
+            // 03. Alice collects the cosignatures, recreate, sign, and announces the transaction
+            const cosignatureSignedTransactions = [
+                new CosignatureSignedTransaction(signedTxBob.parentHash, signedTxBob.signature, signedTxBob.signer),
+            ];
+            const recreatedTx = TransactionMapping.createFromPayload(aliceSignedTransaction.payload) as AggregateTransaction;
+
+            const signedTransaction = recreatedTx.signTransactionGivenSignatures(account, cosignatureSignedTransactions, generationHash);
+
+            listener.confirmed(account.address).subscribe(() => {
+                done();
+            });
+            listener.status(account.address).subscribe((error) => {
+                console.log('Error:', error);
+                assert(false);
+                done();
+            });
+            transactionHttp.announce(signedTransaction);
+        });
+    });
+
     describe('transactions', () => {
         it('should call transactions successfully', (done) => {
             accountHttp.transactions(account.publicAccount).subscribe((transactions) => {

src/model/transaction/CosignatureTransaction.ts

@@ -15,11 +15,12 @@
  */
 
 import { SignSchema } from '../../core/crypto';
+import { Convert } from '../../core/format/Convert';
 import {CosignatureTransaction as CosignaturetransactionLibrary} from '../../infrastructure/builders/CosignatureTransaction';
+import { VerifiableTransaction } from '../../infrastructure/builders/VerifiableTransaction';
 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.
@@ -52,14 +53,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
+     * @param generationHash - Network generation hash
      * @returns {CosignatureSignedTransaction}
      */
-    public static signTransactionPayload(account: Account, payload: string, gernationHash: string): CosignatureSignedTransaction {
+    public static signTransactionPayload(account: Account, payload: string, generationHash: string): CosignatureSignedTransaction {
         /**
          * For aggregated complete transaction, cosignatories are gathered off chain announced.
          */
-        const transactionHash = VerifiableTransaction.createTransactionHash(payload, gernationHash);
+        const transactionHash = VerifiableTransaction.createTransactionHash(payload, Array.from(Convert.hexToUint8(generationHash)));
         const aggregateSignatureTransaction = new CosignaturetransactionLibrary(transactionHash);
         const signedTransactionRaw = aggregateSignatureTransaction.signCosignatoriesTransaction(account);
         return new CosignatureSignedTransaction(signedTransactionRaw.parentHash,
@@ -81,4 +82,4 @@ export class CosignatureTransaction {
             signedTransactionRaw.signature,
             signedTransactionRaw.signer);
     }
-}
+}

test/model/transaction/AggregateTransaction.spec.ts

@@ -388,7 +388,7 @@ describe('AggregateTransaction', () => {
 
     it('Should create signed transaction with cosignatories - Aggregated Complete', () => {
         /**
-         * https://github.com/nemtech/nem2-sdk-typescript-javascript/issues/112
+         * @see https://github.com/nemtech/nem2-sdk-typescript-javascript/issues/112
          */
         const accountAlice = TestingAccount;
         const accountBob = CosignatoryAccount;
@@ -410,22 +410,24 @@ describe('AggregateTransaction', () => {
                                                   PlainMessage.create('c to a'),
                                                   NetworkType.MIJIN_TEST);
 
-        // 01. Alice creates the aggregated tx and serialize it, Then payload send to Bob & Carol
-        const aggregateTransactionPayload = AggregateTransaction.createComplete(
+        // 01. Alice creates the aggregated tx and sign it, Then payload send to Bob & Carol
+        const aggregateTransaction = AggregateTransaction.createComplete(
             Deadline.create(),
             [
                 AtoBTx.toAggregate(accountAlice.publicAccount),
                 BtoATx.toAggregate(accountBob.publicAccount),
                 CtoATx.toAggregate(accountCarol.publicAccount)],
             NetworkType.MIJIN_TEST,
             [],
-        ).serialize();
+        );
+
+        const aliceSignedTransaction = aggregateTransaction.signWith(accountAlice, generationHash);
 
         // 02.1 Bob cosigns the tx and sends it back to Alice
-        const signedTxBob = CosignatureTransaction.signTransactionPayload(accountBob, aggregateTransactionPayload, generationHash);
+        const signedTxBob = CosignatureTransaction.signTransactionPayload(accountBob, aliceSignedTransaction.payload, generationHash);
 
         // 02.2 Carol cosigns the tx and sends it back to Alice
-        const signedTxCarol = CosignatureTransaction.signTransactionPayload(accountCarol, aggregateTransactionPayload, generationHash);
+        const signedTxCarol = CosignatureTransaction.signTransactionPayload(accountCarol, aliceSignedTransaction.payload, generationHash);
 
         // 03. Alice collects the cosignatures, recreate, sign, and announces the transaction
 
@@ -435,14 +437,20 @@ describe('AggregateTransaction', () => {
             new CosignatureSignedTransaction(signedTxCarol.parentHash, signedTxCarol.signature, signedTxCarol.signer),
         ];
 
-        const recreatedTx = TransactionMapping.createFromPayload(aggregateTransactionPayload) as AggregateTransaction;
+        const recreatedTx = TransactionMapping.createFromPayload(aliceSignedTransaction.payload) as AggregateTransaction;
 
         const signedTransaction = recreatedTx.signTransactionGivenSignatures(accountAlice, cosignatureSignedTransactions, generationHash);
 
         expect(signedTransaction.type).to.be.equal(TransactionType.AGGREGATE_COMPLETE);
         expect(signedTransaction.signer).to.be.equal(accountAlice.publicKey);
         expect(signedTransaction.payload.indexOf(accountBob.publicKey) > -1).to.be.true;
         expect(signedTransaction.payload.indexOf(accountCarol.publicKey) > -1).to.be.true;
+
+        // To make sure that the new cosign method returns the same payload & hash as standard cosigning
+        const standardCosignedTransaction = aggregateTransaction
+                    .signTransactionWithCosignatories(accountAlice, [accountBob, accountCarol], generationHash);
+        expect(standardCosignedTransaction.payload).to.be.equal(signedTransaction.payload);
+        expect(standardCosignedTransaction.hash).to.be.equal(signedTransaction.hash);
     });
 
     describe('size', () => {