Merge branch 'master' into task/g295_namespace_id_in_metadata_mosaic_restriction_transaction

rg911 · web-flow · commit a5706963b62e · 2019-10-14T13:20:41.000+01:00
diff --git a/src/infrastructure/receipt/CreateReceiptFromDTO.ts b/src/infrastructure/receipt/CreateReceiptFromDTO.ts
@@ -93,19 +93,21 @@ const createResolutionStatement = (statementDTO, resolutionType): ResolutionStat
     switch (resolutionType) {
         case ResolutionType.Address:
             return new ResolutionStatement(
+                ResolutionType.Address,
                 UInt64.fromNumericString(statementDTO.height),
                 Address.createFromEncoded(statementDTO.unresolved),
                 statementDTO.resolutionEntries.map((entry) => {
-                    return new ResolutionEntry(new AddressAlias(Address.createFromEncoded(entry.resolved)),
+                    return new ResolutionEntry(Address.createFromEncoded(entry.resolved),
                         new ReceiptSource(entry.source.primaryId, entry.source.secondaryId));
                 }),
             );
         case ResolutionType.Mosaic:
             return new ResolutionStatement(
+                ResolutionType.Mosaic,
                 UInt64.fromNumericString(statementDTO.height),
                 new MosaicId(statementDTO.unresolved),
                 statementDTO.resolutionEntries.map((entry) => {
-                    return new ResolutionEntry(new MosaicAlias(new MosaicId(entry.resolved)),
+                    return new ResolutionEntry(new MosaicId(entry.resolved),
                         new ReceiptSource(entry.source.primaryId, entry.source.secondaryId));
                 }),
             );
@@ -200,6 +202,7 @@ const extractArtifactId = (receiptType: ReceiptType, id: string): MosaicId | Nam
         case ReceiptType.Mosaic_Expired:
             return new MosaicId(id);
         case ReceiptType.Namespace_Expired:
+        case ReceiptType.Namespace_Deleted:
             return NamespaceId.createFromEncoded(id);
         default:
             throw new Error('Receipt type is not supported.');
diff --git a/src/model/namespace/AddressAlias.ts b/src/model/namespace/AddressAlias.ts
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { RawAddress } from '../../core/format/RawAddress';
 import {Address} from '../account/Address';
 import {Alias} from './Alias';
 import { AliasType } from './AliasType';
@@ -46,4 +47,12 @@ export class AddressAlias extends Alias {
         }
         return false;
     }
+
+    /**
+     * Generate alias buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+        return RawAddress.stringToAddress(this.address.plain());
+    }
 }
diff --git a/src/model/namespace/Alias.ts b/src/model/namespace/Alias.ts
@@ -53,6 +53,7 @@ export abstract class Alias {
      * @internal
      * Compares alias for equality.
      * @param alias - MosaicAlias
+     * @return {boolean}
      */
     protected abstract equals(alias: any): boolean;
 }
diff --git a/src/model/namespace/EmptyAlias.ts b/src/model/namespace/EmptyAlias.ts
@@ -45,4 +45,12 @@ export class EmptyAlias extends Alias {
     public equals(alias: any): boolean {
         return alias instanceof EmptyAlias || alias.type === 0;
     }
+
+    /**
+     * Generate alias buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+        return new Uint8Array(0);
+    }
 }
diff --git a/src/model/receipt/ArtifactExpiryReceipt.ts b/src/model/receipt/ArtifactExpiryReceipt.ts
@@ -14,8 +14,11 @@
  * limitations under the License.
  */
 
+import { Convert } from '../../core/format/Convert';
+import { GeneratorUtils } from '../../infrastructure/catbuffer/GeneratorUtils';
 import { MosaicId } from '../mosaic/MosaicId';
 import { NamespaceId } from '../namespace/NamespaceId';
+import { UInt64 } from '../UInt64';
 import { Receipt } from './Receipt';
 import { ReceiptType } from './ReceiptType';
 import { ReceiptVersion } from './ReceiptVersion';
@@ -38,4 +41,17 @@ export class ArtifactExpiryReceipt extends Receipt {
                 size?: number) {
         super(version, type, size);
     }
+
+    /**
+     * @internal
+     * Generate buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+        const buffer = new Uint8Array(12);
+        buffer.set(GeneratorUtils.uintToBuffer(ReceiptVersion.ARTIFACT_EXPIRY, 2));
+        buffer.set(GeneratorUtils.uintToBuffer(this.type, 2), 2);
+        buffer.set(GeneratorUtils.uint64ToBuffer(UInt64.fromHex(this.artifactId.toHex()).toDTO()), 4);
+        return buffer;
+    }
 }
diff --git a/src/model/receipt/BalanceChangeReceipt.ts b/src/model/receipt/BalanceChangeReceipt.ts
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { Convert } from '../../core/format/Convert';
+import { GeneratorUtils } from '../../infrastructure/catbuffer/GeneratorUtils';
 import { PublicAccount } from '../account/PublicAccount';
 import { MosaicId } from '../mosaic/MosaicId';
 import { UInt64 } from '../UInt64';
@@ -53,4 +55,19 @@ export class BalanceChangeReceipt extends Receipt {
                 size?: number) {
         super(version, type, size);
     }
+
+    /**
+     * @internal
+     * Generate buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+        const buffer = new Uint8Array(52);
+        buffer.set(GeneratorUtils.uintToBuffer(ReceiptVersion.BALANCE_CHANGE, 2));
+        buffer.set(GeneratorUtils.uintToBuffer(this.type, 2), 2);
+        buffer.set(Convert.hexToUint8(this.targetPublicAccount.publicKey), 4);
+        buffer.set(GeneratorUtils.uint64ToBuffer(UInt64.fromHex(this.mosaicId.toHex()).toDTO()), 36);
+        buffer.set(GeneratorUtils.uint64ToBuffer(UInt64.fromHex(this.amount.toHex()).toDTO()), 44);
+        return buffer;
+    }
 }
diff --git a/src/model/receipt/BalanceTransferReceipt.ts b/src/model/receipt/BalanceTransferReceipt.ts
@@ -14,6 +14,9 @@
  * limitations under the License.
  */
 
+import { Convert } from '../../core/format/Convert';
+import { RawAddress } from '../../core/format/RawAddress';
+import { GeneratorUtils } from '../../infrastructure/catbuffer/GeneratorUtils';
 import { Address } from '../account/Address';
 import { PublicAccount } from '../account/PublicAccount';
 import { MosaicId } from '../mosaic/MosaicId';
@@ -60,4 +63,39 @@ export class BalanceTransferReceipt extends Receipt {
                 size?: number) {
         super(version, type, size);
     }
+
+    /**
+     * @internal
+     * Generate buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+        const recipient = this.getRecipientBytes();
+        const buffer = new Uint8Array(52 + recipient.length);
+        buffer.set(GeneratorUtils.uintToBuffer(ReceiptVersion.BALANCE_TRANSFER, 2));
+        buffer.set(GeneratorUtils.uintToBuffer(this.type, 2), 2);
+        buffer.set(Convert.hexToUint8(this.sender.publicKey), 4);
+        buffer.set(recipient, 36);
+        buffer.set(GeneratorUtils.uint64ToBuffer(UInt64.fromHex(this.mosaicId.toHex()).toDTO()), 36 + recipient.length);
+        buffer.set(GeneratorUtils.uint64ToBuffer(UInt64.fromHex(this.amount.toHex()).toDTO()), 44 + recipient.length);
+        return buffer;
+    }
+
+    /**
+     * @internal
+     * Generate buffer for recipientAddress
+     * @return {Uint8Array}
+     */
+    private getRecipientBytes(): Uint8Array {
+        const recipientString =
+            this.recipientAddress instanceof NamespaceId ? (this.recipientAddress as NamespaceId).toHex()
+                                                         : (this.recipientAddress as Address).plain();
+        if (/^[0-9a-fA-F]{16}$/.test(recipientString)) {
+            // received hexadecimal notation of namespaceId (alias)
+            return RawAddress.aliasToRecipient(Convert.hexToUint8(recipientString));
+        } else {
+            // received recipient address
+            return RawAddress.stringToAddress(recipientString);
+        }
+    }
 }
diff --git a/src/model/receipt/InflationReceipt.ts b/src/model/receipt/InflationReceipt.ts
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+import { Convert } from '../../core/format/Convert';
+import { GeneratorUtils } from '../../infrastructure/catbuffer/GeneratorUtils';
 import { MosaicId } from '../mosaic/MosaicId';
 import { UInt64 } from '../UInt64';
 import { Receipt } from './Receipt';
@@ -47,4 +49,18 @@ export class InflationReceipt extends Receipt {
                 size?: number) {
         super(version, type, size);
     }
+
+    /**
+     * @internal
+     * Generate buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+        const buffer = new Uint8Array(20);
+        buffer.set(GeneratorUtils.uintToBuffer(ReceiptVersion.INFLATION_RECEIPT, 2));
+        buffer.set(GeneratorUtils.uintToBuffer(this.type, 2), 2);
+        buffer.set(GeneratorUtils.uint64ToBuffer(UInt64.fromHex(this.mosaicId.toHex()).toDTO()), 4);
+        buffer.set(GeneratorUtils.uint64ToBuffer(UInt64.fromHex(this.amount.toHex()).toDTO()), 12);
+        return buffer;
+    }
 }
diff --git a/src/model/receipt/Receipt.ts b/src/model/receipt/Receipt.ts
@@ -42,4 +42,11 @@ export abstract class Receipt {
                  */
                 public readonly size?: number) {
     }
