Fixed #760 (#761)

- Removed NamespaceName api call
- filter transaction by unrsolved address

Author: rg911

src/infrastructure/Listener.ts

@@ -14,16 +14,15 @@
  * limitations under the License.
  */
 
-import { Observable, of, OperatorFunction, Subject } from 'rxjs';
-import { catchError, filter, flatMap, map, mergeMap, share, switchMap } from 'rxjs/operators';
+import { Observable, of, Subject } from 'rxjs';
+import { catchError, filter, map, mergeMap, share, switchMap } from 'rxjs/operators';
 import { BlockInfoDTO } from 'symbol-openapi-typescript-fetch-client';
 import * as WebSocket from 'ws';
 import { UnresolvedAddress } from '../model';
 import { Address } from '../model/account/Address';
 import { PublicAccount } from '../model/account/PublicAccount';
 import { FinalizedBlock } from '../model/blockchain/FinalizedBlock';
 import { NewBlock } from '../model/blockchain/NewBlock';
-import { NamespaceName } from '../model/namespace/NamespaceName';
 import { AggregateTransaction } from '../model/transaction/AggregateTransaction';
 import { CosignatureSignedTransaction } from '../model/transaction/CosignatureSignedTransaction';
 import { Deadline } from '../model/transaction/Deadline';
