WIP #55: Added Alias models ; Added NamespaceInfo.alias for cow upgrade ;

Author: Greg S

src/infrastructure/NamespaceHttp.ts

@@ -18,6 +18,12 @@ import {from as observableFrom, Observable} from 'rxjs';
 import {map, mergeMap} from 'rxjs/operators';
 import {Address} from '../model/account/Address';
 import {PublicAccount} from '../model/account/PublicAccount';
+import {MosaicId} from '../model/mosaic/MosaicId';
+import {AddressAlias} from '../model/namespace/AddressAlias';
+import {Alias} from '../model/namespace/Alias';
+import {AliasType} from '../model/namespace/AliasType';
+import {EmptyAlias} from '../model/namespace/EmptyAlias';
+import {MosaicAlias} from '../model/namespace/MosaicAlias';
 import {NamespaceId} from '../model/namespace/NamespaceId';
 import {NamespaceInfo} from '../model/namespace/NamespaceInfo';
 import {NamespaceName} from '../model/namespace/NamespaceName';
@@ -70,6 +76,7 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
                     PublicAccount.createFromPublicKey(namespaceInfoDTO.namespace.owner, networkType),
                     new UInt64(namespaceInfoDTO.namespace.startHeight),
                     new UInt64(namespaceInfoDTO.namespace.endHeight),
+                    this.extractAlias(namespaceInfoDTO.namespace),
                 );
             }))));
     }
@@ -98,6 +105,7 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
                             PublicAccount.createFromPublicKey(namespaceInfoDTO.namespace.owner, networkType),
                             new UInt64(namespaceInfoDTO.namespace.startHeight),
                             new UInt64(namespaceInfoDTO.namespace.endHeight),
+                            this.extractAlias(namespaceInfoDTO.namespace),
                         );
                     });
                 }))));
@@ -130,6 +138,7 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
                             PublicAccount.createFromPublicKey(namespaceInfoDTO.namespace.owner, networkType),
                             new UInt64(namespaceInfoDTO.namespace.startHeight),
                             new UInt64(namespaceInfoDTO.namespace.endHeight),
+                            this.extractAlias(namespaceInfoDTO.namespace),
                         );
                     });
                 }))));
@@ -169,4 +178,21 @@ export class NamespaceHttp extends Http implements NamespaceRepository {
         }
         return result;
     }
+
+    /**
+     * Extract the alias from a namespace
+     *
+     * @internal
+     * @access private
+     * @param namespace
+     */
+    private extractAlias(namespace: any): Alias {
+        if (namespace.alias && namespace.alias.type === AliasType.Mosaic) {
+            return new MosaicAlias(namespace.alias.type, namespace.alias.mosaicId);
+        } else if (namespace.alias && namespace.alias.type === AliasType.Address) {
+            return new AddressAlias(namespace.alias.type, namespace.alias.address);
+        }
+
+        return new EmptyAlias();
+    }
 }

src/model/model.ts

@@ -43,6 +43,10 @@ export * from './mosaic/XEM';
 
 // Namespace
 export * from '../service/Namespace';
+export * from './namespace/AliasType';
+export * from './namespace/Alias';
+export * from './namespace/AddressAlias';
+export * from './namespace/MosaicAlias';
 export * from './namespace/NamespaceId';
 export * from './namespace/NamespaceInfo';
 export * from './namespace/NamespaceName';

src/model/namespace/AddressAlias.ts

@@ -0,0 +1,54 @@
+/*
+ * 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 {namespaceId as NamespaceIdGenerator} from 'nem2-library';
+import {Address} from '../account/Address';
+import {Alias} from './Alias';
+
+/**
+ * The AddressAlias structure describes address aliases
+ *
+ * @since 0.10.2
+ */
+export class AddressAlias implements Alias {
+
+    /**
+     * Create AddressAlias object
+     *
+     * @param type
+     * @param content
+     */
+    constructor(/**
+                 * The alias type
+                 */
+                public readonly type: number,
+                /**
+                 * The alias address
+                 */
+                public readonly address: Address) {
+    }
+
+    /**
+     * Compares AddressAlias for equality.
+     *
+     * @return boolean
+     */
+    public equals(alias: any): boolean {
+        if (alias instanceof AddressAlias) {
+            return this.address.equals(alias.address);
+        }
+        return false;
+    }
+}

src/model/namespace/Alias.ts

@@ -0,0 +1,47 @@
+/*
+ * 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 {namespaceId as NamespaceIdGenerator} from 'nem2-library';
+import {Address} from '../account/Address';
+import {MosaicId} from '../mosaic/MosaicId';
+import {AddressAlias} from './AddressAlias';
+import {AliasType} from './AliasType';
+import {MosaicAlias} from './MosaicAlias';
+
+/**
+ * The alias structure defines an interface for Aliases
+ *
+ * @since 0.10.2
+ */
+export interface Alias {
+    /**
+     * The alias type
+     *
+     * - 0 : No alias
+     * - 1 : Mosaic id alias
+     * - 2 : Address alias
+     */
+    readonly type: number;
+
+    /**
+     * The alias address
+     */
+    readonly address?: Address;
+
+    /**
+     * The alias mosaicId
+     */
+    readonly mosaicId?: MosaicId;
+}