+
+    /**
+     * @internal
+     * Generate buffer
+     * @return {Uint8Array}
+     */
+    abstract serialize(): Uint8Array;
 }
diff --git a/src/model/receipt/ReceiptSource.ts b/src/model/receipt/ReceiptSource.ts
@@ -1,3 +1,6 @@
+import { Convert } from '../../core/format/Convert';
+import { GeneratorUtils } from '../../infrastructure/catbuffer/GeneratorUtils';
+
 /*
  * Copyright 2019 NEM
  *
@@ -34,4 +37,14 @@ export class ReceiptSource {
                  */
                 public readonly secondaryId: number) {
     }
+
+    /**
+     * @internal
+     * Generate buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+        return GeneratorUtils.concatTypedArrays(
+            GeneratorUtils.uintToBuffer(this.primaryId, 4), GeneratorUtils.uintToBuffer(this.secondaryId, 4));
+    }
 }
diff --git a/src/model/receipt/ResolutionEntry.ts b/src/model/receipt/ResolutionEntry.ts
@@ -14,14 +14,17 @@
  * limitations under the License.
  */
 
-  import { AddressAlias } from '../namespace/AddressAlias';
-  import { MosaicAlias } from '../namespace/MosaicAlias';
-  import { ReceiptSource } from './ReceiptSource';
+import { RawAddress } from '../../core/format/RawAddress';
+import { GeneratorUtils } from '../../infrastructure/catbuffer/GeneratorUtils';
+import { Address } from '../account/Address';
+import { MosaicId } from '../mosaic/MosaicId';
+import { UInt64 } from '../UInt64';
+import { ReceiptSource } from './ReceiptSource';
 
 /**
  * The receipt source object.
  */
