#345: add method addCosignatures to fill cosignatures offline

src/model/transaction/AggregateTransaction.ts

@@ -194,6 +194,17 @@ export class AggregateTransaction extends Transaction {
         return Object.assign({__proto__: Object.getPrototypeOf(this)}, this, {innerTransactions});
     }
 
+    /**
+     * @description add cosignatures to current list
+     * @param {AggregateTransactionCosignature[]} transaction
+     * @returns {AggregateTransaction}
+     * @memberof AggregateTransaction
+     */
+    public addCosignatures(cosigs: AggregateTransactionCosignature[]): AggregateTransaction {
+        const cosignatures = this.cosignatures.concat(cosigs);
+        return Object.assign({__proto__: Object.getPrototypeOf(this)}, this, {cosignatures});
+    }
+
     /**
      * @internal
      * Sign transaction with cosignatories creating a new SignedTransaction

test/model/transaction/AggregateTransaction.spec.ts

@@ -30,6 +30,7 @@ import {MosaicNonce} from '../../../src/model/mosaic/MosaicNonce';
 import {MosaicSupplyChangeAction} from '../../../src/model/mosaic/MosaicSupplyChangeAction';
 import { NetworkCurrencyMosaic } from '../../../src/model/mosaic/NetworkCurrencyMosaic';
 import {AggregateTransaction} from '../../../src/model/transaction/AggregateTransaction';
+import {AggregateTransactionCosignature} from '../../../src/model/transaction/AggregateTransactionCosignature';
 import {CosignatoryModificationAction} from '../../../src/model/transaction/CosignatoryModificationAction';
 import { CosignatureSignedTransaction } from '../../../src/model/transaction/CosignatureSignedTransaction';
 import { CosignatureTransaction } from '../../../src/model/transaction/CosignatureTransaction';
@@ -547,6 +548,35 @@ describe('AggregateTransaction', () => {
         expect(aggregateTransaction.innerTransactions.length).to.be.equal(2);
     });
 
+    it('Should be able to add cosignatures to current aggregate tx', () => {
+        const transferTx1 = TransferTransaction.create(Deadline.create(),
+                                                  account.address,
+                                                  [],
+                                                  PlainMessage.create('a to b'),
+                                                  NetworkType.MIJIN_TEST);
+        let aggregateTransaction = AggregateTransaction.createComplete(
+            Deadline.create(),
+            [transferTx1.toAggregate(account.publicAccount)],
+            NetworkType.MIJIN_TEST,
+            [],
+        );
+
+        expect(aggregateTransaction.type).to.be.equal(TransactionType.AGGREGATE_COMPLETE);
+        expect(aggregateTransaction.cosignatures.length).to.be.equal(0);
+
+        // add cosignature after creation
+        const signedTransaction = aggregateTransaction.signWith(account, generationHash);
+        const cosignature = new AggregateTransactionCosignature(
+            signedTransaction.payload,
+            PublicAccount.createFromPublicKey(signedTransaction.signerPublicKey, NetworkType.MIJIN_TEST),
+        );
+
+        aggregateTransaction = aggregateTransaction.addCosignatures([cosignature]);
+
+        expect(aggregateTransaction.type).to.be.equal(TransactionType.AGGREGATE_COMPLETE);
+        expect(aggregateTransaction.cosignatures.length).to.be.equal(1);
+    });
+
     describe('size', () => {
         it('should return 282 for AggregateTransaction byte size with TransferTransaction with 1 mosaic and message NEM', () => {
             const transaction = TransferTransaction.create(