Changed to sign cosign transaction to use payload instead of hash

Author: rg911

src/model/transaction/CosignatureTransaction.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-import {CosignatureTransaction as CosignaturetransactionLibrary} from 'nem2-library';
+import {CosignatureTransaction as CosignaturetransactionLibrary, VerifiableTransaction} from 'nem2-library';
 import {Account} from '../account/Account';
 import {AggregateTransaction} from './AggregateTransaction';
 import {CosignatureSignedTransaction} from './CosignatureSignedTransaction';
@@ -46,16 +46,17 @@ export class CosignatureTransaction {
     }
 
     /**
-     * Co-sign transaction with transaction hash (off chain)
+     * Co-sign transaction with transaction payload (off chain)
      * Creating a new CosignatureSignedTransaction
      * @param account - The signing account
-     * @param transactionHash - off transaction hash (aggregated transaction is unannounced)
+     * @param payload - off transaction payload (aggregated transaction is unannounced)
      * @returns {CosignatureSignedTransaction}
      */
-    public static signTransactionHashWith(account: Account, transactionHash: string): CosignatureSignedTransaction {
+    public static signTransactionPayload(account: Account, payload: string): CosignatureSignedTransaction {
         /**
          * For aggregated complete transaction, cosignatories are gathered off chain announced.
          */
+        const transactionHash = VerifiableTransaction.createTransactionHash(payload);
         const aggregateSignatureTransaction = new CosignaturetransactionLibrary(transactionHash);
         const signedTransactionRaw = aggregateSignatureTransaction.signCosignatoriesTransaction(account);
         return new CosignatureSignedTransaction(signedTransactionRaw.parentHash,

test/model/transaction/AggregateTransaction.spec.ts

@@ -411,7 +411,7 @@ describe('AggregateTransaction', () => {
                                                   PlainMessage.create('c to a'),
                                                   NetworkType.MIJIN_TEST);
 
-        // 01. Alice creates the aggregated tx and serialize it, and generate the hash. Then send to Bob & Carol
+        // 01. Alice creates the aggregated tx and serialize it, Then payload send to Bob & Carol
         const aggregateTransactionPayload = AggregateTransaction.createComplete(
             Deadline.create(),
             [
@@ -422,13 +422,11 @@ describe('AggregateTransaction', () => {
             [],
         ).serialize();
 
-        const txHash = VerifiableTransaction.createTransactionHash(aggregateTransactionPayload);
-
         // 02.1 Bob cosigns the tx and sends it back to Alice
-        const signedTxBob = CosignatureTransaction.signTransactionHashWith(accountBob, txHash);
+        const signedTxBob = CosignatureTransaction.signTransactionPayload(accountBob, aggregateTransactionPayload);
 
         // 02.2 Carol cosigns the tx and sends it back to Alice
-        const signedTxCarol = CosignatureTransaction.signTransactionHashWith(accountCarol, txHash);
+        const signedTxCarol = CosignatureTransaction.signTransactionPayload(accountCarol, aggregateTransactionPayload);
 
         // 03. Alice collects the cosignatures, recreate, sign, and announces the transaction
 

test/model/transaction/CosignatureTransaction.spec.ts

@@ -118,18 +118,15 @@ describe('CosignatureTransaction', () => {
         expect(cosignatureSignedTransaction.signer).to.be.equal(account.publicKey);
     });
 
-    it('should sign a transaction with transaction hash', () => {
+    it('should sign a transaction with transaction payload', () => {
         const txPayload = TransferTransaction.create(Deadline.create(),
                                               account.address,
                                               [],
                                               PlainMessage.create('a to b'),
                                               NetworkType.MIJIN_TEST).serialize();
 
-        const txHash = VerifiableTransaction.createTransactionHash(txPayload);
+        const signedTx = CosignatureTransaction.signTransactionPayload(account, txPayload);
 
-        const signedTx = CosignatureTransaction.signTransactionHashWith(account, txHash);
-
-        expect(signedTx.parentHash).to.be.equal(txHash);
         expect(signedTx.signer).to.be.equal('C2F93346E27CE6AD1A9F8F5E3066F8326593A406BDF357ACB041E2F9AB402EFE');
         expect(signedTx.signer).to.be.equal(account.publicKey);
     });