fix: replaced instanceof statement (#819)

fix: fixed new Buffer warning.
fix: rxjs precated use

Co-authored-by: Steven Liu <[email protected]>

Author: fboucquez

CHANGELOG.md

@@ -4,14 +4,25 @@ All notable changes to this project will be documented in this file.
 
 The changelog format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
+## [1.0.3] - NEXT
+
+**Milestone**: Symbol Mainnet
+Package  | Version  | Link
+---|---|---
+SDK Core| v1.0.3 | [symbol-sdk](https://www.npmjs.com/package/symbol-sdk)
+Catbuffer | v1.0.1 | [catbuffer-typescript](https://www.npmjs.com/package/catbuffer-typescript)
+Client Library | v1.0.2  | [symbol-openapi-typescript-fetch-client](https://www.npmjs.com/package/symbol-openapi-typescript-fetch-client)
+
+- fix: replaced `instanceof` statements. These statements are problematic when npm installs the dependency in multiples modules. 
+
 ## [1.0.2] - 25-Oct-2021
 
 **Milestone**: Symbol Mainnet
 Package  | Version  | Link
 ---|---|---
 SDK Core| v1.0.2 | [symbol-sdk](https://www.npmjs.com/package/symbol-sdk)
 Catbuffer | v1.0.1 | [catbuffer-typescript](https://www.npmjs.com/package/catbuffer-typescript)
-Client Library | v1.0.1  | [symbol-openapi-typescript-fetch-client](https://www.npmjs.com/package/symbol-openapi-typescript-fetch-client)
+Client Library | v1.0.2 | [symbol-openapi-typescript-fetch-client](https://www.npmjs.com/package/symbol-openapi-typescript-fetch-client)
 
 - feat: Multisig multilevel subscription in web listener.
 - feat: Added Deployment data to `ServerInfo`.

package.json

@@ -10,6 +10,7 @@
         "e2e": "npm run bootstrap-stop && npm run bootstrap-start-detached && npm run test:e2e && npm run bootstrap-stop",
         "test:all": "mocha --ui bdd --recursive ./dist/ --timeout 90000 --unhandled-rejections=strict",
         "build": "shx rm -rf dist/ && tsc",
+        "watch": "tsc --watch",
         "test:cov": "nyc --reporter=lcov --reporter=text-summary npm t",
         "test:coveralls": "npm run test:cov | coveralls",
         "coveralls-report": "cat ./coverage/lcov.info | coveralls",

src/core/format/RawAddress.ts

@@ -83,7 +83,7 @@ export class RawAddress {
         const publicKeyHash = sha3_256.arrayBuffer(publicKey);
 
         // step 2: ripemd160 hash of (1)
-        const ripemdHash = new ripemd160().update(new Buffer(publicKeyHash)).digest();
+        const ripemdHash = new ripemd160().update(Buffer.from(publicKeyHash)).digest();
 
         // step 3: add network identifier byte in front of (2)
         const decodedAddress = new Uint8Array(RawAddress.constants.sizes.addressDecoded);

src/core/utils/UnresolvedMapping.ts

@@ -93,7 +93,7 @@ export class UnresolvedMapping {
      * @return {Uint8Array}
      */
     public static toUnresolvedAddressBytes(unresolvedAddress: UnresolvedAddress, networkType: NetworkType): Uint8Array {
-        if (unresolvedAddress instanceof NamespaceId) {
+        if (unresolvedAddress.isNamespaceId()) {
             // received hexadecimal notation of namespaceId (alias)
             return RawAddress.aliasToRecipient(Convert.hexToUint8((unresolvedAddress as NamespaceId).toHex()), networkType);
         } else {

src/infrastructure/Listener.ts

@@ -20,7 +20,7 @@ import { BlockInfoDTO } from 'symbol-openapi-typescript-fetch-client';
 import * as WebSocket from 'ws';
 import { parseObjectProperties } from '../core/format/Utilities';
 import { DtoMapping, MultisigChildrenTreeObject, MultisigGraphUtils } from '../core/utils';
-import { MultisigAccountInfo, UnresolvedAddress } from '../model';
+import { MultisigAccountInfo, NamespaceId, UnresolvedAddress } from '../model';
 import { Address } from '../model/account/Address';
 import { PublicAccount } from '../model/account/PublicAccount';
 import { FinalizedBlock } from '../model/blockchain/FinalizedBlock';
@@ -270,7 +270,6 @@ export class Listener implements IListener {
         return this.messageSubject.asObservable().pipe(
             share(),
             filter((_) => _.channelName === ListenerChannelName.block),
-            filter((_) => _.message instanceof NewBlock),
             map((_) => _.message as NewBlock),
         );
     }
@@ -287,7 +286,6 @@ export class Listener implements IListener {
         return this.messageSubject.asObservable().pipe(
             share(),
             filter((_) => _.channelName === ListenerChannelName.finalizedBlock),
-            filter((_) => _.message instanceof FinalizedBlock),
             map((_) => _.message as FinalizedBlock),
         );
     }
@@ -360,7 +358,6 @@ export class Listener implements IListener {
             switchMap((subscribers) => {
                 return this.messageSubject.asObservable().pipe(
                     filter((listenerMessage) => listenerMessage.channelName === channel),
-                    filter((listenerMessage) => listenerMessage.message instanceof Transaction),
                     distinctUntilChanged((prev, curr) => {
                         const currentHash = (curr.message as Transaction).transactionInfo!.hash;
                         const previousHash = (prev.message as Transaction).transactionInfo!.hash;
@@ -470,7 +467,6 @@ export class Listener implements IListener {
                 this.subscribeTo(`status/${address.plain()}`);
                 return this.messageSubject.asObservable().pipe(
                     filter((_) => _.channelName === ListenerChannelName.status),
-                    filter((_) => _.message instanceof TransactionStatusError),
                     filter((_) => _.channelParam.toUpperCase() === address.plain()),
                     map((_) => _.message as TransactionStatusError),
                     filter((_) => !transactionHash || _.hash.toUpperCase() == transactionHash.toUpperCase()),
@@ -507,7 +503,6 @@ export class Listener implements IListener {
             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),
                 );
@@ -535,20 +530,18 @@ export class Listener implements IListener {
      * @returns {Address}
      */
     private getResolvedAddress(unresolvedAddress: UnresolvedAddress): Observable<Address> {
-        if (unresolvedAddress instanceof Address) {
-            return of(unresolvedAddress);
+        if (unresolvedAddress.isAddress()) {
+            return of(unresolvedAddress as Address);
         }
 
-        return this.namespaceRepository.getLinkedAddress(unresolvedAddress).pipe(
+        const namespaceId = unresolvedAddress as NamespaceId;
+        return this.namespaceRepository.getLinkedAddress(namespaceId).pipe(
             map((address) => {
                 if (!address) {
-                    throw new Error(`Invalid unresolvedAddress: ${unresolvedAddress.toHex()}`);
+                    throw new Error(`Invalid unresolvedAddress: ${namespaceId.toHex()}`);
                 }
                 return address;
             }),
-            catchError((err) => {
-                throw new Error(err);
-            }),
         );
     }
 

src/model/UInt64.ts

@@ -136,7 +136,7 @@ export class UInt64 {
      * @returns {boolean}
      */
     public equals(other: UInt64): boolean {
-        return this.lower === other.lower && this.higher === other.higher;
+        return other && this.lower === other.lower && this.higher === other.higher;
     }
 
     /**

src/model/account/Address.ts

@@ -139,10 +139,7 @@ export class Address {
      * @returns {boolean}
      */
     public equals(address: any): boolean {
-        if (address instanceof Address) {
-            return this.plain() === address.plain() && this.networkType === address.networkType;
-        }
-        return false;
+        return address && this.address == address.address && this.networkType === address.networkType;
     }
 
     /**
@@ -167,8 +164,27 @@ export class Address {
      * zero padded.
      * @returns {Uint8Array}
      */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    public encodeUnresolvedAddress(networkType: NetworkType): Uint8Array {
+    public encodeUnresolvedAddress(): Uint8Array {
         return Convert.hexToUint8(this.encoded());
     }
+
+    /**
+     * returns that this instance is a resolved, not an alias, address.
+     */
+    public isNamespaceId(): boolean {
+        return false;
+    }
+    /**
+     * returns that the instance is an address
+     */
+    public isAddress(): boolean {
+        return true;
+    }
+
+    /**
+     * returns that the instance is not a mosaic id
+     */
+    public isMosaicId(): boolean {
+        return false;
+    }
 }

src/model/account/UnresolvedAddress.ts

@@ -14,10 +14,21 @@
  * limitations under the License.
  */
 
-import { NamespaceId } from '../namespace/NamespaceId';
+import { NamespaceId } from '../namespace';
 import { Address } from './Address';
 
 /**
  * Custom type for unresolved address
  */
-export type UnresolvedAddress = Address | NamespaceId;
+export type UnresolvedAddress = (Address | NamespaceId) & {
+    /**
+     * returns if the object is instance of NamespaceId.
+     * It avoid the `instanceof` issue when the sdk lib is referenced from multiple modules
+     */
+    isNamespaceId(): boolean;
+    /**
+     * returns if the object is instance of Address.
+     * It avoid the `instanceof` issue when the sdk lib is referenced from multiple modules
+     */
+    isAddress(): boolean;
+};

src/model/mosaic/MosaicId.ts

@@ -79,10 +79,7 @@ export class MosaicId {
      * @return boolean
      */
     public equals(other: any): boolean {
-        if (other instanceof MosaicId) {
-            return this.id.equals(other.id);
-        }
-        return false;
+        return other && this.id.equals(other.id);
     }
 
     /**
@@ -91,4 +88,24 @@ export class MosaicId {
     toBuilder(): MosaicIdDto {
         return new MosaicIdDto(this.id.toDTO());
     }
+
+    /**
+     * returns that this instance is an alias.
+     */
+    public isNamespaceId(): boolean {
+        return false;
+    }
+    /**
+     * returns that the instance is not address
+     */
+    public isAddress(): boolean {
+        return false;
+    }
+
+    /**
+     * returns that the instance is a mosaic id
+     */
+    public isMosaicId(): boolean {
+        return true;
+    }
 }

src/model/mosaic/UnresolvedMosaicId.ts

@@ -14,10 +14,21 @@
  * limitations under the License.
  */
 
-import { NamespaceId } from '../namespace/NamespaceId';
+import { NamespaceId } from '../namespace';
 import { MosaicId } from './MosaicId';
 
 /**
  * Custom type for unresolved mosaicId
  */
-export type UnresolvedMosaicId = MosaicId | NamespaceId;
+export type UnresolvedMosaicId = (MosaicId | NamespaceId) & {
+    /**
+     * returns if the object is instance of NamespaceId.
+     * It avoid the `instanceof` issue when the sdk lib is referenced from multiple modules
+     */
+    isNamespaceId(): boolean;
+    /**
+     * returns if the object is instance of MosaicId.
+     * It avoid the `instanceof` issue when the sdk lib is referenced from multiple modules
+     */
+    isMosaicId(): boolean;
+};

src/model/namespace/AddressAlias.ts

@@ -43,10 +43,7 @@ export class AddressAlias extends Alias {
      * @return boolean
      */
     public equals(alias: any): boolean {
-        if (alias instanceof AddressAlias) {
-            return this.address.equals(alias.address);
-        }
-        return false;
+        return alias && alias.type === this.type && this.address.equals(alias.address);
     }
 
     /**

src/model/namespace/EmptyAlias.ts

@@ -43,7 +43,7 @@ export class EmptyAlias extends Alias {
      * @return boolean
      */
     public equals(alias: any): boolean {
-        return alias instanceof EmptyAlias || alias.type === 0;
+        return alias && alias.type === this.type;
     }
 
     /**

src/model/namespace/MosaicAlias.ts

@@ -42,10 +42,7 @@ export class MosaicAlias extends Alias {
      * @return boolean
      */
     public equals(alias: any): boolean {
-        if (alias instanceof MosaicAlias) {
-            return this.mosaicId.equals(alias.mosaicId);
-        }
-        return false;
+        return alias && alias.type === this.type && this.mosaicId.equals(alias.mosaicId);
     }
 
     /**

src/model/namespace/NamespaceId.ts

@@ -76,10 +76,7 @@ export class NamespaceId {
      * @return boolean
      */
     public equals(id: any): boolean {
-        if (id instanceof NamespaceId) {
-            return this.id.equals(id.id);
-        }
-        return false;
+        return id && this.id.equals(id.id);
     }
 
     /**
@@ -114,4 +111,25 @@ export class NamespaceId {
     public plain(): string {
         return this.toHex();
     }
+
+    /**
+     * returns that this instance is an alias.
+     */
+    public isNamespaceId(): boolean {
+        return true;
+    }
+
+    /**
+     * returns that the instance is not address
+     */
+    public isAddress(): boolean {
+        return false;
+    }
+
+    /**
+     * returns that the instance is not a mosaic id
+     */
+    public isMosaicId(): boolean {
+        return false;
+    }
 }

src/model/node/NodeVersion.ts

@@ -102,12 +102,10 @@ export class NodeVersion {
     public formatted(): string {
         const placeholderHex = '00000000';
         const hexNodeVersion = (placeholderHex + this.nodeVersion.toString(16)).slice(-8);
-        const formattedNodeVersion = hexNodeVersion
+        return hexNodeVersion
             .match(/.{1,2}/g)!
             .map((hex) => parseInt(hex, 16))
             .join('.');
-
-        return formattedNodeVersion;
     }
 
     /**
@@ -124,10 +122,6 @@ export class NodeVersion {
      * @returns {boolean}
      */
     public equals(nodeVersion: any): boolean {
-        if (nodeVersion instanceof NodeVersion) {
-            return this.nodeVersion === nodeVersion.raw();
-        }
-
-        return false;
+        return nodeVersion && this.nodeVersion === nodeVersion.nodeVersion;
     }
 }

src/model/receipt/ArtifactExpiryReceipt.ts

@@ -15,8 +15,8 @@
  */
 
 import { MosaicExpiryReceiptBuilder, NamespaceExpiryReceiptBuilder } from 'catbuffer-typescript';
-import { MosaicId } from '../mosaic/MosaicId';
-import { UnresolvedMosaicId } from '../mosaic/UnresolvedMosaicId';
+import { MosaicId, UnresolvedMosaicId } from '../mosaic';
+import { NamespaceId } from '../namespace';
 import { Receipt } from './Receipt';
 import { ReceiptType } from './ReceiptType';
 import { ReceiptVersion } from './ReceiptVersion';
@@ -42,17 +42,17 @@ export class ArtifactExpiryReceipt extends Receipt {
      * @return {Uint8Array}
      */
     public serialize(): Uint8Array {
-        if (this.artifactId instanceof MosaicId) {
+        if (!this.artifactId.isNamespaceId()) {
             return new MosaicExpiryReceiptBuilder(
                 ReceiptVersion.ARTIFACT_EXPIRY,
                 this.type.valueOf(),
-                this.artifactId.toBuilder(),
+                (this.artifactId as MosaicId).toBuilder(),
             ).serialize();
         }
         return new NamespaceExpiryReceiptBuilder(
             ReceiptVersion.ARTIFACT_EXPIRY,
             this.type.valueOf(),
-            this.artifactId.toBuilder(),
+            (this.artifactId as NamespaceId).toBuilder(),
         ).serialize();
     }
 }