Merge pull request #793 from symbol/dev

Dev -> Main

Author: rg911

.DS_Store

@@ -15,3 +15,4 @@ ts-docs/
 .travis
 *.iml
 *.log
+.npm-pack-all-tmp

.npmignore

@@ -4,6 +4,22 @@ 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.2] - 19-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)
+
+- feat: Multisig multilevel subscription in web listener.
+- feat: Added Deployment data to `ServerInfo`.
+- fix: Announce method missing observable map.
+- fix: Allowing plain base32 addresses in rest payloads. Both address formats are supported. 
+- fix: Cosigning from transaction hash only.
+- fix: Transaction signWith method broken into smaller methods.
+
 ## [1.0.1] - 24-May-2021
 
 **Milestone**: Symbol Mainnet

CHANGELOG.md

@@ -11,7 +11,7 @@ The Symbol SDK for TypeScript / JavaScript allows you to develop web, mobile, an
 
 ### _Catapult-Server_ Network Compatibility ([email protected])
 
-Symbol network launched [catapult-server](https://github.com/nemtech/catapult-server/releases/tag/v1.0.0.0), **it is recommended to use this package's 1.0.0 version and upwards for the Symbol public network**.
+Symbol network launched [catapult-client](https://github.com/symbol/catapult-client/releases/tag/v1.0.0.0), **it is recommended to use this package's 1.0.0 version and upwards for the Symbol public network**.
 
 Find the complete release notes [here](CHANGELOG.md).
 
@@ -40,7 +40,7 @@ Use the following available resources to get help:
 
 - [Symbol Documentation][docs]
 - [Symbol SDK Typescript/Javascript Reference][sdk-ref]
-- Join the community [slack group (#sig-api)][slack]
+- Join the community [Discord server][discord]
 - If you found a bug, [open a new issue][issues]
 
 ## Contributing
@@ -55,9 +55,9 @@ You can also find useful notes for developers under our documentation [guideline
 Copyright (c) 2018-present NEM
 Licensed under the [Apache License 2.0](LICENSE)
 
-[self]: https://github.com/nemtech/symbol-sdk-typescript-javascript
-[docs]: http://nemtech.github.io/getting-started/setup-workstation.html
-[issues]: https://github.com/nemtech/symbol-sdk-typescript-javascript/issues
-[sdk-ref]: https://nemtech.github.io/references/typescript-sdk.html
-[guidelines]: https://nemtech.github.io/contribute/contributing.html#sdk
-[slack]: https://join.slack.com/t/nem2/shared_invite/enQtMzY4MDc2NTg0ODgyLWZmZWRiMjViYTVhZjEzOTA0MzUyMTA1NTA5OWQ0MWUzNTA4NjM5OTJhOGViOTBhNjkxYWVhMWRiZDRkOTE0YmU
+[self]: https://github.com/symbol/symbol-sdk-typescript-javascript
+[docs]: http://docs.symbolplatform.com/getting-started/setup-workstation.html
+[issues]: https://github.com/symbol/symbol-sdk-typescript-javascript/issues
+[sdk-ref]: https://docs.symbolplatform.com/references/typescript-sdk.html
+[guidelines]: https://docs.symbolplatform.com/contribute/contributing.html#sdk
+[discord]: https://discord.com/invite/xymcity

README.md

@@ -98,7 +98,7 @@
     "dependencies": {
         "@js-joda/core": "^3.2.0",
         "bluebird": "^3.7.2",
-        "catbuffer-typescript": "0.1.1",
+        "catbuffer-typescript": "1.0.0",
         "crypto-js": "^4.0.0",
         "diff": "^4.0.2",
         "futoin-hkdf": "^1.3.2",
@@ -110,9 +110,9 @@
         "minimist": "^1.2.5",
         "node-fetch": "^2.6.0",
         "ripemd160": "^2.0.2",
-        "rxjs": "^6.6.3",
+        "rxjs": "^6.6.7",
         "rxjs-compat": "^6.6.3",
-        "symbol-openapi-typescript-fetch-client": "0.11.2",
+        "symbol-openapi-typescript-fetch-client": "^1.0.2",
         "tweetnacl": "^1.0.3",
         "utf8": "^2.1.2",
         "ws": "^7.3.1"

package-lock.json

@@ -173,3 +173,18 @@ export const decodeBlock = (input: any, inputOffset: number, output: any, output
     output[outputOffset + 3] = ((bytes[4] & 0x01) << 7) | (bytes[5] << 2) | (bytes[6] >> 3);
     output[outputOffset + 4] = ((bytes[6] & 0x07) << 5) | bytes[7];
 };
+
+/**
+ * Traverses the tree object to pick addresses strings.
+ * @param {array} array of multisig children
+ * @param {parse} function to parse tree and pick children addresses
+ */
+export const parseObjectProperties = (obj: [], parse): any => {
+    for (const k in obj) {
+        if (typeof obj[k] === 'object' && obj[k] !== null) {
+            parseObjectProperties(obj[k], parse);
+        } else if (Object.prototype.hasOwnProperty.call(obj, k)) {
+            parse(k, obj[k]);
+        }
+    }
+};

package.json

@@ -34,6 +34,7 @@ import { MerkleTreeBranch } from '../../model/state/MerkleTreeBranch';
 import { MerkleTreeBranchLink } from '../../model/state/MerkleTreeBranchLink';
 import { MerkleTreeLeaf } from '../../model/state/MerkleTreeLeaf';
 import { MerkleTreeNodeType } from '../../model/state/MerkleTreeNodeType';
+import { Convert } from '../format';
 
 export class DtoMapping {
     /**
@@ -45,7 +46,7 @@ export class DtoMapping {
         return new AccountRestrictions(
             accountRestrictions.accountRestrictions.version || 1,
             accountRestrictions['id'],
-            Address.createFromEncoded(accountRestrictions.accountRestrictions.address),
+            DtoMapping.toAddress(accountRestrictions.accountRestrictions.address),
             accountRestrictions.accountRestrictions.restrictions.map((prop) => {
                 const restrictionFlags = prop.restrictionFlags as number;
                 switch (restrictionFlags) {
@@ -55,7 +56,7 @@ export class DtoMapping {
                     case AddressRestrictionFlag.BlockOutgoingAddress:
                         return new AccountRestriction(
                             restrictionFlags,
-                            prop.values.map((value) => Address.createFromEncoded(value as string)),
+                            prop.values.map((value) => DtoMapping.toAddress(value as string)),
                         );
                     case MosaicRestrictionFlag.AllowMosaic:
                     case MosaicRestrictionFlag.BlockMosaic:
@@ -76,6 +77,22 @@ export class DtoMapping {
         );
     }
 
+    /**
+     * This method knows how to convert an address payload sent by Rest to Address.
+     *
+     * Currently rest sends hex encoded addresses, it is desired to use base32 encoded addresses.
+     *
+     * This method handles both format, encoded (deprecated) and base32 encoded addresses.
+     *
+     * Clients using this SDK will be able to process both payloads.
+     *
+     * @param value the address in encoded (6823BB7C3C089D996585466380EDBDC19D4959184893E38C) format or decoded/plain format (SB3KUBHATFCPV7UZQLWAQ2EUR6SIHBSBEOEDDDF3)
+     * @return the Address object.
+     */
+    public static toAddress(value: string): Address {
+        return Convert.isHexString(value, 48) ? Address.createFromEncoded(value) : Address.createFromRawAddress(value);
+    }
+
     /**
      * Creates a copy of the first object adding the attributes of the second object.
      * @param object the object to be cloned

src/core/format/Utilities.ts

@@ -0,0 +1,87 @@
+/*
+ * Copyright 2020 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 { MultisigAccountGraphInfo } from '../../model/account/MultisigAccountGraphInfo';
+import { MultisigAccountInfo } from '../../model/account/MultisigAccountInfo';
+
+/**
+ * MultisigGraph utilities
+ */
+
+// Type for Multisig Tree children Object
+export type MultisigChildrenTreeObject = {
+    address: string;
+    children: []; // children array.
+};
+
+export class MultisigGraphUtils {
+    /**
+     * creates a structred Tree object containing Current multisig account with children
+     * @param {MultisigAccountInfo[][]} multisigEnteries
+     * @returns {MultisigChildrenTreeObject[]} Array of multisigChildrentTree objects
+     */
+    public static getMultisigChildren(multisigAccountGraphInfoMapped: MultisigAccountInfo[][]): MultisigChildrenTreeObject[] {
+        if (multisigAccountGraphInfoMapped) {
+            const mappedTree: MultisigChildrenTreeObject[] = [];
+            multisigAccountGraphInfoMapped.forEach((level: MultisigAccountInfo[]) => {
+                level.forEach((entry: MultisigAccountInfo) => {
+                    mappedTree.push({
+                        address: entry.accountAddress.plain(),
+                        children: [],
+                    });
+                    // find the entry matching with address matching cosignatory address and update his children
+                    const updateRecursively = (address: string, object: MultisigChildrenTreeObject) => (obj): any => {
+                        if (obj.address === address) {
+                            obj.children.push(object);
+                        } else if (obj.children) {
+                            obj.children.forEach(updateRecursively(address, object));
+                        }
+                    };
+                    entry.cosignatoryAddresses.forEach((addressVal) => {
+                        mappedTree.forEach(
+                            updateRecursively(addressVal['address'], {
+                                address: entry.accountAddress.plain(),
+                                children: [],
+                            }),
+                        );
+                    });
+                });
+            });
+            return mappedTree;
+        }
+        return [];
+    }
+    /**
+     * sort entries based on tree hierarchy from top to bottom
+     * @param {Map<number, MultisigAccountInfo[]>} multisigEnteries
+     * @returns {MultisigAccountInfo[]}  sorted multisig graph
+     */
+    private static getMultisigGraphArraySorted(multisigEntries: Map<number, MultisigAccountInfo[]>): MultisigAccountInfo[][] {
+        return [...multisigEntries.keys()]
+            .sort((a, b) => b - a) // Get addresses from top to bottom
+            .map((key) => multisigEntries.get(key) || [])
+            .filter((x) => x.length > 0);
+    }
+    /**
+     * returns sorted tree entries
+     * @param {MultisigAccountGraphInfo} graphInfo
+     * @returns {MultisigAccountInfo[][]}  array of sorted multisigInfo
+     */
+    public static getMultisigInfoFromMultisigGraphInfo(graphInfo: MultisigAccountGraphInfo): MultisigAccountInfo[][] {
+        const { multisigEntries } = graphInfo;
+        return [...this.getMultisigGraphArraySorted(multisigEntries)].map((item) => item);
+    }
+}

src/core/utils/DtoMapping.ts

@@ -21,6 +21,7 @@ import { NamespaceId } from '../../model/namespace/NamespaceId';
 import { NetworkType } from '../../model/network/NetworkType';
 import { Convert } from '../format/Convert';
 import { RawAddress } from '../format/RawAddress';
+import { DtoMapping } from './DtoMapping';
 
 /**
  * @internal
@@ -48,26 +49,40 @@ export class UnresolvedMapping {
     }
 
     /**
-     * Map unresolved address string to Address or NamespaceId
-     * @param {string} address The unresolved address in hex
+     * Map unresolved address string to Address or NamespaceId.
+     *
+     * Input examples:
+     *  - 6826D27E1D0A26CA4E316F901E23E55C8711DB20DF45C536 Hex address (old rest)
+     *  - NATNE7Q5BITMUTRRN6IB4I7FLSDRDWZA35C4KNQ Base32 address (new reset)
+     *  - 99C2860B73398FD8D3000000000000000000000000000000 Hex namespace id (old rest)
+     *  - THBIMC3THGH5RUYAAAAAAAAAAAAAAAAAAAAAAAA Base32 namespace id (new rest)
+     *
+     * @param {string} unresolvedAddressString The unresolved address in hex (old rest) or base32 address (new rest)
      * @returns {UnresolvedAddress}
      */
-    public static toUnresolvedAddress(address: string): UnresolvedAddress {
-        if (!Convert.isHexString(address)) {
-            throw new Error('Input string is not in valid hexadecimal notation.');
-        }
-        // If bit 0 of byte 0 is not set (like in 0x90), then it is a regular address.
-        // Else (e.g. 0x91) it represents a namespace id which starts at byte 1.
-        const bit0 = Convert.hexToUint8(address.substr(1, 2))[0];
-        if ((bit0 & 16) === 16) {
-            // namespaceId encoded hexadecimal notation provided
-            // only 8 bytes are relevant to resolve the NamespaceId
-            const relevantPart = address.substr(2, 16);
-            return NamespaceId.createFromEncoded(Convert.uint8ToHex(Convert.hexToUint8Reverse(relevantPart)));
-        }
+    public static toUnresolvedAddress(unresolvedAddressString: string): UnresolvedAddress {
+        const fromHexToUnresolvedAddress = (unresolvedAddressStringHex: string) => {
+            // If bit 0 of byte 0 is not set (like in 0x90), then it is a regular address.
+            // Else (e.g. 0x91) it represents a namespace id which starts at byte 1.
+            const bit0 = Convert.hexToUint8(unresolvedAddressStringHex.substr(1, 2))[0];
+            if ((bit0 & 16) === 16) {
+                // namespaceId encoded hexadecimal notation provided
+                // only 8 bytes are relevant to resolve the NamespaceId
+                const relevantPart = unresolvedAddressStringHex.substr(2, 16);
+                return NamespaceId.createFromEncoded(Convert.uint8ToHex(Convert.hexToUint8Reverse(relevantPart)));
+            }
 
-        // read address from encoded hexadecimal notation
-        return Address.createFromEncoded(address);
+            // read address from encoded hexadecimal notation
+            return Address.createFromEncoded(unresolvedAddressStringHex);
+        };
+
+        if (Convert.isHexString(unresolvedAddressString, 48)) {
+            // Old Rest
+            return fromHexToUnresolvedAddress(unresolvedAddressString);
+        } else {
+            // New rest
+            return fromHexToUnresolvedAddress(DtoMapping.toAddress(unresolvedAddressString).encoded());
+        }
     }
 
     /**