Removed InnerTransaction

Added isEmbedded argument back to TransactionMapping
Fixed catbuffer lib version using the one that includes the src and dist folders for easy debugging.

Author: fboucquez

package-lock.json

@@ -58,7 +58,7 @@
   },
   "dependencies": {
     "bluebird": "^3.5.5",
-    "catbuffer": "0.0.6-SNAPSHOT",
+    "catbuffer": "0.0.7",
     "crypto-js": "^3.1.9-1",
     "js-joda": "^1.6.2",
     "js-sha256": "^0.9.0",

package.json

@@ -15,7 +15,10 @@
  */
 
 import { CreateTransactionFromDTO } from '../../infrastructure/transaction/CreateTransactionFromDTO';
-import { CreateTransactionFromPayload } from '../../infrastructure/transaction/CreateTransactionFromPayload';
+import {
+    CreateTransactionFromInnerPayload,
+    CreateTransactionFromPayload
+} from '../../infrastructure/transaction/CreateTransactionFromPayload';
 import { Transaction } from '../../model/transaction/Transaction';
 
 export class TransactionMapping {
@@ -32,9 +35,11 @@ export class TransactionMapping {
     /**
      * Create transaction class from payload binary.
      * @param {string} payload The transaction binary payload
-     * @returns {Transaction} The transaction class.
+     * @param {Boolean} isEmbedded Is embedded transaction (Default: false)
+     * @returns Transaction The transaction class.
      */
-    public static createFromPayload(payload: string): Transaction {
-        return CreateTransactionFromPayload(payload);
+    public static createFromPayload(payload: string,
+                                    isEmbedded = false): Transaction {
+        return isEmbedded ? CreateTransactionFromInnerPayload(payload) : CreateTransactionFromPayload(payload);
     }
 }

src/core/utils/TransactionMapping.ts

@@ -25,17 +25,13 @@ import { AggregateTransaction } from '../model/transaction/AggregateTransaction'
 import { AggregateTransactionCosignature } from '../model/transaction/AggregateTransactionCosignature';
 import { CosignatureSignedTransaction } from '../model/transaction/CosignatureSignedTransaction';
 import { Deadline } from '../model/transaction/Deadline';
-import { InnerTransaction } from '../model/transaction/InnerTransaction';
 import { MultisigAccountModificationTransaction } from '../model/transaction/MultisigAccountModificationTransaction';
 import { Transaction } from '../model/transaction/Transaction';
 import { TransactionStatusError } from '../model/transaction/TransactionStatusError';
 import { TransferTransaction } from '../model/transaction/TransferTransaction';
 import { UInt64 } from '../model/UInt64';
 import { IListener } from './IListener';
-import {
-    CreateTransactionFromDTO,
-    extractBeneficiary,
-} from './transaction/CreateTransactionFromDTO';
+import { CreateTransactionFromDTO, extractBeneficiary, } from './transaction/CreateTransactionFromDTO';
 
 enum ListenerChannelName {
     block = 'block',
@@ -370,7 +366,7 @@ export class Listener implements IListener {
                     transactionFromAddress = true;
                 }
             });
-            transaction.innerTransactions.map((innerTransaction: InnerTransaction) => {
+            transaction.innerTransactions.map((innerTransaction: Transaction) => {
                 if (this.transactionHasSignerOrReceptor(innerTransaction, address) ||
                     this.accountAddedToMultiSig(innerTransaction, address)) {
                     transactionFromAddress = true;

src/infrastructure/Listener.ts

@@ -42,6 +42,7 @@ import {
     EmbeddedSecretLockTransactionBuilder,
     EmbeddedSecretProofTransactionBuilder,
     EmbeddedTransactionBuilder,
+    EmbeddedTransactionHelper,
     EmbeddedTransferTransactionBuilder,
     HashLockTransactionBuilder,
     MosaicAddressRestrictionTransactionBuilder,
@@ -145,6 +146,16 @@ export const CreateTransactionFromPayload = (payload: string): Transaction => {
     return toBuilder();
 };
 
+/**
+ * @internal
+ * @param payload - The transaction binary data from an inner transaction
+ * @returns Transaction
+ */
+export const CreateTransactionFromInnerPayload = (payload: string): Transaction => {
+    const builder = EmbeddedTransactionHelper.loadFromBinary(convert.hexToUint8(payload));
+    return CreateTransactionFromEmbeddedTransactionBuilder(builder);
+};
+
 /**
  * @internal
  * @param builder - The embedded transaction builder builder.

src/infrastructure/transaction/CreateTransactionFromPayload.ts

@@ -129,7 +129,7 @@ export * from './transaction/Deadline';
 export * from './transaction/PersistentDelegationRequestTransaction';
 export * from './transaction/HashLockTransaction';
 export * from './transaction/HashType';
-export * from './transaction/InnerTransaction';
+export * from './transaction/Transaction';
 export * from './transaction/LinkAction';
 export * from './transaction/LockFundsTransaction';
 export * from './transaction/MultisigAccountModificationTransaction';

src/model/model.ts

@@ -38,7 +38,6 @@ import { UInt64 } from '../UInt64';
 import { AggregateTransactionCosignature } from './AggregateTransactionCosignature';
 import { CosignatureSignedTransaction } from './CosignatureSignedTransaction';
 import { Deadline } from './Deadline';
-import { InnerTransaction } from './InnerTransaction';
 import { SignedTransaction } from './SignedTransaction';
 import { Transaction } from './Transaction';
 import { TransactionInfo } from './TransactionInfo';
@@ -70,7 +69,7 @@ export class AggregateTransaction extends Transaction {
                 /**
                  * The array of innerTransactions included in the aggregate transaction.
                  */
-                public readonly innerTransactions: InnerTransaction[],
+                public readonly innerTransactions: Transaction[],
                 /**
                  * The array of transaction cosigners signatures.
                  */
@@ -91,7 +90,7 @@ export class AggregateTransaction extends Transaction {
      * @returns {AggregateTransaction}
      */
     public static createComplete(deadline: Deadline,
-                                 innerTransactions: InnerTransaction[],
+                                 innerTransactions: Transaction[],
                                  networkType: NetworkType,
                                  cosignatures: AggregateTransactionCosignature[],
                                  maxFee: UInt64 = new UInt64([0, 0])): AggregateTransaction {
@@ -108,14 +107,14 @@ export class AggregateTransaction extends Transaction {
     /**
      * Create an aggregate bonded transaction object
      * @param {Deadline} deadline
-     * @param {InnerTransaction[]} innerTransactions
+     * @param {Transaction[]} innerTransactions
      * @param {NetworkType} networkType
      * @param {AggregateTransactionCosignature[]} cosignatures
      * @param {UInt64} maxFee - (Optional) Max fee defined by the sender
      * @return {AggregateTransaction}
      */
     public static createBonded(deadline: Deadline,
-                               innerTransactions: InnerTransaction[],
+                               innerTransactions: Transaction[],
                                networkType: NetworkType,
                                cosignatures: AggregateTransactionCosignature[] = [],
                                maxFee: UInt64 = new UInt64([0, 0])): AggregateTransaction {
@@ -151,7 +150,7 @@ export class AggregateTransaction extends Transaction {
         });
 
         const innerTransactions = builder.getTransactions().map((transaction) => {
-            return CreateTransactionFromEmbeddedTransactionBuilder(transaction as EmbeddedTransactionBuilder) as InnerTransaction;
+            return CreateTransactionFromEmbeddedTransactionBuilder(transaction as EmbeddedTransactionBuilder);
         });
 
         return builder.getType().valueOf() === TransactionType.AGGREGATE_COMPLETE ?
@@ -173,11 +172,11 @@ export class AggregateTransaction extends Transaction {
 
     /**
      * @description add inner transactions to current list
-     * @param {InnerTransaction[]} transactions the transactions to be added
+     * @param {Transaction[]} transactions the transactions to be added
      * @returns {AggregateTransaction}
      * @memberof AggregateTransaction
      */
-    public addTransactions(transactions: InnerTransaction[]): AggregateTransaction {
+    public addTransactions(transactions: Transaction[]): AggregateTransaction {
         const innerTransactions = this.innerTransactions.concat(transactions);
         return DtoMapping.assign(this, {innerTransactions});
     }
@@ -298,7 +297,7 @@ export class AggregateTransaction extends Transaction {
     protected generateBytes(): Uint8Array {
         const signerBuffer = new Uint8Array(32);
         const signatureBuffer = new Uint8Array(64);
-        const transactions = this.innerTransactions.map((transaction) => (transaction as Transaction).toEmbeddedTransaction());
+        const transactions = this.innerTransactions.map((transaction) => transaction.toEmbeddedTransaction());
         const cosignatures = this.cosignatures.map((cosignature) => {
             const signerBytes = Convert.hexToUint8(cosignature.signer.publicKey);
             const signatureBytes = Convert.hexToUint8(cosignature.signature);

src/model/transaction/AggregateTransaction.ts

@@ -26,7 +26,6 @@ import { Statement } from '../receipt/Statement';
 import { UInt64 } from '../UInt64';
 import { AggregateTransactionInfo } from './AggregateTransactionInfo';
 import { Deadline } from './Deadline';
-import { InnerTransaction } from './InnerTransaction';
 import { SignedTransaction } from './SignedTransaction';
 import { TransactionInfo } from './TransactionInfo';
 import { TransactionType } from './TransactionType';
@@ -273,9 +272,9 @@ export abstract class Transaction {
      * Signer is optional for `AggregateComplete` transaction `ONLY`.
      * If no signer provided, aggregate transaction signer will be delegated on signing
      * @param signer - Innre transaction signer.
-     * @returns InnerTransaction
+     * @returns Transaction
      */
-    public toAggregate(signer: PublicAccount): InnerTransaction {
+    public toAggregate(signer: PublicAccount): Transaction {
         if (this.type === TransactionType.AGGREGATE_BONDED || this.type === TransactionType.AGGREGATE_COMPLETE) {
             throw new Error('Inner transaction cannot be an aggregated transaction.');
         }

src/model/transaction/InnerTransaction.ts

@@ -20,9 +20,9 @@ import { TransactionMapping } from '../core/utils/TransactionMapping';
 import { MultisigRepository } from '../infrastructure/MultisigRepository';
 import { MultisigAccountGraphInfo } from '../model/account/MultisigAccountGraphInfo';
 import { AggregateTransaction } from '../model/transaction/AggregateTransaction';
-import { InnerTransaction } from '../model/transaction/InnerTransaction';
 import { MultisigAccountModificationTransaction } from '../model/transaction/MultisigAccountModificationTransaction';
 import { SignedTransaction } from '../model/transaction/SignedTransaction';
+import { Transaction } from '../model/transaction/Transaction';
 import { TransactionType } from '../model/transaction/TransactionType';
 
 /**
@@ -77,12 +77,12 @@ export class AggregateTransactionService {
      * Validate cosignatories against multisig Account(s)
      * @param graphInfo - multisig account graph info
      * @param cosignatories - array of cosignatories extracted from aggregated transaction
-     * @param innerTransaction - the inner transaction of the aggregated transaction
+     * @param transaction - the inner transaction of the aggregated transaction
      * @returns {boolean}
      */
     private validateCosignatories(graphInfo: MultisigAccountGraphInfo,
                                   cosignatories: string[],
-                                  innerTransaction: InnerTransaction): boolean {
+                                  transaction: Transaction): boolean {
         /**
          *  Validate cosignatories from bottom level to top
          */
@@ -96,8 +96,8 @@ export class AggregateTransactionService {
          * Check inner transaction. If remove cosigner from multisig account,
          * use minRemoval instead of minApproval for cosignatories validation.
          */
-        if (innerTransaction.type === TransactionType.MODIFY_MULTISIG_ACCOUNT) {
-            if ((innerTransaction as MultisigAccountModificationTransaction).publicKeyDeletions.length) {
+        if (transaction.type === TransactionType.MODIFY_MULTISIG_ACCOUNT) {
+            if ((transaction as MultisigAccountModificationTransaction).publicKeyDeletions.length) {
                         isMultisigRemoval = true;
             }
         }