src/model/namespace/AliasType.ts

@@ -0,0 +1,29 @@
+/*
+ * 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.
+ */
+
+/**
+ * The alias type. Supported types are:
+ * 0: No alias.
+ * 1: Mosaic id alias.
+ * 2: Address alias.
+ *
+ * @since 0.10.2
+ */
+export enum AliasType {
+    None = 0,
+    Mosaic = 1,
+    Address = 2,
+}

src/model/namespace/EmptyAlias.ts

@@ -0,0 +1,49 @@
+/*
+ * 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 {namespaceId as NamespaceIdGenerator} from 'nem2-library';
+import {Address} from '../account/Address';
+import {Alias} from './Alias';
+
+/**
+ * The EmptyAlias structure describes empty aliases (type:0)
+ *
+ * @since 0.10.2
+ */
+export class EmptyAlias implements Alias {
+    /**
+     * The alias type
+     */
+    public readonly type: number;
+
+    /**
+     * Create EmptyAlias object
+     *
+     * @param type
+     * @param content
+     */
+    constructor() {
+        this.type = 0;
+    }
+
+    /**
+     * Compares EmptyAlias for equality.
+     *
+     * @return boolean
+     */
+    public equals(alias: any): boolean {
+        return alias instanceof EmptyAlias || alias.type === 0;
+    }
+}

src/model/namespace/MosaicAlias.ts

@@ -0,0 +1,54 @@
+/*
+ * 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 {namespaceId as NamespaceIdGenerator} from 'nem2-library';
+import {MosaicId} from '../mosaic/MosaicId';
+import {Alias} from './Alias';
+
+/**
+ * The MosaicAlias structure describe mosaic aliases
+ *
+ * @since 0.10.2
+ */
+export class MosaicAlias implements Alias {
+
+    /**
+     * Create AddressAlias object
+     *
+     * @param type
+     * @param mosaicId
+     */
+    constructor(/**
+                 * The alias type
+                 */
+                public readonly type: number,
+                /**
+                 * The alias address
+                 */
+                public readonly mosaicId: MosaicId) {
+    }
+
+    /**
+     * Compares AddressAlias for equality.
+     *
+     * @return boolean
+     */
+    public equals(alias: any): boolean {
+        if (alias instanceof MosaicAlias) {
+            return this.mosaicId.equals(alias.mosaicId);
+        }
+        return false;
+    }
+}

src/model/namespace/NamespaceInfo.ts

@@ -16,6 +16,7 @@
 
 import {PublicAccount} from '../account/PublicAccount';
 import {UInt64} from '../UInt64';
+import {Alias} from './Alias';
 import {NamespaceId} from './NamespaceId';
 
 /**
@@ -74,7 +75,11 @@ export class NamespaceInfo {
                 /**
                  * The height at which the ownership ends.
                  */
-                public readonly endHeight: UInt64) {
+                public readonly endHeight: UInt64,
+                /**
+                 * The alias linked to a namespace.
+                 */
+                public readonly alias: Alias) {
 
     }
 
@@ -102,6 +107,14 @@ export class NamespaceInfo {
         return this.type === 1;
     }
 
+    /**
+     * Has alias
+     * @returns {boolean}
+     */
+    public hasAlias(): boolean {
+        return this.alias.type !== 0;
+    }
+
     /**
      * Get parent id
      * @returns {Id}

test/model/namespace/NamespaceInfo.spec.ts

@@ -41,6 +41,7 @@ describe('NamespaceInfo', () => {
                 parentId: new NamespaceId([0, 0]),
                 startHeight: new UInt64([1, 0]),
                 type: 0,
+                alias: {type: 0},
             },
         };
         subNamespaceDTO = {
@@ -73,6 +74,7 @@ describe('NamespaceInfo', () => {
                     50795,
                     0,
                 ],
+                alias: {type: 0},
             },
         };
     });
@@ -88,6 +90,7 @@ describe('NamespaceInfo', () => {
         expect(namespaceInfo.owner.publicKey).to.be.equal(rootNamespaceDTO.namespace.owner);
         deepEqual(namespaceInfo.startHeight, rootNamespaceDTO.namespace.startHeight);
         deepEqual(namespaceInfo.endHeight, rootNamespaceDTO.namespace.endHeight);
+        deepEqual(namespaceInfo.alias, rootNamespaceDTO.namespace.alias);
     });
 
     it('should return the NamespaceId in string format', () => {
@@ -156,6 +159,7 @@ describe('NamespaceInfo', () => {
             PublicAccount.createFromPublicKey(dto.namespace.owner, NetworkType.MIJIN_TEST),
             dto.namespace.startHeight,
             dto.namespace.endHeight,
+            dto.namespace.alias,
         );
     }
 
@@ -171,6 +175,7 @@ describe('NamespaceInfo', () => {
             PublicAccount.createFromPublicKey(dto.namespace.owner, NetworkType.MIJIN_TEST),
             dto.namespace.startHeight,
             dto.namespace.endHeight,
+            dto.namespace.alias,
         );
     }