Added #112 sign with cosignatories

Author: rg911

src/model/transaction/AggregateTransaction.ts

@@ -21,6 +21,7 @@ import { PublicAccount } from '../account/PublicAccount';
 import { NetworkType } from '../blockchain/NetworkType';
 import { UInt64 } from '../UInt64';
 import { AggregateTransactionCosignature } from './AggregateTransactionCosignature';
+import { CosignatureSignedTransaction } from './CosignatureSignedTransaction';
 import { Deadline } from './Deadline';
 import { InnerTransaction } from './InnerTransaction';
 import { SignedTransaction } from './SignedTransaction';
@@ -143,6 +144,23 @@ export class AggregateTransaction extends Transaction {
                                      this.type, this.networkType);
     }
 
+    /**
+     * @internal
+     * 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[]} cosignatureSignedTransaction - Array of cosigned transaction
+     * @return {SignedTransaction}
+     */
+    public signTransactionWithCosignedTransactions(initiatorAccount: Account,
+                                                   cosignatureSignedTransaction: CosignatureSignedTransaction[]) {
+        const aggregateTransaction = this.buildTransaction();
+        const signedTransactionRaw = aggregateTransaction.signTransactionWithCosignedTransactions(initiatorAccount,
+                                                                                                  cosignatureSignedTransaction);
+        return new SignedTransaction(signedTransactionRaw.payload, signedTransactionRaw.hash, initiatorAccount.publicKey,
+                                     this.type, this.networkType);
+    }
+
     /**
      * Check if account has signed transaction
      * @param publicAccount - Signer public account

src/model/transaction/CosignatureTransaction.ts

@@ -45,6 +45,24 @@ export class CosignatureTransaction {
         return new CosignatureTransaction(transactionToCosign);
     }
 
+    /**
+     * Co-sign transaction with transaction hash (off chain)
+     * Creating a new CosignatureSignedTransaction
+     * @param account - The signing account
+     * @param transactionHash - off transaction hash (aggregated transaction is unannounced)
+     * @returns {CosignatureSignedTransaction}
+     */
+    public static signTransactionHashWith(account: Account, transactionHash: string): CosignatureSignedTransaction {
+        /**
+         * For aggregated complete transaction, cosignatories are gathered off chain announced.
+         */
+        const aggregateSignatureTransaction = new CosignaturetransactionLibrary(transactionHash);
+        const signedTransactionRaw = aggregateSignatureTransaction.signCosignatoriesTransaction(account);
+        return new CosignatureSignedTransaction(signedTransactionRaw.parentHash,
+            signedTransactionRaw.signature,
+            signedTransactionRaw.signer);
+    }
+
     /**
      * @internal
      * Serialize and sign transaction creating a new SignedTransaction

test/model/transaction/AggregateTransaction.spec.ts

@@ -16,6 +16,8 @@
 
 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';
 import {Address} from '../../../src/model/account/Address';
@@ -27,6 +29,8 @@ import {MosaicProperties} from '../../../src/model/mosaic/MosaicProperties';
 import {MosaicSupplyType} from '../../../src/model/mosaic/MosaicSupplyType';
 import { NetworkCurrencyMosaic } from '../../../src/model/mosaic/NetworkCurrencyMosaic';
 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 {ModifyMultisigAccountTransaction} from '../../../src/model/transaction/ModifyMultisigAccountTransaction';
 import {MosaicDefinitionTransaction} from '../../../src/model/transaction/MosaicDefinitionTransaction';
@@ -35,6 +39,7 @@ import {MultisigCosignatoryModification} from '../../../src/model/transaction/Mu
 import {MultisigCosignatoryModificationType} from '../../../src/model/transaction/MultisigCosignatoryModificationType';
 import {PlainMessage} from '../../../src/model/transaction/PlainMessage';
 import {RegisterNamespaceTransaction} from '../../../src/model/transaction/RegisterNamespaceTransaction';
+import { TransactionType } from '../../../src/model/transaction/TransactionType';
 import {TransferTransaction} from '../../../src/model/transaction/TransferTransaction';
 import {UInt64} from '../../../src/model/UInt64';
 import {Cosignatory2Account, CosignatoryAccount, MultisigAccount, TestingAccount} from '../../conf/conf.spec';
@@ -80,7 +85,7 @@ describe('AggregateTransaction', () => {
             [transferTransaction.toAggregate(account.publicAccount)],
             NetworkType.MIJIN_TEST,
             [],
-            new UInt64([1, 0])
+            new UInt64([1, 0]),
         );
 
         expect(aggregateTransaction.maxFee.higher).to.be.equal(0);
@@ -382,6 +387,67 @@ describe('AggregateTransaction', () => {
         }).to.throw(Error, 'Inner transaction cannot be an aggregated transaction.');
     });
 
+    it('Should create signed transaction with cosignatories - Aggregated Complete', () => {
+        /**
+         * https://github.com/nemtech/nem2-sdk-typescript-javascript/issues/112
+         */
+        const accountAlice = TestingAccount;
+        const accountBob = CosignatoryAccount;
+        const accountCarol = Cosignatory2Account;
+
+        const AtoBTx = TransferTransaction.create(Deadline.create(),
+                                                  accountBob.address,
+                                                  [],
+                                                  PlainMessage.create('a to b'),
+                                                  NetworkType.MIJIN_TEST);
+        const BtoATx = TransferTransaction.create(Deadline.create(),
+                                                  accountAlice.address,
+                                                  [],
+                                                  PlainMessage.create('b to a'),
+                                                  NetworkType.MIJIN_TEST);
+        const CtoATx = TransferTransaction.create(Deadline.create(),
+                                                  accountAlice.address,
+                                                  [],
+                                                  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
+        const aggregateTransactionPayload = AggregateTransaction.createComplete(
+            Deadline.create(),
+            [
+                AtoBTx.toAggregate(accountAlice.publicAccount),
+                BtoATx.toAggregate(accountBob.publicAccount),
+                CtoATx.toAggregate(accountCarol.publicAccount)],
+            NetworkType.MIJIN_TEST,
+            [],
+        ).serialize();
+
+        const txHash = VerifiableTransaction.createTransactionHash(aggregateTransactionPayload);
+
+        // 02.1 Bob cosigns the tx and sends it back to Alice
+        const signedTxBob = CosignatureTransaction.signTransactionHashWith(accountBob, txHash);
+
+        // 02.2 Carol cosigns the tx and sends it back to Alice
+        const signedTxCarol = CosignatureTransaction.signTransactionHashWith(accountCarol, txHash);
+
+        // 03. Alice collects the cosignatures, recreate, sign, and announces the transaction
+
+        // First Alice need to append cosignatories to current transaction.
+        const cosignatureSignedTransactions = [
+            new CosignatureSignedTransaction(signedTxBob.parentHash, signedTxBob.signature, signedTxBob.signer),
+            new CosignatureSignedTransaction(signedTxCarol.parentHash, signedTxCarol.signature, signedTxCarol.signer),
+        ];
+
+        const recreatedTx = TransactionMapping.createFromPayload(aggregateTransactionPayload) as AggregateTransaction;
+
+        const signedTransaction = recreatedTx.signTransactionWithCosignedTransactions(accountAlice, cosignatureSignedTransactions);
+
+        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;
+    });
+
     describe('size', () => {
         it('should return 282 for AggregateTransaction byte size with TransferTransaction with 1 mosaic and message NEM', () => {
             const transaction = TransferTransaction.create(

test/model/transaction/CosignatureTransaction.spec.ts

@@ -15,10 +15,15 @@
  */
 
 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';
 import {AggregateTransaction} from '../../../src/model/transaction/AggregateTransaction';
 import {CosignatureTransaction} from '../../../src/model/transaction/CosignatureTransaction';
+import { Deadline } from '../../../src/model/transaction/Deadline';
+import { PlainMessage } from '../../../src/model/transaction/PlainMessage';
+import { TransferTransaction } from '../../../src/model/transaction/TransferTransaction';
 import {TestingAccount} from '../../conf/conf.spec';
 
 describe('CosignatureTransaction', () => {
@@ -112,4 +117,20 @@ describe('CosignatureTransaction', () => {
             '93D2F8522C8DEAC74BEFBCB61AF6414ADF27B2176D6A24FEF612AA6DB2F562176A11C46BA6D5E05430042CB5705');
         expect(cosignatureSignedTransaction.signer).to.be.equal(account.publicKey);
     });
+
+    it('should sign a transaction with transaction hash', () => {
+        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.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);
+    });
 });