Merge branch 'master' into patch-2

rg911 · web-flow · commit b3aaaff3ac8b · 2019-07-25T12:51:46.000+01:00
diff --git a/e2e/infrastructure/TransactionHttp.spec.ts b/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';
@@ -45,6 +46,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';
@@ -1761,6 +1763,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) => {
diff --git a/src/infrastructure/builders/AggregateTransaction.ts b/src/infrastructure/builders/AggregateTransaction.ts
@@ -56,7 +56,7 @@ export class AggregateTransaction extends VerifiableTransaction {
         return signedTransaction;
     }
 
-    signTransactionGivenSignatures(initializer, cosignedSignedTransactions, generationHash, signSchema) {
+    signTransactionGivenSignatures(initializer, cosignedSignedTransactions, generationHash, signSchema = SignSchema.SHA3) {
         const signedTransaction = this.signTransaction(initializer, generationHash, signSchema);
         cosignedSignedTransactions.forEach((cosignedTransaction) => {
             signedTransaction.payload = signedTransaction.payload + cosignedTransaction.signer + cosignedTransaction.signature;
diff --git a/src/model/account/Account.ts b/src/model/account/Account.ts
@@ -171,6 +171,21 @@ export class Account {
     return transaction.signTransactionWithCosignatories(this, cosignatories, generationHash, signSchema);
     }
 
+    /**
+     * Sign transaction with cosignatories collected from cosigned transactions and creating a new SignedTransaction
+     * 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
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @return {SignedTransaction}
+     */
+    public signTransactionGivenSignatures(transaction: AggregateTransaction,
+                                          cosignatureSignedTransactions: CosignatureSignedTransaction[],
+                                          generationHash: string,
+                                          signSchema: SignSchema = SignSchema.SHA3): SignedTransaction {
+    return transaction.signTransactionGivenSignatures(this, cosignatureSignedTransactions, generationHash, signSchema);
+    }
     /**
      * Sign aggregate signature transaction
      * @param cosignatureTransaction - The aggregate signature transaction.
diff --git a/src/model/transaction/CosignatureTransaction.ts b/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,16 +53,20 @@ 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
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
      * @returns {CosignatureSignedTransaction}
      */
-    public static signTransactionPayload(account: Account, payload: string, gernationHash: string): CosignatureSignedTransaction {
+    public static signTransactionPayload(account: Account,
+                                         payload: string,
+                                         generationHash: string,
+                                         signSchema: SignSchema = SignSchema.SHA3): 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);
+        const signedTransactionRaw = aggregateSignatureTransaction.signCosignatoriesTransaction(account, signSchema);
         return new CosignatureSignedTransaction(signedTransactionRaw.parentHash,
             signedTransactionRaw.signature,
             signedTransactionRaw.signer);
@@ -81,4 +86,4 @@ export class CosignatureTransaction {
             signedTransactionRaw.signature,
             signedTransactionRaw.signer);
     }
-}
+}
diff --git a/test/model/transaction/AggregateTransaction.spec.ts b/test/model/transaction/AggregateTransaction.spec.ts
@@ -389,7 +389,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;
@@ -411,22 +411,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
 
@@ -436,14 +438,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', () => {

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ export class AggregateTransaction extends VerifiableTransaction {`
`56`	`56`	`return signedTransaction;`
`57`	`57`	`}`
`58`	`58`
`59`		`- signTransactionGivenSignatures(initializer, cosignedSignedTransactions, generationHash, signSchema) {`
	`59`	`+ signTransactionGivenSignatures(initializer, cosignedSignedTransactions, generationHash, signSchema = SignSchema.SHA3) {`
`60`	`60`	`const signedTransaction = this.signTransaction(initializer, generationHash, signSchema);`
`61`	`61`	`cosignedSignedTransactions.forEach((cosignedTransaction) => {`
`62`	`62`	`signedTransaction.payload = signedTransaction.payload + cosignedTransaction.signer + cosignedTransaction.signature;`