JAV-64 [Github #295] Unresolved Mosaic and Address in transactions

Author: rg911

e2e/infrastructure/UnresolvedMapping.spec.ts

@@ -196,7 +196,7 @@ describe('MosaicRestrictionTransactionService', () => {
                     expect(transaction.type).to.be.equal(TransactionType.MOSAIC_ADDRESS_RESTRICTION);
                     expect(transaction.previousRestrictionValue.toString()).to.be.equal('2');
                     expect(transaction.newRestrictionValue.toString()).to.be.equal('3');
-                    expect(transaction.targetAddress.plain()).to.be.equal(targetAccount.address.plain());
+                    expect(transaction.targetAddressToString()).to.be.equal(targetAccount.address.plain());
                     expect(transaction.restrictionKey.toHex()).to.be.equal(key.toHex());
                     done();
             });

e2e/service/MosaicRestrictionTransactionService.spec.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2019 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 { Address } from '../../model/account/Address';
+import { MosaicId } from '../../model/mosaic/MosaicId';
+import { NamespaceId } from '../../model/namespace/NamespaceId';
+import { Convert } from '../format/Convert';
+import { RawAddress } from '../format/RawAddress';
+
+/**
+ * @internal
+ */
+export class UnresolvedMapping {
+
+    /**
+     * @internal
+     * Map unresolved mosaic string to MosaicId or NamespaceId
+     * @param {string} mosaicId The unresolvedMosaic id in hex.
+     * @returns {MosaicId | NamespaceId}
+     */
+    public static toUnresolvedMosaic(mosaicId: string): MosaicId | NamespaceId {
+        if (!Convert.isHexString(mosaicId)) {
+            throw new Error('Input string is not in valid hexadecimal notation.');
+        }
+        const bytes = Convert.hexToUint8(mosaicId);
+        const byte0 = bytes[0];
+
+        // if most significant bit of byte 0 is set, then we have a namespaceId
+        if ((byte0 & 128) === 128) {
+            return NamespaceId.createFromEncoded(mosaicId);
+        }
+        // most significant bit of byte 0 is not set => mosaicId
+        return new MosaicId(mosaicId);
+    }
+
+    /**
+     * Map unresolved address string to Address or NamespaceId
+     * @param {string} address The unresolved address in hex
+     * @returns {Address | NamespaceId}
+     */
+    public static toUnresolvedAddress(address: string): Address | NamespaceId {
+        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(relevantPart);
+        }
+
+        // read address from encoded hexadecimal notation
+        return Address.createFromEncoded(address);
+    }
+
+    /**
+     * Return unresolved address bytes of the unresolved address
+     * @internal
+     * @param {Address | NamespaceId} unresolvedAddress The unresolved address
+     * @return {Uint8Array}
+     */
+    public static toUnresolvedAddressBytes(unresolvedAddress: Address | NamespaceId): Uint8Array {
+        if (unresolvedAddress instanceof NamespaceId) {
+            // received hexadecimal notation of namespaceId (alias)
+            return RawAddress.aliasToRecipient(Convert.hexToUint8((unresolvedAddress as NamespaceId).toHex()));
+        } else {
+            // received recipient address
+            return RawAddress.stringToAddress((unresolvedAddress as Address).plain());
+        }
+    }
+}

src/core/utils/UnresolvedMapping.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import {Convert as convert} from '../../core/format';
+import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
 import {Address} from '../../model/account/Address';
 import {PublicAccount} from '../../model/account/PublicAccount';
 import {NetworkType} from '../../model/blockchain/NetworkType';
@@ -345,8 +346,8 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             extractTransactionVersion(transactionDTO.version),
             Deadline.createFromDTO(transactionDTO.deadline),
             UInt64.fromNumericString(transactionDTO.maxFee || '0'),
-            new MosaicId(transactionDTO.mosaicId),
-            new MosaicId(transactionDTO.referenceMosaicId),
+            UnresolvedMapping.toUnresolvedMosaic(transactionDTO.mosaicId),
+            UnresolvedMapping.toUnresolvedMosaic(transactionDTO.referenceMosaicId),
             UInt64.fromHex(transactionDTO.restrictionKey),
             UInt64.fromNumericString(transactionDTO.previousRestrictionValue),
             transactionDTO.previousRestrictionType,
@@ -364,11 +365,10 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             extractTransactionVersion(transactionDTO.version),
             Deadline.createFromDTO(transactionDTO.deadline),
             UInt64.fromNumericString(transactionDTO.maxFee || '0'),