@@ -335,24 +334,25 @@ export class Listener implements IListener {
         transactionHash?: string,
         subscribeMultisig = false,
     ): Observable<T> {
-        return this.getResolvedAddress(unresolvedAddress).pipe(
-            mergeMap((address: Address) => {
-                return this.subscribeWithMultig(address, channel, subscribeMultisig).pipe(
-                    switchMap((subscribers) => {
-                        return this.messageSubject.asObservable().pipe(
-                            filter((listenerMessage) => listenerMessage.channelName === channel),
-                            filter((listenerMessage) => listenerMessage.message instanceof Transaction),
-                            switchMap((_) => {
-                                const transactionObservable = of(_.message as T).pipe(
-                                    filter((transaction) => this.filterHash(transaction, transactionHash)),
-                                );
-                                if (subscribers.includes(_.channelParam.toUpperCase())) {
-                                    return transactionObservable;
-                                } else {
-                                    return transactionObservable.pipe(this.filterByNotifyAccount(address));
-                                }
-                            }),
+        return this.subscribeWithMultig(unresolvedAddress, channel, subscribeMultisig).pipe(
+            switchMap((subscribers) => {
+                return this.messageSubject.asObservable().pipe(
+                    filter((listenerMessage) => listenerMessage.channelName === channel),
+                    filter((listenerMessage) => listenerMessage.message instanceof Transaction),
+                    switchMap((_) => {
+                        const transactionObservable = of(_.message as T).pipe(
+                            filter((transaction) => this.filterHash(transaction, transactionHash)),
                         );
+                        if (subscribers.includes(_.channelParam.toUpperCase())) {
+                            return transactionObservable;
+                        } else {
+                            return transactionObservable.pipe(
+                                filter(
+                                    (transaction) =>
+                                        transaction.isSigned(unresolvedAddress) || transaction.shouldNotifyAccount(unresolvedAddress),
+                                ),
+                            );
+                        }
                     }),
                 );
             }),
@@ -414,18 +414,14 @@ export class Listener implements IListener {
         transactionHash: string | undefined,
         subscribeMultisig = false,
     ): Observable<string> {
-        return this.getResolvedAddress(unresolvedAddress).pipe(
-            mergeMap((address: Address) => {
-                return this.subscribeWithMultig(address, channel, subscribeMultisig).pipe(
-                    switchMap((subscribers) => {
-                        return this.messageSubject.asObservable().pipe(
-                            filter((_) => _.channelName === channel),
-                            filter((_) => typeof _.message === 'string'),
-                            filter((_) => subscribers.includes(_.channelParam.toUpperCase())),
-                            map((_) => _.message as string),
-                            filter((_) => !transactionHash || _.toUpperCase() == transactionHash.toUpperCase()),
-                        );
-                    }),
+        return this.subscribeWithMultig(unresolvedAddress, channel, subscribeMultisig).pipe(
+            switchMap((subscribers) => {
+                return this.messageSubject.asObservable().pipe(
+                    filter((_) => _.channelName === channel),
+                    filter((_) => typeof _.message === 'string'),
+                    filter((_) => subscribers.includes(_.channelParam.toUpperCase())),
+                    map((_) => _.message as string),
+                    filter((_) => !transactionHash || _.toUpperCase() == transactionHash.toUpperCase()),
                 );
             }),
         );
@@ -469,39 +465,6 @@ export class Listener implements IListener {
         }
     }
 
-    /**
-     * It filters a transaction by address using the aliases.
-     *
-     * This method delegates the rest loading as much as possible. It tries to filter by signer first.
-     *
-     * Note: this filter performs one extra rest call and it should be down in the pipeline.
-     *
-     * @param address the address.
-     * @return an observable filter.
-     */
-    private filterByNotifyAccount<T extends Transaction>(address: Address): OperatorFunction<T, T> {
-        return (transactionObservable): Observable<T> => {
-            return transactionObservable.pipe(
-                flatMap((transaction) => {
-                    if (transaction.isSigned(address)) {
-                        return of(transaction);
-                    }
-                    const namespaceIdsObservable = this.namespaceRepository.getAccountsNames([address]).pipe(
-                        map((names) => {
-                            return ([] as NamespaceName[])
-                                .concat(...Array.from(names.map((accountName) => accountName.names)))
-                                .map((name) => name.namespaceId);
-                        }),
-                    );
-                    return namespaceIdsObservable.pipe(
-                        filter((namespaceIds) => transaction.shouldNotifyAccount(address, namespaceIds)),
-                        map(() => transaction),
-                    );
-                }),
-            );
-        };
-    }
-
     /**
      * Returns an observable stream of {@link CosignatureSignedTransaction} for specific address.
      * Each time a cosigner signs a transaction the address initialized,
@@ -512,17 +475,13 @@ export class Listener implements IListener {
      * @return an observable stream of {@link CosignatureSignedTransaction}
      */
     public cosignatureAdded(unresolvedAddress: UnresolvedAddress, subscribeMultisig = false): Observable<CosignatureSignedTransaction> {
-        return this.getResolvedAddress(unresolvedAddress).pipe(
-            mergeMap((address: Address) => {
-                return this.subscribeWithMultig(address, ListenerChannelName.cosignature, subscribeMultisig).pipe(
-                    switchMap((subscribers) => {
-                        return this.messageSubject.asObservable().pipe(
-                            filter((_) => _.channelName.toUpperCase() === ListenerChannelName.cosignature.toUpperCase()),
-                            filter((_) => _.message instanceof CosignatureSignedTransaction),
-                            filter((_) => subscribers.includes(_.channelParam.toUpperCase())),
-                            map((_) => _.message as CosignatureSignedTransaction),
-                        );
-                    }),
+        return this.subscribeWithMultig(unresolvedAddress, ListenerChannelName.cosignature, subscribeMultisig).pipe(
+            switchMap((subscribers) => {
+                return this.messageSubject.asObservable().pipe(
+                    filter((_) => _.channelName.toUpperCase() === ListenerChannelName.cosignature.toUpperCase()),
+                    filter((_) => _.message instanceof CosignatureSignedTransaction),
+                    filter((_) => subscribers.includes(_.channelParam.toUpperCase())),
+                    map((_) => _.message as CosignatureSignedTransaction),
                 );
             }),
         );
@@ -604,22 +563,26 @@ export class Listener implements IListener {
      * @param multisig subscribe multisig account
      * @returns {string[]}
      */
-    private subscribeWithMultig(cosigner: Address, channel: ListenerChannelName, multisig = false): Observable<string[]> {
+    private subscribeWithMultig(cosigner: UnresolvedAddress, channel: ListenerChannelName, multisig = false): Observable<string[]> {
         if (!multisig) {
             this.subscribeTo(`${channel.toString()}/${cosigner.plain()}`);
             return of([cosigner.plain()]);
         }
-        return this.multisigRepository!.getMultisigAccountInfo(cosigner).pipe(
-            map((multisigInfo) => {
-                const subscribers = [cosigner].concat(multisigInfo.multisigAddresses);
-                subscribers.forEach((m) => {
-                    this.subscribeTo(`${channel.toString()}/${m.plain()}`);
-                });
-                return subscribers.map((m) => m.plain());
-            }),
-            catchError(() => {
-                this.subscribeTo(`${channel.toString()}/${cosigner.plain()}`);
-                return of([cosigner.plain()]);
+        return this.getResolvedAddress(cosigner).pipe(
+            mergeMap((address: Address) => {
+                return this.multisigRepository!.getMultisigAccountInfo(address).pipe(
+                    map((multisigInfo) => {
+                        const subscribers = [cosigner].concat(multisigInfo.multisigAddresses);
+                        subscribers.forEach((m) => {
+                            this.subscribeTo(`${channel.toString()}/${m.plain()}`);
+                        });
+                        return subscribers.map((m) => m.plain());
+                    }),
+                    catchError(() => {
+                        this.subscribeTo(`${channel.toString()}/${cosigner.plain()}`);
+                        return of([cosigner.plain()]);
+                    }),
+                );
             }),
         );
     }

src/model/namespace/NamespaceId.ts

@@ -106,4 +106,12 @@ export class NamespaceId {
     public encodeUnresolvedAddress(networkType: NetworkType): Uint8Array {
         return RawAddress.aliasToRecipient(Convert.hexToUint8(this.toHex()), networkType);
     }
+
+    /**
+     * Get string value of id
+     * @returns {string}
+     */
+    public plain(): string {
+        return this.toHex();
+    }
 }

src/model/transaction/AccountAddressRestrictionTransaction.ts

@@ -27,8 +27,7 @@ import {
 } from 'catbuffer-typescript';
 import { Convert } from '../../core/format';
 import { DtoMapping, UnresolvedMapping } from '../../core/utils';
-import { Address, PublicAccount, UnresolvedAddress } from '../account';
-import { NamespaceId } from '../namespace';
+import { PublicAccount, UnresolvedAddress } from '../account';
 import { NetworkType } from '../network';
 import { Statement } from '../receipt';
 import { AddressRestrictionFlag } from '../restriction';
@@ -201,14 +200,13 @@ export class AccountAddressRestrictionTransaction extends Transaction {
      * @internal
      * Check a given address should be notified in websocket channels
      * @param address address to be notified
-     * @param alias address alias (names)
      * @returns {boolean}
      */
-    public shouldNotifyAccount(address: Address, alias: NamespaceId[]): boolean {
+    public shouldNotifyAccount(address: UnresolvedAddress): boolean {
         return (
             super.isSigned(address) ||
-            this.restrictionAdditions.find((_) => _.equals(address) || alias.find((a) => _.equals(a)) !== undefined) !== undefined ||
-            this.restrictionDeletions.find((_) => _.equals(address) || alias.find((a) => _.equals(a)) !== undefined) !== undefined
+            this.restrictionAdditions.find((_) => _.equals(address)) !== undefined ||
+            this.restrictionDeletions.find((_) => _.equals(address)) !== undefined
         );
     }
 }

src/model/transaction/AccountKeyLinkTransaction.ts

@@ -24,7 +24,7 @@ import {
     TransactionBuilder,
 } from 'catbuffer-typescript';
 import { Convert } from '../../core/format';
-import { Address, PublicAccount } from '../account';
+import { Address, PublicAccount, UnresolvedAddress } from '../account';
 import { NetworkType } from '../network';
 import { UInt64 } from '../UInt64';
 import { Deadline } from './Deadline';
@@ -178,7 +178,7 @@ export class AccountKeyLinkTransaction extends Transaction {
      * @param address address to be notified
      * @returns {boolean}
      */
-    public shouldNotifyAccount(address: Address): boolean {
+    public shouldNotifyAccount(address: UnresolvedAddress): boolean {
         return super.isSigned(address) || Address.createFromPublicKey(this.linkedPublicKey, this.networkType).equals(address);
     }
 }

src/model/transaction/AccountMetadataTransaction.ts

@@ -25,10 +25,8 @@ import {
 } from 'catbuffer-typescript';
 import { Convert } from '../../core/format';
 import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
-import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
 import { UnresolvedAddress } from '../account/UnresolvedAddress';
-import { NamespaceId } from '../namespace/NamespaceId';
 import { NetworkType } from '../network/NetworkType';
 import { UInt64 } from '../UInt64';
 import { Deadline } from './Deadline';
@@ -203,14 +201,9 @@ export class AccountMetadataTransaction extends Transaction {
      * @internal
      * Check a given address should be notified in websocket channels
      * @param address address to be notified
-     * @param alias address alias (names)
      * @returns {boolean}
      */
-    public shouldNotifyAccount(address: Address, alias: NamespaceId[]): boolean {
-        return (
-            super.isSigned(address) ||
-            this.targetAddress.equals(address) ||
-            alias.find((name) => this.targetAddress.equals(name)) !== undefined
-        );
+    public shouldNotifyAccount(address: UnresolvedAddress): boolean {
+        return super.isSigned(address) || this.targetAddress.equals(address);
     }
 }

src/model/transaction/AggregateTransaction.ts

@@ -31,8 +31,7 @@ import { KeyPair, MerkleHashBuilder, SHA3Hasher } from '../../core/crypto';
 import { Convert } from '../../core/format';
 import { DtoMapping } from '../../core/utils';
 import { CreateTransactionFromPayload } from '../../infrastructure/transaction';
-import { Account, Address, PublicAccount } from '../account';
-import { NamespaceId } from '../namespace';
+import { Account, PublicAccount, UnresolvedAddress } from '../account';
 import { NetworkType } from '../network';
 import { Statement } from '../receipt';
 import { UInt64 } from '../UInt64';
@@ -396,15 +395,13 @@ export class AggregateTransaction extends Transaction {
      * @internal
      * Check a given address should be notified in websocket channels
      * @param address address to be notified
-     * @param alias address alias (names)
      * @returns {boolean}
      */
-    public shouldNotifyAccount(address: Address, alias: NamespaceId[]): boolean {
+    public shouldNotifyAccount(address: UnresolvedAddress): boolean {
         return (
             super.isSigned(address) ||
             this.cosignatures.find((_) => _.signer.address.equals(address)) !== undefined ||
-            this.innerTransactions.find((innerTransaction: InnerTransaction) => innerTransaction.shouldNotifyAccount(address, alias)) !==
-                undefined
+            this.innerTransactions.find((innerTransaction: InnerTransaction) => innerTransaction.shouldNotifyAccount(address)) !== undefined
         );
     }
 }

src/model/transaction/MosaicAddressRestrictionTransaction.ts

@@ -253,14 +253,9 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
      * @internal
      * Check a given address should be notified in websocket channels
      * @param address address to be notified
-     * @param alias address alias (names)
      * @returns {boolean}
      */
-    public shouldNotifyAccount(address: Address, alias: NamespaceId[]): boolean {
-        return (
-            super.isSigned(address) ||
-            this.targetAddress.equals(address) ||
-            alias.find((name) => this.targetAddress.equals(name)) !== undefined
-        );
+    public shouldNotifyAccount(address: UnresolvedAddress): boolean {
+        return super.isSigned(address) || this.targetAddress.equals(address);
     }
 }

src/model/transaction/MosaicMetadataTransaction.ts

@@ -27,11 +27,9 @@ import {
 import { Convert } from '../../core/format';
 import { DtoMapping } from '../../core/utils/DtoMapping';
 import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
-import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
 import { UnresolvedAddress } from '../account/UnresolvedAddress';
 import { UnresolvedMosaicId } from '../mosaic/UnresolvedMosaicId';
-import { NamespaceId } from '../namespace/NamespaceId';
 import { NetworkType } from '../network/NetworkType';
 import { Statement } from '../receipt/Statement';
 import { UInt64 } from '../UInt64';
@@ -228,14 +226,9 @@ export class MosaicMetadataTransaction extends Transaction {
      * @internal
      * Check a given address should be notified in websocket channels
      * @param address address to be notified
-     * @param alias address alias (names)
      * @returns {boolean}
      */
-    public shouldNotifyAccount(address: Address, alias: NamespaceId[]): boolean {
-        return (
-            super.isSigned(address) ||
-            this.targetAddress.equals(address) ||
-            alias.find((name) => this.targetAddress.equals(name)) !== undefined
-        );
+    public shouldNotifyAccount(address: UnresolvedAddress): boolean {
+        return super.isSigned(address) || this.targetAddress.equals(address);
     }
 }

src/model/transaction/MultisigAccountModificationTransaction.ts

@@ -25,10 +25,8 @@ import {
 } from 'catbuffer-typescript';
 import { Convert } from '../../core/format';
 import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
-import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
 import { UnresolvedAddress } from '../account/UnresolvedAddress';
-import { NamespaceId } from '../namespace/NamespaceId';
 import { NetworkType } from '../network/NetworkType';
 import { UInt64 } from '../UInt64';
 import { Deadline } from './Deadline';
@@ -217,14 +215,13 @@ export class MultisigAccountModificationTransaction extends Transaction {
      * @internal
      * Check a given address should be notified in websocket channels
      * @param address address to be notified
-     * @param alias address alias (names)
      * @returns {boolean}
      */
-    public shouldNotifyAccount(address: Address, alias: NamespaceId[]): boolean {
+    public shouldNotifyAccount(address: UnresolvedAddress): boolean {
         return (
             super.isSigned(address) ||
-            this.addressAdditions.find((_) => _.equals(address) || alias.find((a) => _.equals(a)) !== undefined) !== undefined ||
-            this.addressDeletions.find((_) => _.equals(address) || alias.find((a) => _.equals(a)) !== undefined) !== undefined
+            this.addressAdditions.find((_) => _.equals(address)) !== undefined ||
+            this.addressDeletions.find((_) => _.equals(address)) !== undefined
         );
     }
 }