9.6.1 with pagination on Transaction/Block/Mosaic (#601)

* Updated address (25 bytes => 24 bytes)

* 961 patch changes applied

* Added UnresolvedMosaicId

* Added A, I, Q, Y check on address

* Gernate MosaicId by address now

* - A few issues fixed.
- Integration tests fixed
- updated openAPI and catbuffer lib version

* mosaic test vector

* Fixed mosaic vector test

* Fixed mosaic id test vector tests

* - updated networkd properties fields
- added size to blockInfo

* Remvoed meta.id from createFromDto since all ids are from the top level

* - Updated openAPI version
- Fixed e2e tests

* Added MultisigAccounts.spect.ts

* - Updated opneAPI spec
- Split transaction search & get into 3
- Made 'group' mandatory in transactionSearchCriteria
- Added transactionStatus repository

* Fixed unit test

* Added some unit tests

* - Renamed TransactionSearchGroup ->  TransactionGroup
- Removed transactionGroup from getEffectiveFees
- Other PR comments fixed

* Fixed doc

* Improved test coverage

* - Added missing export
- More coverage improvment

* Fixed missing version in detached cosignature issue

* - Updated openAPI version
- Fixed a small issues in e2e tests

Co-authored-by: fernando <fboucquez@gmail.com>

Author: rg911

e2e/infrastructure/AccountHttp.spec.ts

@@ -134,7 +134,7 @@ describe('AccountHttp', () => {
                 Deadline.create(),
                 2,
                 1,
-                [cosignAccount1.publicAccount, cosignAccount2.publicAccount, cosignAccount3.publicAccount],
+                [cosignAccount1.address, cosignAccount2.address, cosignAccount3.address],
                 [],
                 networkType,
                 helper.maxFee,
@@ -177,21 +177,6 @@ describe('AccountHttp', () => {
         });
     });
 
-    describe('getMultisigAccountGraphInfo', () => {
-        it('should call getMultisigAccountGraphInfo successfully', async () => {
-            const multisigAccountGraphInfo = await multisigRepository
-                .getMultisigAccountGraphInfo(multisigAccount.publicAccount.address)
-                .toPromise();
-            expect(multisigAccountGraphInfo.multisigAccounts.get(0)![0].account.publicKey).to.be.equal(multisigAccount.publicKey);
-        });
-    });
-    describe('getMultisigAccountInfo', () => {
-        it('should call getMultisigAccountInfo successfully', async () => {
-            const multisigAccountInfo = await multisigRepository.getMultisigAccountInfo(multisigAccount.publicAccount.address).toPromise();
-            expect(multisigAccountInfo.account.publicKey).to.be.equal(multisigAccount.publicKey);
-        });
-    });
-
     describe('transactions', () => {
         it('should not return accounts when account does not exist', () => {
             return accountRepository
@@ -218,6 +203,21 @@ describe('AccountHttp', () => {
         });
     });
 
+    describe('getMultisigAccountGraphInfo', () => {
+        it('should call getMultisigAccountGraphInfo successfully', async () => {
+            await new Promise((resolve) => setTimeout(resolve, 3000));
+            const multisigAccountGraphInfo = await multisigRepository
+                .getMultisigAccountGraphInfo(multisigAccount.publicAccount.address)
+                .toPromise();
+            expect(multisigAccountGraphInfo.multisigEntries.get(0)![0].accountAddress.plain()).to.be.equal(multisigAccount.address.plain());
+        });
+    });
+    describe('getMultisigAccountInfo', () => {
+        it('should call getMultisigAccountInfo successfully', async () => {
+            const multisigAccountInfo = await multisigRepository.getMultisigAccountInfo(multisigAccount.publicAccount.address).toPromise();
+            expect(multisigAccountInfo.accountAddress.plain()).to.be.equal(multisigAccount.address.plain());
+        });
+    });
     /**
      * =========================
      * House Keeping
@@ -245,7 +245,7 @@ describe('AccountHttp', () => {
                 -1,
                 0,
                 [],
-                [cosignAccount1.publicAccount],
+                [cosignAccount1.address],
                 networkType,
                 helper.maxFee,
             );
@@ -254,7 +254,7 @@ describe('AccountHttp', () => {
                 0,
                 0,
                 [],
-                [cosignAccount2.publicAccount],
+                [cosignAccount2.address],
                 networkType,
                 helper.maxFee,
             );
@@ -264,7 +264,7 @@ describe('AccountHttp', () => {
                 -1,
                 -1,
                 [],
-                [cosignAccount3.publicAccount],
+                [cosignAccount3.address],
                 networkType,
                 helper.maxFee,
             );

e2e/infrastructure/BlockHttp.spec.ts

@@ -91,7 +91,7 @@ describe('BlockHttp', () => {
             expect(blockInfo.height.higher).to.be.equal(0);
             expect(blockInfo.timestamp.lower).to.be.equal(0);
             expect(blockInfo.timestamp.higher).to.be.equal(0);
-            expect(blockInfo.beneficiaryPublicKey).not.to.be.undefined;
+            expect(blockInfo.beneficiaryAddress).not.to.be.undefined;
             expect(blockInfo.numStatements).not.to.be.undefined;
         });
     });

e2e/infrastructure/IntegrationTestHelper.ts

@@ -108,7 +108,9 @@ export class IntegrationTestHelper {
                                 this.account3 = this.createAccount(parsedYaml.nemesis_addresses[2]);
                                 this.multisigAccount = this.createAccount(parsedYaml.nemesis_addresses[3]);
                                 this.cosignAccount1 = this.createAccount(parsedYaml.nemesis_addresses[4]);
-                                this.cosignAccount4 = this.createAccount(parsedYaml.nemesis_addresses[5]);
+                                this.cosignAccount2 = this.createAccount(parsedYaml.nemesis_addresses[5]);
+                                this.cosignAccount3 = this.createAccount(parsedYaml.nemesis_addresses[6]);
+                                this.cosignAccount4 = this.createAccount(parsedYaml.nemesis_addresses[7]);
                                 this.harvestingAccount = this.createAccount(parsedYaml.nemesis_addresses_harvesting[0]);
                                 return resolve(this);
                             }

e2e/infrastructure/Listener.spec.ts

@@ -15,21 +15,25 @@
  */
 import { assert, expect } from 'chai';
 import { ChronoUnit } from 'js-joda';
-import { filter } from 'rxjs/operators';
+import { filter, mergeMap } from 'rxjs/operators';
 import { TransactionRepository } from '../../src/infrastructure/TransactionRepository';
 import { Account } from '../../src/model/account/Account';
 import { PlainMessage } from '../../src/model/message/PlainMessage';
-import { Address, CosignatureTransaction, LockFundsTransaction, Mosaic, SignedTransaction, UInt64 } from '../../src/model/model';
-import { MosaicId } from '../../src/model/mosaic/MosaicId';
-import { NamespaceId } from '../../src/model/namespace/NamespaceId';
 import { NetworkType } from '../../src/model/network/NetworkType';
 import { AggregateTransaction } from '../../src/model/transaction/AggregateTransaction';
 import { Deadline } from '../../src/model/transaction/Deadline';
 import { MultisigAccountModificationTransaction } from '../../src/model/transaction/MultisigAccountModificationTransaction';
 import { TransferTransaction } from '../../src/model/transaction/TransferTransaction';
 import { IntegrationTestHelper } from './IntegrationTestHelper';
 import { TransactionSearchCriteria } from '../../src/infrastructure/searchCriteria/TransactionSearchCriteria';
-import { TransactionGroupSubsetEnum } from 'symbol-openapi-typescript-node-client';
+import { Address } from '../../src/model/account/Address';
+import { SignedTransaction } from '../../src/model/transaction/SignedTransaction';
+import { LockFundsTransaction } from '../../src/model/transaction/LockFundsTransaction';
+import { UInt64 } from '../../src/model/UInt64';
+import { Mosaic } from '../../src/model/mosaic/Mosaic';
+import { CosignatureTransaction } from '../../src/model/transaction/CosignatureTransaction';
+import { UnresolvedMosaicId } from '../../src/model/mosaic/UnresolvedMosaicId';
+import { TransactionGroup } from '../../src/infrastructure/TransactionGroup';
 
 describe('Listener', () => {
     const helper = new IntegrationTestHelper();
@@ -41,7 +45,6 @@ describe('Listener', () => {
     let cosignAccount3: Account;
     let generationHash: string;
     let networkType: NetworkType;
-    const NetworkCurrencyLocalId: NamespaceId = helper.networkCurrencyNamespaceId;
     let transactionRepository: TransactionRepository;
 
     before(() => {
@@ -92,7 +95,7 @@ describe('Listener', () => {
     const createHashLockTransactionAndAnnounce = (
         signedAggregatedTransaction: SignedTransaction,
         signer: Account,
-        mosaicId: MosaicId | NamespaceId,
+        mosaicId: UnresolvedMosaicId,
     ): void => {
         const lockFundsTransaction = LockFundsTransaction.create(
             Deadline.create(),
@@ -182,7 +185,7 @@ describe('Listener', () => {
             const transferTransaction = TransferTransaction.create(
                 Deadline.create(),
                 cosignAccount1.address,
-                [new Mosaic(NetworkCurrencyLocalId, UInt64.fromUint(10 * Math.pow(10, helper.networkCurrencyDivisibility)))],
+                [helper.createNetworkCurrency(10, true)],
                 PlainMessage.create('test-message'),
                 networkType,
                 helper.maxFee,
@@ -199,7 +202,7 @@ describe('Listener', () => {
                 Deadline.create(),
                 2,
                 1,
-                [cosignAccount1.publicAccount, cosignAccount2.publicAccount, cosignAccount3.publicAccount],
+                [cosignAccount1.address, cosignAccount2.address, cosignAccount3.address],
                 [],
                 networkType,
                 helper.maxFee,
@@ -225,7 +228,7 @@ describe('Listener', () => {
     describe('Aggregate Bonded Transactions', () => {
         it('aggregateBondedTransactionsAdded', (done) => {
             const signedAggregatedTx = createSignedAggregatedBondTransaction(multisigAccount, account, account2.address);
-            createHashLockTransactionAndAnnounce(signedAggregatedTx, account, NetworkCurrencyLocalId);
+            createHashLockTransactionAndAnnounce(signedAggregatedTx, account, helper.networkCurrencyNamespaceId);
             helper.listener.aggregateBondedAdded(account.address).subscribe(() => {
                 done();
             });
@@ -239,26 +242,34 @@ describe('Listener', () => {
             });
         });
     });
+
     describe('Aggregate Bonded Transactions', () => {
         it('aggregateBondedTransactionsRemoved', (done) => {
             const signedAggregatedTx = createSignedAggregatedBondTransaction(multisigAccount, cosignAccount1, account2.address);
-
-            createHashLockTransactionAndAnnounce(signedAggregatedTx, cosignAccount1, NetworkCurrencyLocalId);
+            createHashLockTransactionAndAnnounce(signedAggregatedTx, cosignAccount1, helper.networkCurrencyNamespaceId);
+            helper.listener.aggregateBondedRemoved(cosignAccount1.address, signedAggregatedTx.hash).subscribe(() => {
+                done();
+            });
             helper.listener.confirmed(cosignAccount1.address).subscribe(() => {
-                helper.listener.aggregateBondedRemoved(cosignAccount1.address).subscribe(() => {
-                    done();
-                });
                 helper.listener.aggregateBondedAdded(cosignAccount1.address).subscribe(() => {
                     const criteria: TransactionSearchCriteria = {
-                        address: cosignAccount1.publicAccount.address,
-                        group: TransactionGroupSubsetEnum.Partial,
+                        address: cosignAccount1.address,
+                        group: TransactionGroup.Partial,
+                        embedded: true,
                     };
-                    transactionRepository.search(criteria).subscribe((transactions) => {
-                        const transactionToCosign = transactions[0];
-                        const cosignatureTransaction = CosignatureTransaction.create(transactionToCosign);
-                        const cosignatureSignedTransaction = cosignAccount2.signCosignatureTransaction(cosignatureTransaction);
-                        transactionRepository.announceAggregateBondedCosignature(cosignatureSignedTransaction);
-                    });
+                    transactionRepository
+                        .search(criteria)
+                        .pipe(
+                            mergeMap((page) => {
+                                return transactionRepository.getTransaction(page.data[0].transactionInfo?.hash!, TransactionGroup.Partial);
+                            }),
+                        )
+                        .subscribe((transactions) => {
+                            const transactionToCosign = transactions as AggregateTransaction;
+                            const cosignatureTransaction = CosignatureTransaction.create(transactionToCosign);
+                            const cosignatureSignedTransaction = cosignAccount2.signCosignatureTransaction(cosignatureTransaction);
+                            transactionRepository.announceAggregateBondedCosignature(cosignatureSignedTransaction);
+                        });
                 });
                 helper.listener.status(cosignAccount1.address).subscribe((error) => {
                     console.log('Error:', error);
@@ -279,17 +290,17 @@ describe('Listener', () => {
         it('cosignatureAdded', (done) => {
             const signedAggregatedTx = createSignedAggregatedBondTransaction(multisigAccount, cosignAccount1, account2.address);
 
-            createHashLockTransactionAndAnnounce(signedAggregatedTx, cosignAccount1, NetworkCurrencyLocalId);
+            createHashLockTransactionAndAnnounce(signedAggregatedTx, cosignAccount1, helper.networkCurrencyNamespaceId);
             helper.listener.cosignatureAdded(cosignAccount1.address).subscribe(() => {
                 done();
             });
             helper.listener.aggregateBondedAdded(cosignAccount1.address).subscribe(() => {
                 const criteria: TransactionSearchCriteria = {
                     address: cosignAccount1.publicAccount.address,
-                    group: TransactionGroupSubsetEnum.Partial,
+                    group: TransactionGroup.Partial,
                 };
                 transactionRepository.search(criteria).subscribe((transactions) => {
-                    const transactionToCosign = transactions[0];
+                    const transactionToCosign = transactions.data[0] as AggregateTransaction;
                     const cosignatureTransaction = CosignatureTransaction.create(transactionToCosign);
                     const cosignatureSignedTransaction = cosignAccount2.signCosignatureTransaction(cosignatureTransaction);
                     transactionRepository.announceAggregateBondedCosignature(cosignatureSignedTransaction);
@@ -313,15 +324,15 @@ describe('Listener', () => {
                 -1,
                 0,
                 [],
-                [cosignAccount1.publicAccount],
+                [cosignAccount1.address],
                 networkType,
             );
             const removeCosigner2 = MultisigAccountModificationTransaction.create(
                 Deadline.create(),
                 0,
                 0,
                 [],
-                [cosignAccount2.publicAccount],
+                [cosignAccount2.address],
                 networkType,
             );
 
@@ -330,7 +341,7 @@ describe('Listener', () => {
                 -1,
                 -1,
                 [],
-                [cosignAccount3.publicAccount],
+                [cosignAccount3.address],
                 networkType,
             );
 
@@ -343,6 +354,7 @@ describe('Listener', () => {
                 ],
                 networkType,
                 [],
+                helper.maxFee,
             );
             const signedTransaction = aggregateTransaction.signTransactionWithCosignatories(
                 cosignAccount1,