Merge pull request #87 from rg911/task/g38_raise_error_adding_agg_tx_as_inner_tx

Added #38 Raise an error when adding an aggregate tx as an inner tranction

Author: Grégory Saive

src/model/transaction/AggregateTransaction.ts

@@ -133,7 +133,8 @@ export class AggregateTransaction extends Transaction {
     public signTransactionWithCosignatories(initiatorAccount: Account, cosignatories: Account[]) {
         const aggregateTransaction = this.buildTransaction();
         const signedTransactionRaw = aggregateTransaction.signTransactionWithCosigners(initiatorAccount, cosignatories);
-        return new SignedTransaction(signedTransactionRaw.payload, signedTransactionRaw.hash, initiatorAccount.publicKey, this.type, this.networkType);
+        return new SignedTransaction(signedTransactionRaw.payload, signedTransactionRaw.hash, initiatorAccount.publicKey,
+                                     this.type, this.networkType);
     }
 
     /**

src/model/transaction/Transaction.ts

@@ -24,6 +24,7 @@ import { Deadline } from './Deadline';
 import { InnerTransaction } from './InnerTransaction';
 import { SignedTransaction } from './SignedTransaction';
 import { TransactionInfo } from './TransactionInfo';
+import { TransactionType } from './TransactionType';
 
 /**
  * An abstract transaction class that serves as the base class of all NEM transactions.
@@ -112,6 +113,9 @@ export abstract class Transaction {
      * @returns InnerTransaction
      */
     public toAggregate(signer: PublicAccount): InnerTransaction {
+        if (this.type === TransactionType.AGGREGATE_BONDED || this.type === TransactionType.AGGREGATE_COMPLETE) {
+            throw new Error('Inner transaction cannot be an aggregated transaction.');
+        }
         return Object.assign({__proto__: Object.getPrototypeOf(this)}, this, {signer});
     }
 

test/model/transaction/AggregateTransaction.spec.ts

@@ -315,4 +315,28 @@ describe('AggregateTransaction', () => {
 
         expect(aggregateTransaction.type).to.be.equal(0x4241);
     });
+
+    it('should throw exception when adding an aggregated transaction as inner transaction', () => {
+        const transferTransaction = TransferTransaction.create(
+            Deadline.create(1, ChronoUnit.HOURS),
+            Address.createFromRawAddress('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC'),
+            [],
+            PlainMessage.create('test-message'),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const aggregateTransaction = AggregateTransaction.createComplete(
+            Deadline.create(),
+            [transferTransaction.toAggregate(account.publicAccount)],
+            NetworkType.MIJIN_TEST,
+            []);
+
+        expect(() => {
+            AggregateTransaction.createComplete(
+                Deadline.create(),
+                [aggregateTransaction.toAggregate(account.publicAccount)],
+                NetworkType.MIJIN_TEST,
+                []);
+        }).to.throw(Error, 'Inner transaction cannot be an aggregated transaction.');
+    });
 });

test/model/transaction/Transaction.spec.ts

@@ -16,16 +16,24 @@
 
 import { expect } from 'chai';
 import { VerifiableTransaction } from 'nem2-library';
+import { Account } from '../../../src/model/account/Account';
 import { NetworkType } from '../../../src/model/blockchain/NetworkType';
-import { Account } from '../../../src/model/model';
+import { AggregateTransaction } from '../../../src/model/transaction/AggregateTransaction';
 import { Deadline } from '../../../src/model/transaction/Deadline';
 import { SignedTransaction } from '../../../src/model/transaction/SignedTransaction';
 import { Transaction } from '../../../src/model/transaction/Transaction';
 import { TransactionInfo } from '../../../src/model/transaction/TransactionInfo';
 import { TransactionType } from '../../../src/model/transaction/TransactionType';
 import { UInt64 } from '../../../src/model/UInt64';
+import { TestingAccount } from '../../conf/conf.spec';
 
 describe('Transaction', () => {
+    let account: Account;
+
+    before(() => {
+        account = TestingAccount;
+    });
+
     describe('isUnannounced', () => {
         it('should return true when there is no Transaction Info', () => {
             const transaction = new FakeTransaction(TransactionType.TRANSFER,
@@ -146,6 +154,29 @@ describe('Transaction', () => {
             expect(after).to.be.equal(true);
         });
     });
+
+    describe('toAggregate', () => {
+        it('should throw exception when adding an aggregated transaction as inner transaction', () => {
+            const transaction = new FakeTransaction(TransactionType.TRANSFER,
+                NetworkType.MIJIN_TEST,
+                1,
+                Deadline.create(),
+                UInt64.fromUint(0),
+                undefined,
+                undefined,
+            );
+
+            const aggregateTransaction = AggregateTransaction.createComplete(
+                Deadline.create(),
+                [transaction.toAggregate(account.publicAccount)],
+                NetworkType.MIJIN_TEST,
+                []);
+
+            expect(() => {
+                aggregateTransaction.toAggregate(account.publicAccount);
+            }).to.throw(Error, 'Inner transaction cannot be an aggregated transaction.');
+        });
+    });
 });
 
 class FakeTransaction extends Transaction {