Merge pull request #423 from NEMStudios/task/g402_resolution_statement

Applied catbuffer on resolutionStatement

Author: rg911

e2e/service/MosaicService.spec.ts

@@ -44,7 +44,6 @@ describe('MosaicService', () => {
             const views = amountViews.map((v) => {
                 return {mosaicId: v.fullName(), amount: v.relativeAmount()};
             });
-            console.log(views);
             done();
         });
     });

package-lock.json

@@ -58,15 +58,15 @@
   },
   "dependencies": {
     "bluebird": "^3.5.5",
-    "catbuffer": "0.0.7",
+    "catbuffer": "0.0.11",
     "crypto-js": "^3.1.9-1",
     "futoin-hkdf": "^1.3.1",
     "js-joda": "^1.6.2",
     "js-sha256": "^0.9.0",
     "js-sha3": "^0.8.0",
     "long": "^4.0.0",
     "merkletreejs": "^0.1.7",
-    "nem2-sdk-openapi-typescript-node-client": "0.7.20-beta.6",
+    "nem2-sdk-openapi-typescript-node-client": "0.7.20-alpha.7",
     "request": "^2.88.0",
     "request-promise-native": "^1.0.5",
     "ripemd160": "^2.0.2",

package.json

@@ -14,8 +14,16 @@
  * limitations under the License.
  */
 
-import { GeneratorUtils } from 'catbuffer';
+import { AddressDto,
+         AddressResolutionEntryBuilder,
+         AddressResolutionStatementBuilder,
+         MosaicIdDto, MosaicResolutionEntryBuilder,
+         MosaicResolutionStatementBuilder,
+         ReceiptSourceBuilder,
+         UnresolvedAddressDto,
+         UnresolvedMosaicIdDto } from 'catbuffer';
 import { sha3_256 } from 'js-sha3';
+import { RawAddress } from '../../core/format/RawAddress';
 import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
 import { Address } from '../account/Address';
 import { NetworkType } from '../blockchain/NetworkType';
@@ -68,19 +76,23 @@ export class ResolutionStatement {
     public generateHash(networkType: NetworkType): string {
         const type = this.resolutionType === ResolutionType.Address ? ReceiptType.Address_Alias_Resolution
             : ReceiptType.Mosaic_Alias_Resolution;
-        const unresolvedBytes = this.getUnresolvedBytes(this.resolutionType, networkType);
+        const builder = this.resolutionType === ResolutionType.Address ? new AddressResolutionStatementBuilder(
+            ReceiptVersion.RESOLUTION_STATEMENT, type.valueOf(),
+            new UnresolvedAddressDto(UnresolvedMapping.toUnresolvedAddressBytes(this.unresolved as Address | NamespaceId, networkType)),
+            this.resolutionEntries.map((entry) => new AddressResolutionEntryBuilder(
+                new ReceiptSourceBuilder(entry.source.primaryId, entry.source.secondaryId),
+                new AddressDto(RawAddress.stringToAddress((entry.resolved as Address).plain())),
+            )),
+        ) : new MosaicResolutionStatementBuilder(ReceiptVersion.RESOLUTION_STATEMENT,
+                type.valueOf(),
+                new UnresolvedMosaicIdDto(UInt64.fromHex((this.unresolved as MosaicId | NamespaceId).toHex()).toDTO()),
+                this.resolutionEntries.map((entry) => new MosaicResolutionEntryBuilder(
+                    new ReceiptSourceBuilder(entry.source.primaryId, entry.source.secondaryId),
+                    new MosaicIdDto((entry.resolved as MosaicId).toDTO()),
+                )),
+        );
         const hasher = sha3_256.create();
-        hasher.update(GeneratorUtils.uintToBuffer(ReceiptVersion.RESOLUTION_STATEMENT, 2));
-        hasher.update(GeneratorUtils.uintToBuffer(type, 2));
-        hasher.update(unresolvedBytes);
-
-        let entryBytes = Uint8Array.from([]);
-        this.resolutionEntries.forEach((entry) => {
-            const bytes = entry.serialize();
-            entryBytes = GeneratorUtils.concatTypedArrays(entryBytes, bytes);
-        });
-
-        hasher.update(entryBytes);
+        hasher.update(builder.serialize());
         return hasher.hex().toUpperCase();
     }
 
@@ -195,18 +207,4 @@ export class ResolutionStatement {
         return Math.max(...this.resolutionEntries
             .map((entry) => primaryId >= entry.source.primaryId ? entry.source.primaryId : 0));
     }
-
-    /**
-     * @internal
-     * Generate buffer for unresulved
-     * @param {resolutionType} The resolution Type
-     * @param {networkType} the network type serialized in the output.
-     * @return {Uint8Array}
-     */
-    private getUnresolvedBytes(resolutionType: ResolutionType, networkType: NetworkType): Uint8Array {
-        if (resolutionType === ResolutionType.Address) {
-            return UnresolvedMapping.toUnresolvedAddressBytes(this.unresolved as Address | NamespaceId, networkType);
-        }
-        return GeneratorUtils.uint64ToBuffer(UInt64.fromHex((this.unresolved as MosaicId | NamespaceId).toHex()).toDTO());
-    }
 }

src/model/receipt/ResolutionStatement.ts

@@ -347,14 +347,14 @@ describe('Receipt', () => {
         const statement = CreateStatementFromDTO(statementDTO, netWorkType);
         const receipt = statement.mosaicResolutionStatements[0];
         const hash = receipt.generateHash(NetworkType.MAIN_NET);
-        expect(hash).to.be.equal('99381CE398D3AAE110FC97E984D7D35A710A5C525A4F959EC8916B382DE78A63');
+        expect(hash).to.be.equal('DE29FB6356530E5D1FBEE0A84202520C155D882C46EA74456752D6C75F0707B3');
     });
 
     it('should generate hash for AddressResolutionStatement', () => {
         const statement = CreateStatementFromDTO(statementDTO, netWorkType);
         const receipt = statement.addressResolutionStatements[0];
         const hash = receipt.generateHash(NetworkType.MAIN_NET);
-        expect(hash).to.be.equal('952225717E26295B97F9A35E719CA1319114CCF23C927BCBD14E7A7AA4BAC617');
+        expect(hash).to.be.equal('EFE3D51BF14E861E6E219D1ADB5715D132D6AB7481B29726104933E517F7FBCC');
     });
 
     it('should generate hash for TransactionStatement', () => {

test/model/receipt/Receipt.spec.ts

@@ -53,7 +53,6 @@ describe('Deadline', () => {
 
     it('make sure epochAdjustment is correct', () => {
         const epochAdjustment = new Date(Deadline.timestampNemesisBlock * 1000);
-        console.log(epochAdjustment.toUTCString());
 
         expect(epochAdjustment.getUTCFullYear()).to.be.equal(2019);
         expect(epochAdjustment.getUTCMonth() + 1).to.be.equal(11);