#4

1. Addes service for Aggregated Transaction - isComplete
2. Fixed couple of bugs in TransactionMappings

Author: rg911

src/infrastructure/transaction/CreateTransactionFromPayload.ts

@@ -377,7 +377,7 @@ const CreateTransaction = (type: number, transactionData: string, networkType: N
                 networkType,
                 consignatureArray ? consignatureArray.map((cosignature) => new AggregateTransactionCosignature(
                     cosignature.substring(0, 64),
-                    PublicAccount.createFromPublicKey(cosignature.substring(64, 192), networkType),
+                    PublicAccount.createFromPublicKey(cosignature.substring(0, 64), networkType),
                 )) : [],
             );
         case TransactionType.AGGREGATE_BONDED:
@@ -401,7 +401,7 @@ const CreateTransaction = (type: number, transactionData: string, networkType: N
                 networkType,
                 bondedConsignatureArray ? bondedConsignatureArray.map((cosignature) => new AggregateTransactionCosignature(
                     cosignature.substring(0, 64),
-                    PublicAccount.createFromPublicKey(cosignature.substring(64, 192), networkType),
+                    PublicAccount.createFromPublicKey(cosignature.substring(0, 64), networkType),
                 )) : [],
             );
         default:
@@ -457,9 +457,9 @@ const parseInnerTransactionFromBinary = (innerTransactionBinary: string): string
 
     while (innerBinary.length) {
         const payloadSize = parseInt(convert.uint8ToHex(convert.hexToUint8(innerTransactionBinary.substring(0, 8)).reverse()), 16) * 2;
-        const innerTransaction = innerTransactionBinary.substring(8, 8 + payloadSize);
+        const innerTransaction = innerTransactionBinary.substring(8, payloadSize);
         embeddedTransaction.push(innerTransaction);
-        innerBinary = innerTransactionBinary.substring(8 + payloadSize);
+        innerBinary = innerBinary.substring(payloadSize);
     }
     return embeddedTransaction;
 };

src/service/AggregatedTransactionService.ts

@@ -0,0 +1,127 @@
+/*
+ * Copyright 2019 NEM
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {from as observableFrom , Observable, of as observableOf} from 'rxjs';
+import { map, mergeMap} from 'rxjs/operators';
+import { TransactionMapping } from '../core/utils/TransactionMapping';
+import { AccountHttp } from '../infrastructure/AccountHttp';
+import { MultisigAccountGraphInfo } from '../model/account/MultisigAccountGraphInfo';
+import { AggregateTransaction } from '../model/transaction/AggregateTransaction';
+import { SignedTransaction } from '../model/transaction/SignedTransaction';
+
+/**
+ * Aggregated Transaction service
+ */
+export class AggregatedTransactionService {
+
+    /**
+     * Constructor
+     * @param accountHttp
+     */
+    constructor(private readonly accountHttp: AccountHttp) {
+    }
+
+    /**
+     * Check if an aggregate complete transaction has all cosignatories attached
+     * @param signedTransaction - The signed aggregate transaction (complete) to be verified
+     * @returns {Observable<boolean>}
+     */
+    public isComplete(signedTransaction: SignedTransaction): Observable<boolean> {
+        const aggregateTransaction = TransactionMapping.createFromPayload(signedTransaction.payload) as AggregateTransaction;
+        /**
+         * Include both initiator & cosigners
+         */
+        const signers = (aggregateTransaction.cosignatures.map((cosigner) => cosigner.signer.publicKey));
+        if (signedTransaction.signer) {
+            signers.push(signedTransaction.signer);
+        }
+
+        return observableFrom(aggregateTransaction.innerTransactions).pipe(
+            mergeMap((innerTransaction) => this.accountHttp.getMultisigAccountInfo(innerTransaction.signer.address)
+                .pipe(
+                    /**
+                     * For multisig account, we need to get the graph info in case it has multiple levels
+                     */
+                    mergeMap((_) => _.minApproval !== 0 && _.minRemoval !== 0 ?
+                        this.accountHttp.getMultisigAccountGraphInfo(_.account.address)
+                        .pipe(
+                            map((graphInfo) => this.validateCosignatories(graphInfo, signers)),
+                        ) : observableOf(true),
+                        ),
+                    ),
+                ),
+            );
+    }
+
+    /**
+     * Validate cosignatories against multisig Account(s)
+     * @param graphInfo - multisig account graph info
+     * @param cosignatories - array of cosignatories extracted from aggregated transaction
+     * @returns {boolean}
+     */
+    private validateCosignatories(graphInfo: MultisigAccountGraphInfo, cosignatories: string[]): boolean {
+        /**
+         *  Validate cosignatories from bottom level to top
+         */
+        const sortedKeys = Array.from(graphInfo.multisigAccounts.keys()).sort((a, b) => b - a);
+        const cosignatoriesReceived = cosignatories;
+        let validationResult = true;
+
+        sortedKeys.forEach((key) => {
+            const multisigInfo = graphInfo.multisigAccounts.get(key);
+            if (multisigInfo && validationResult) {
+                multisigInfo.forEach((multisig) => {
+                    if (multisig.minApproval >= 1) {
+                        const matchedCosignatories = this.compareArrays(cosignatoriesReceived,
+                                        multisig.cosignatories.map((cosig) => cosig.publicKey));
+
+                        /**
+                         * if minimal signature requirement met at current level, push the multisig account
+                         * into the received signatories array for next level validation.
+                         * Otherwise return validation failed.
+                         */
+                        if (matchedCosignatories.length >= multisig.minApproval) {
+                            if (cosignatoriesReceived.indexOf(multisig.account.publicKey) === -1) {
+                                cosignatoriesReceived.push(multisig.account.publicKey);
+                              }
+                        } else {
+                            validationResult = false;
+                        }
+                    }
+                });
+            }
+        });
+
+        return validationResult;
+    }
+
+    /**
+     * Compare two string arrays
+     * @param array1 - base array
+     * @param array2 - array to be matched
+     * @returns {string[]} - array of matched elements
+     */
+    private compareArrays(array1: string[], array2: string[]): string[] {
+        const results: string[] = [];
+        array1.forEach((a1) => array2.forEach((a2) => {
+            if (a1 === a2) {
+                results.push(a1);
+            }
+        }));
+
+        return results;
+    }
+}

src/service/service.ts

@@ -16,3 +16,4 @@
 
 export * from './NamespaceService';
 export * from './MosaicService';
+export * from './AggregatedTransactionService';