Merge branch 'master' into task/g56_expose_serialization_methods

Author: Grégory Saive

e2e/infrastructure/Listener.spec.ts

@@ -154,4 +154,16 @@ describe('Listener', () => {
             TransactionUtils.createAndAnnounceWithInsufficientBalance();
         }, 1000);
     });
+
+    it('multisigAccountAdded', (done) => {
+        listener.multisigAccountAdded(account.address)
+            .toPromise()
+            .then((res) => {
+                done();
+            });
+
+        setTimeout(() => {
+            TransactionUtils.createModifyMultisigAccountTransaction(account);
+        }, 1000);
+    });
 });

e2e/infrastructure/TransactionUtils.ts

@@ -17,11 +17,15 @@ import {ChronoUnit} from 'js-joda';
 import {TransactionHttp} from '../../src/infrastructure/TransactionHttp';
 import {Account} from '../../src/model/account/Account';
 import {Address} from '../../src/model/account/Address';
+import { PublicAccount } from '../../src/model/account/PublicAccount';
 import {NetworkType} from '../../src/model/blockchain/NetworkType';
 import {NetworkCurrencyMosaic} from '../../src/model/mosaic/NetworkCurrencyMosaic';
 import {AggregateTransaction} from '../../src/model/transaction/AggregateTransaction';
 import {CosignatureTransaction} from '../../src/model/transaction/CosignatureTransaction';
 import {Deadline} from '../../src/model/transaction/Deadline';
+import { ModifyMultisigAccountTransaction } from '../../src/model/transaction/ModifyMultisigAccountTransaction';
+import { MultisigCosignatoryModification } from '../../src/model/transaction/MultisigCosignatoryModification';
+import { MultisigCosignatoryModificationType } from '../../src/model/transaction/MultisigCosignatoryModificationType';
 import {PlainMessage} from '../../src/model/transaction/PlainMessage';
 import {TransferTransaction} from '../../src/model/transaction/TransferTransaction';
 import {CosignatoryAccount, MultisigAccount, NIS2_URL, TestingAccount} from '../../test/conf/conf.spec';
@@ -82,4 +86,20 @@ export class TransactionUtils {
         const cosignatureSignedTransaction = account.signCosignatureTransaction(cosignatureTransaction);
         transactionHttp.announceAggregateBondedCosignature(cosignatureSignedTransaction);
     }
+
+    public static createModifyMultisigAccountTransaction( account: Account,
+                                                          transactionHttp: TransactionHttp = new TransactionHttp(NIS2_URL)) {
+        const modifyMultisig = ModifyMultisigAccountTransaction.create(
+            Deadline.create(),
+            2,
+            1,
+            [new MultisigCosignatoryModification(
+                MultisigCosignatoryModificationType.Add,
+                PublicAccount.createFromPublicKey(account.publicKey, NetworkType.MIJIN_TEST),
+            )],
+            NetworkType.MIJIN_TEST,
+        );
+        const signedTransaction = account.sign(modifyMultisig);
+        transactionHttp.announce(signedTransaction);
+    }
 }

src/infrastructure/AccountRepository.ts

@@ -23,6 +23,7 @@ import {PublicAccount} from '../model/account/PublicAccount';
 import {AggregateTransaction} from '../model/transaction/AggregateTransaction';
 import {Transaction} from '../model/transaction/Transaction';
 import {QueryParams} from './QueryParams';
+import {AccountPropertiesInfo} from "../model/account/AccountPropertiesInfo";
 
 /**
  * Account interface repository.
@@ -45,6 +46,20 @@ export interface AccountRepository {
      */
     getAccountsInfo(addresses: Address[]): Observable<AccountInfo[]>;
 