-            new MosaicId(transactionDTO.mosaicId),
+            UnresolvedMapping.toUnresolvedMosaic(transactionDTO.mosaicId),
             UInt64.fromHex(transactionDTO.restrictionKey),
-            typeof targetAddress === 'object' && targetAddress.hasOwnProperty('address') ?
-                Address.createFromRawAddress(targetAddress.address) : Address.createFromEncoded(targetAddress),
-                UInt64.fromNumericString(transactionDTO.previousRestrictionValue),
+            extractRecipient(transactionDTO.targetAddress),
+            UInt64.fromNumericString(transactionDTO.previousRestrictionValue),
             UInt64.fromNumericString(transactionDTO.newRestrictionValue),
             transactionDTO.signature,
             transactionDTO.signerPublicKey ? PublicAccount.createFromPublicKey(transactionDTO.signerPublicKey,
@@ -398,7 +398,7 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             UInt64.fromNumericString(transactionDTO.maxFee || '0'),
             transactionDTO.targetPublicKey,
             UInt64.fromHex(transactionDTO.scopedMetadataKey),
-            new MosaicId(transactionDTO.targetMosaicId),
+            UnresolvedMapping.toUnresolvedMosaic(transactionDTO.targetMosaicId),
             transactionDTO.valueSizeDelta,
             convert.decodeHex(transactionDTO.value),
             transactionDTO.signature,
@@ -455,18 +455,7 @@ export const extractTransactionVersion = (version: number): number => {
  */
 export const extractRecipient = (recipientAddress: any): Address | NamespaceId => {
     if (typeof recipientAddress === '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(recipientAddress.substr(1, 2))[0];
-        if ((bit0 & 16) === 16) {
-            // namespaceId encoded hexadecimal notation provided
-            // only 8 bytes are relevant to resolve the NamespaceId
-            const relevantPart = recipientAddress.substr(2, 16);
-            return NamespaceId.createFromEncoded(relevantPart);
-        }
-
-        // read address from encoded hexadecimal notation
-        return Address.createFromEncoded(recipientAddress);
+        return UnresolvedMapping.toUnresolvedAddress(recipientAddress);
     } else if (typeof recipientAddress === 'object') { // Is JSON object
         if (recipientAddress.hasOwnProperty('address')) {
             return Address.createFromRawAddress(recipientAddress.address);
@@ -487,25 +476,12 @@ export const extractRecipient = (recipientAddress: any): Address | NamespaceId
  * @return {Mosaic[]}
  */
 export const extractMosaics = (mosaics: any): Mosaic[] => {
-
     if (mosaics === undefined) {
         return [];
     }
-
     return mosaics.map((mosaicDTO) => {
-
-        // convert ID to UInt8 bytes array and get first byte (most significant byte)
-        const bytes = convert.hexToUint8(mosaicDTO.id);
-        const byte0 = bytes[0];
-
-        // if most significant bit of byte 0 is set, then we have a namespaceId
-        if ((byte0 & 128) === 128) {
-            const namespaceId = NamespaceId.createFromEncoded(mosaicDTO.id);
-            return new Mosaic(namespaceId, UInt64.fromNumericString(mosaicDTO.amount));
-        }
-
-        // most significant bit of byte 0 is not set => mosaicId
-        return new Mosaic(new MosaicId(mosaicDTO.id), UInt64.fromNumericString(mosaicDTO.amount));
+        const id = UnresolvedMapping.toUnresolvedMosaic(mosaicDTO.id);
+        return new Mosaic(id, UInt64.fromNumericString(mosaicDTO.amount));
     });
 };
 

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -15,6 +15,7 @@
  */
 
 import { Convert, RawAddress } from '../../core/format';
+import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
 import { AmountDto } from '../../infrastructure/catbuffer/AmountDto';
 import {
     EmbeddedMosaicAddressRestrictionTransactionBuilder,
@@ -29,6 +30,7 @@ import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
 import { NetworkType } from '../blockchain/NetworkType';
 import { MosaicId } from '../mosaic/MosaicId';
+import { NamespaceId } from '../namespace/NamespaceId';
 import { UInt64 } from '../UInt64';
 import { Deadline } from './Deadline';
 import { InnerTransaction } from './InnerTransaction';
@@ -51,7 +53,7 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
      * **MosaicAddressRestrictionTransaction can only be announced in with Aggregate Transaction
      *
      * @param deadline - The deadline to include the transaction.
-     * @param mosaicId - The mosaic id ex: new MosaicId([481110499, 231112638]).
+     * @param mosaicId - The unresolved mosaic identifier.
      * @param restrictionKey - The restriction key.
      * @param targetAddress - The affected unresolved address.
      * @param newRestrictionValue - The new restriction value.
@@ -61,9 +63,9 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
      * @returns {MosaicAddressRestrictionTransaction}
      */
     public static create(deadline: Deadline,
-                         mosaicId: MosaicId,
+                         mosaicId: MosaicId | NamespaceId,
                          restrictionKey: UInt64,
-                         targetAddress: Address,
+                         targetAddress: Address | NamespaceId,
                          newRestrictionValue: UInt64,
                          networkType: NetworkType,
                          previousRestrictionValue: UInt64 = UInt64.fromHex('FFFFFFFFFFFFFFFF'),
@@ -102,15 +104,15 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
                 /**
                  * The mosaic id.
                  */
-                public readonly mosaicId: MosaicId,
+                public readonly mosaicId: MosaicId | NamespaceId,
                 /**
                  * The restriction key.
                  */
                 public readonly restrictionKey: UInt64,
                 /**
                  * The affected unresolved address.
                  */
-                public readonly targetAddress: Address,
+                public readonly targetAddress: Address | NamespaceId,
                 /**
                  * The previous restriction value.
                  */
@@ -140,9 +142,9 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
         const transaction = MosaicAddressRestrictionTransaction.create(
             isEmbedded ? Deadline.create() : Deadline.createFromDTO(
                 (builder as MosaicAddressRestrictionTransactionBuilder).getDeadline().timestamp),
-            new MosaicId(builder.getMosaicId().unresolvedMosaicId),
+            UnresolvedMapping.toUnresolvedMosaic(new UInt64(builder.getMosaicId().unresolvedMosaicId).toHex()),
             new UInt64(builder.getRestrictionKey()),
-            Address.createFromEncoded(Convert.uint8ToHex(builder.getTargetAddress().unresolvedAddress)),
+            UnresolvedMapping.toUnresolvedAddress(Convert.uint8ToHex(builder.getTargetAddress().unresolvedAddress)),
             new UInt64(builder.getNewRestrictionValue()),
             networkType,
             new UInt64(builder.getPreviousRestrictionValue()),
@@ -173,6 +175,22 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
                byteTargetAddress + bytePreviousRestrictionValue + byteNewRestrictionValue;
     }
 
+    /**
+     * Return the string notation for the set recipient
+     * @internal
+     * @returns {string}
+     */
+    public targetAddressToString(): string {
+
+        if (this.targetAddress instanceof NamespaceId) {
+            // namespaceId recipient, return hexadecimal notation
+            return (this.targetAddress as NamespaceId).toHex();
+        }
+
+        // address recipient
+        return (this.targetAddress as Address).plain();
+    }
+
     /**
      * @internal
      * @returns {Uint8Array}
@@ -190,7 +208,7 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
             new TimestampDto(this.deadline.toDTO()),
             new UnresolvedMosaicIdDto(this.mosaicId.id.toDTO()),
             this.restrictionKey.toDTO(),
-            new UnresolvedAddressDto(RawAddress.stringToAddress(this.targetAddress.plain())),
+            new UnresolvedAddressDto(UnresolvedMapping.toUnresolvedAddressBytes(this.targetAddress)),
             this.previousRestrictionValue.toDTO(),
             this.newRestrictionValue.toDTO(),
         );
@@ -208,7 +226,7 @@ export class MosaicAddressRestrictionTransaction extends Transaction {
             TransactionType.MOSAIC_ADDRESS_RESTRICTION.valueOf(),
             new UnresolvedMosaicIdDto(this.mosaicId.id.toDTO()),
             this.restrictionKey.toDTO(),
-            new UnresolvedAddressDto(RawAddress.stringToAddress(this.targetAddress.plain())),
+            new UnresolvedAddressDto(UnresolvedMapping.toUnresolvedAddressBytes(this.targetAddress)),
             this.previousRestrictionValue.toDTO(),
             this.newRestrictionValue.toDTO(),
         );

src/model/transaction/MosaicAddressRestrictionTransaction.ts

@@ -15,6 +15,7 @@
  */
 
 import { Convert } from '../../core/format';
+import { UnresolvedMapping } from '../../core/utils/UnresolvedMapping';
 import { AmountDto } from '../../infrastructure/catbuffer/AmountDto';
 import {
     EmbeddedMosaicGlobalRestrictionTransactionBuilder,
@@ -27,6 +28,7 @@ import { UnresolvedMosaicIdDto } from '../../infrastructure/catbuffer/Unresolved
 import { PublicAccount } from '../account/PublicAccount';
 import { NetworkType } from '../blockchain/NetworkType';
 import { MosaicId } from '../mosaic/MosaicId';
+import { NamespaceId } from '../namespace/NamespaceId';
 import { MosaicRestrictionType } from '../restriction/MosaicRestrictionType';
 import { UInt64 } from '../UInt64';
 import { Deadline } from './Deadline';
@@ -60,19 +62,19 @@ export class MosaicGlobalRestrictionTransaction extends Transaction {
      * @param newRestrictionValue - The new restriction value.
      * @param newRestrictionType - The new restriction tpye.
      * @param networkType - The network type.
-     * @param referenceMosaicId - (Optional) The mosaic id providing the restriction key.
+     * @param referenceMosaicId - (Optional) The unresolved mosaic identifier providing the restriction key.
      * @param maxFee - (Optional) Max fee defined by the sender
      * @returns {MosaicGlobalRestrictionTransaction}
      */
     public static create(deadline: Deadline,
-                         mosaicId: MosaicId,
+                         mosaicId: MosaicId | NamespaceId,
                          restrictionKey: UInt64,
                          previousRestrictionValue: UInt64,
                          previousRestrictionType: MosaicRestrictionType,
                          newRestrictionValue: UInt64,
                          newRestrictionType: MosaicRestrictionType,
                          networkType: NetworkType,
-                         referenceMosaicId: MosaicId = new MosaicId(UInt64.fromUint(0).toDTO()),
+                         referenceMosaicId: MosaicId | NamespaceId = UnresolvedMapping.toUnresolvedMosaic(UInt64.fromUint(0).toHex()),
                          maxFee: UInt64 = new UInt64([0, 0])): MosaicGlobalRestrictionTransaction {
         return new MosaicGlobalRestrictionTransaction(networkType,
             TransactionVersion.MOSAIC_GLOBAL_RESTRICTION,
@@ -93,7 +95,7 @@ export class MosaicGlobalRestrictionTransaction extends Transaction {
      * @param version - The transaction version
      * @param deadline - The deadline to include the transaction.
      * @param maxFee - (Optional) Max fee defined by the sender
-     * @param mosaicId - The mosaic id ex: new MosaicId([481110499, 231112638]).
+     * @param mosaicId - The unresolved mosaic identifier.
      * @param referenceMosaicId - The mosaic id providing the restriction key.
      * @param restrictionKey - The restriction key.
      * @param previousRestrictionValue - The previous restriction value.
@@ -111,11 +113,11 @@ export class MosaicGlobalRestrictionTransaction extends Transaction {
                 /**
                  * The mosaic id.
                  */
-                public readonly mosaicId: MosaicId,
+                public readonly mosaicId: MosaicId | NamespaceId,
                 /**
                  * The refrence mosaic id.
                  */
-                public readonly referenceMosaicId: MosaicId,
+                public readonly referenceMosaicId: MosaicId | NamespaceId,
                 /**
                  * The restriction key.
                  */
@@ -157,14 +159,14 @@ export class MosaicGlobalRestrictionTransaction extends Transaction {
         const transaction = MosaicGlobalRestrictionTransaction.create(
             isEmbedded ? Deadline.create() : Deadline.createFromDTO(
                 (builder as MosaicGlobalRestrictionTransactionBuilder).getDeadline().timestamp),
-            new MosaicId(builder.getMosaicId().unresolvedMosaicId),
+            UnresolvedMapping.toUnresolvedMosaic(new UInt64(builder.getMosaicId().unresolvedMosaicId).toHex()),
             new UInt64(builder.getRestrictionKey()),
             new UInt64(builder.getPreviousRestrictionValue()),
             builder.getPreviousRestrictionType().valueOf(),
             new UInt64(builder.getNewRestrictionValue()),
             builder.getNewRestrictionType().valueOf(),
             networkType,
-            new MosaicId(builder.getReferenceMosaicId().unresolvedMosaicId),
+            UnresolvedMapping.toUnresolvedMosaic(new UInt64(builder.getReferenceMosaicId().unresolvedMosaicId).toHex()),
             isEmbedded ? new UInt64([0, 0]) : new UInt64((builder as MosaicGlobalRestrictionTransactionBuilder).fee.amount),
         );
         return isEmbedded ?