-  export class ResolutionEntry {
+export class ResolutionEntry {
 
     /**
      * @constructor
@@ -32,10 +35,26 @@
                 /**
                  * A resolved address or resolved mosaicId (alias).
                  */
-                public readonly resolved: AddressAlias | MosaicAlias,
+                public readonly resolved: Address | MosaicId,
                 /**
                  * The receipt source.
                  */
                 public readonly source: ReceiptSource) {
     }
+
+    /**
+     * @internal
+     * Generate buffer
+     * @return {Uint8Array}
+     */
+    public serialize(): Uint8Array {
+      let resolvedBytes: Uint8Array;
+      if (this.resolved instanceof Address) {
+        resolvedBytes = RawAddress.stringToAddress((this.resolved as Address).plain());
+      } else {
+        resolvedBytes = GeneratorUtils.uint64ToBuffer(UInt64.fromHex((this.resolved as MosaicId).toHex()).toDTO());
+      }
+      const sourceBytes = this.source.serialize();
+      return GeneratorUtils.concatTypedArrays(resolvedBytes, sourceBytes);
+    }
 }
diff --git a/src/model/receipt/ResolutionStatement.ts b/src/model/receipt/ResolutionStatement.ts
@@ -14,10 +14,18 @@
  * limitations under the License.
  */
 
+import { sha3_256 } from 'js-sha3';
+import { Convert } from '../../core/format/Convert';
+import { RawAddress } from '../../core/format/RawAddress';
+import { GeneratorUtils } from '../../infrastructure/catbuffer/GeneratorUtils';
 import { Address } from '../account/Address';
 import { MosaicId } from '../mosaic/MosaicId';
+import { NamespaceId } from '../namespace/NamespaceId';
 import { UInt64 } from '../UInt64';