+    /**
+     * Gets Account property.
+     * @param publicAccount public account
+     * @returns Observable<AccountProperty>
+     */
+    getAccountProperty(publicAccount: PublicAccount): Observable<AccountPropertiesInfo>;
+
+    /**
+     * Gets Account properties.
+     * @param address list of addresses
+     * @returns Observable<AccountProperty[]>
+     */
+    getAccountProperties(addresses: Address[]): Observable<AccountPropertiesInfo[]>;
+
     /**
      * Gets a MultisigAccountInfo for an account.
      * @param address - User address

src/infrastructure/Listener.ts

@@ -26,6 +26,9 @@ import {AggregateTransactionCosignature} from '../model/transaction/AggregateTra
 import {CosignatureSignedTransaction} from '../model/transaction/CosignatureSignedTransaction';
 import {Deadline} from '../model/transaction/Deadline';
 import {InnerTransaction} from '../model/transaction/InnerTransaction';
+import {ModifyMultisigAccountTransaction} from '../model/transaction/ModifyMultisigAccountTransaction';
+import {MultisigCosignatoryModification} from '../model/transaction/MultisigCosignatoryModification';
+import {MultisigCosignatoryModificationType} from '../model/transaction/MultisigCosignatoryModificationType';
 import {Transaction} from '../model/transaction/Transaction';
 import {TransactionStatusError} from '../model/transaction/TransactionStatusError';
 import {TransferTransaction} from '../model/transaction/TransferTransaction';
@@ -40,6 +43,7 @@ enum ListenerChannelName {
     aggregateBondedAdded = 'partialAdded',
     aggregateBondedRemoved = 'partialRemoved',
     cosignature = 'cosignature',
+    modifyMultisigAccount = 'modifyMultisigAccount',
     status = 'status',
 }
 
@@ -288,6 +292,24 @@ export class Listener {
             map((_) => _.message as string));
     }
 
+    /**
+     * Return an observable of {@link ModifyMultisigAccountTransaction} for specific address which has been added to multi signatories.
+     * Each time an modify multi signatures transaction is announced,
+     * it emits a new {@link ModifyMultisigAccountTransaction} in the event stream.
+     *
+     * @param address address we listen when a transaction with missing signatures state
+     * @return an observable stream of ModifyMultisigAccountTransaction with missing signatures state
+     */
+    public multisigAccountAdded(address: Address): Observable<ModifyMultisigAccountTransaction> {
+        this.subscribeTo(`modifyMultisigAccount/${address.plain()}`);
+        return this.messageSubject.asObservable().pipe(
+            filter((_) => _.channelName === ListenerChannelName.modifyMultisigAccount),
+            filter((_) => _.message instanceof ModifyMultisigAccountTransaction),
+            map((_) => _.message as ModifyMultisigAccountTransaction),
+            filter((_) => this.accountAddedToMultiSig(_, address)),
+        );
+    }
+
     /**
      * Returns an observable stream of {@link TransactionStatusError} for specific address.
      * Each time a transaction contains an error,
@@ -388,4 +410,23 @@ export class Listener {
             && (transaction.recipient as Address).equals(address)
         );
     }
+
+    /**
+     * @internal
+     * Filters if an account has been added to multi signatories
+     * @param transaction - Transaction object
+     * @param address - Address
+     * @returns boolean
+     */
+    // tslint:disable-next-line:adjacent-overload-signatures
+    private accountAddedToMultiSig(transaction: Transaction, address: Address): boolean {
+        if (transaction instanceof ModifyMultisigAccountTransaction) {
+            transaction.modifications.map((_: MultisigCosignatoryModification) => {
+                if (_.type === MultisigCosignatoryModificationType.Add && _.cosignatoryPublicAccount.address.equals(address)) {
+                    return true;
+                }
+            });
+        }
+        return false;
+    }
 }

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -240,9 +240,9 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             extractTransactionVersion(transactionDTO.version),
             Deadline.createFromDTO(transactionDTO.deadline),
             new UInt64(transactionDTO.fee || [0, 0]),
-            transactionDTO.actionType,
-            transactionDTO.namespaceId,
-            transactionDTO.mosaicId,
+            transactionDTO.aliasAction,
+            new NamespaceId(transactionDTO.namespaceId),
+            new MosaicId(transactionDTO.mosaicId),
             transactionDTO.signature,
             PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
             transactionInfo,
@@ -253,9 +253,9 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             extractTransactionVersion(transactionDTO.version),
             Deadline.createFromDTO(transactionDTO.deadline),
             new UInt64(transactionDTO.fee || [0, 0]),
-            transactionDTO.actionType,
-            transactionDTO.namespaceId,
-            transactionDTO.address,
+            transactionDTO.aliasAction,
+            new NamespaceId(transactionDTO.namespaceId),
+            extractRecipient(transactionDTO.address) as Address,
             transactionDTO.signature,
             PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
             transactionInfo,