+import { ReceiptType } from './ReceiptType';
+import { ReceiptVersion } from './ReceiptVersion';
 import { ResolutionEntry } from './ResolutionEntry';
+import { ResolutionType } from './ResolutionType';
 
 /**
  * When a transaction includes an alias, a so called resolution statement reflects the resolved value for that block:
@@ -28,22 +36,73 @@ export class ResolutionStatement {
 
     /**
      * Receipt - resolution statement object
+     * @param resolutionType - The resolution type
      * @param height - The block height
      * @param unresolved - An unresolved address or unresolved mosaicId.
      * @param resolutionEntries - The array of resolution entries.
      */
     constructor(
+                /**
+                 * Resolution type
+                 */
+                public readonly resolutionType: ResolutionType,
                 /**
                  * The block height.
                  */
                 public readonly height: UInt64,
                 /**
                  * An unresolved address or unresolved mosaicId.
                  */
-                public readonly unresolved: Address | MosaicId,
+                public readonly unresolved: Address | MosaicId | NamespaceId,
                 /**
                  * The array of resolution entries.
                  */
                 public readonly resolutionEntries: ResolutionEntry[]) {
     }
+
+    /**
+     * Generate receipt hash
+     * @return {string} receipt hash in hex
+     */
+    public generateHash(): string {
+        const type = this.resolutionType === ResolutionType.Address ? ReceiptType.Address_Alias_Resolution
+                                                                    : ReceiptType.Mosaic_Alias_Resolution;
+        const unresolvedBytes = this.getUnresolvedBytes(this.resolutionType);
+        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);
+        return hasher.hex().toUpperCase();
+    }
+
+    /**
+     * @internal
+     * Generate buffer for unresulved
+     * @param - The resolution Type
+     * @return {Uint8Array}
+     */
+    private getUnresolvedBytes(resolutionType: ResolutionType): Uint8Array {
+        if (resolutionType === ResolutionType.Address) {
+            const recipientString =
+            this.unresolved instanceof NamespaceId ? (this.unresolved as NamespaceId).toHex()
+                                                   : (this.unresolved as Address).plain();
+            if (/^[0-9a-fA-F]{16}$/.test(recipientString)) {
+                // received hexadecimal notation of namespaceId (alias)
+                return RawAddress.aliasToRecipient(Convert.hexToUint8(recipientString));
+            } else {
+                // received recipient address
+                return RawAddress.stringToAddress(recipientString);
+            }
+        }
+
+        return GeneratorUtils.uint64ToBuffer(UInt64.fromHex((this.unresolved as MosaicId | NamespaceId).toHex()).toDTO());
+    }
 }
diff --git a/src/model/receipt/TransactionStatement.ts b/src/model/receipt/TransactionStatement.ts
diff --git a/test/infrastructure/receipt/CreateReceiptFromDTO.spec.ts b/test/infrastructure/receipt/CreateReceiptFromDTO.spec.ts
diff --git a/test/model/receipt/Receipt.spec.ts b/test/model/receipt/Receipt.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -53,6 +53,7 @@ export abstract class Alias {`
`53`	`53`	`* @internal`
`54`	`54`	`* Compares alias for equality.`
`55`	`55`	`* @param alias - MosaicAlias`
	`56`	`+ * @return {boolean}`
`56`	`57`	`*/`
`57`	`58`	`protected abstract equals(alias: any): boolean;`
`58`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,4 +45,12 @@ export class EmptyAlias extends Alias {`
`45`	`45`	`public equals(alias: any): boolean {`
`46`	`46`	`return alias instanceof EmptyAlias \|\| alias.type === 0;`
`47`	`47`	`}`
	`48`	`+`
	`49`	`+ /**`
	`50`	`+ * Generate alias buffer`
	`51`	`+ * @return {Uint8Array}`
	`52`	`+ */`
	`53`	`+ public serialize(): Uint8Array {`
	`54`	`+ return new Uint8Array(0);`
	`55`	`+ }`
`48`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,4 +42,11 @@ export abstract class Receipt {`
`42`	`42`	`*/`
`43`	`43`	`public readonly size?: number) {`
`44`	`44`	`}`
	`45`	`+`
	`46`	`+ /**`
	`47`	`+ * @internal`
	`48`	`+ * Generate buffer`
	`49`	`+ * @return {Uint8Array}`
	`50`	`+ */`
	`51`	`+ abstract serialize(): Uint8Array;`
`45`	`52`	`}`