Added unit test and fixed a few issues.

Author: rg911

src/infrastructure/AccountHttp.ts

@@ -19,7 +19,6 @@ import {from as observableFrom, Observable} from 'rxjs';
 import {map, mergeMap} from 'rxjs/operators';
 import {AccountInfo} from '../model/account/AccountInfo';
 import { AccountPropertiesInfo } from '../model/account/AccountPropertiesInfo';
-import { AccountProperty } from '../model/account/AccountProperty';
 import {Address} from '../model/account/Address';
 import {MultisigAccountGraphInfo} from '../model/account/MultisigAccountGraphInfo';
 import {MultisigAccountInfo} from '../model/account/MultisigAccountInfo';

src/infrastructure/transaction/CreateTransactionFromDTO.ts

@@ -17,20 +17,22 @@
 import {Address} from '../../model/account/Address';
 import {PublicAccount} from '../../model/account/PublicAccount';
 import {NetworkType} from '../../model/blockchain/NetworkType';
-import { AccountPropertyModification,
-    ModifyAccountPropertyAddressTransaction,
-    ModifyAccountPropertyEntityTypeTransaction,
-    ModifyAccountPropertyMosaicTransaction } from '../../model/model';
 import {Mosaic} from '../../model/mosaic/Mosaic';
 import {MosaicId} from '../../model/mosaic/MosaicId';
 import {MosaicProperties} from '../../model/mosaic/MosaicProperties';
 import {NamespaceId} from '../../model/namespace/NamespaceId';
+import { AccountLinkTransaction } from '../../model/transaction/AccountLinkTransaction';
+import {AccountPropertyModification} from '../../model/transaction/AccountPropertyModification';
 import {AddressAliasTransaction} from '../../model/transaction/AddressAliasTransaction';
 import {AggregateTransaction} from '../../model/transaction/AggregateTransaction';
 import {AggregateTransactionCosignature} from '../../model/transaction/AggregateTransactionCosignature';
 import {AggregateTransactionInfo} from '../../model/transaction/AggregateTransactionInfo';
 import {Deadline} from '../../model/transaction/Deadline';
+import { LinkAction } from '../../model/transaction/LinkAction';
 import {LockFundsTransaction} from '../../model/transaction/LockFundsTransaction';
+import {ModifyAccountPropertyAddressTransaction} from '../../model/transaction/ModifyAccountPropertyAddressTransaction';
+import {ModifyAccountPropertyEntityTypeTransaction} from '../../model/transaction/ModifyAccountPropertyEntityTypeTransaction';
+import {ModifyAccountPropertyMosaicTransaction} from '../../model/transaction/ModifyAccountPropertyMosaicTransaction';
 import {ModifyMultisigAccountTransaction} from '../../model/transaction/ModifyMultisigAccountTransaction';
 import {MosaicAliasTransaction} from '../../model/transaction/MosaicAliasTransaction';
 import {MosaicDefinitionTransaction} from '../../model/transaction/MosaicDefinitionTransaction';
@@ -303,6 +305,18 @@ const CreateStandaloneTransactionFromDTO = (transactionDTO, transactionInfo): Tr
             PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
             transactionInfo,
         );
+    } else if (transactionDTO.type === TransactionType.LINK_ACCOUNT) {
+        return new AccountLinkTransaction(
+            extractNetworkType(transactionDTO.version),
+            extractTransactionVersion(transactionDTO.version),
+            Deadline.createFromDTO(transactionDTO.deadline),
+            new UInt64(transactionDTO.fee || [0, 0]),
+            transactionDTO.remoteAccountKey,
+            transactionDTO.linkAction,
+            transactionDTO.signature,
+            PublicAccount.createFromPublicKey(transactionDTO.signer, extractNetworkType(transactionDTO.version)),
+            transactionInfo,
+        );
     }
 
     throw new Error('Unimplemented transaction with type ' + transactionDTO.type);

src/model/transaction/AccountLinkTransaction.ts

@@ -38,7 +38,7 @@ export class AccountLinkTransaction extends Transaction {
      * @returns {AccountLinkTransaction}
      */
     public static create(deadline: Deadline,
-                         remoteAccountKey: PublicAccount,
+                         remoteAccountKey: string,
                          linkAction: LinkAction,
                          networkType: NetworkType): AccountLinkTransaction {
         return new AccountLinkTransaction(networkType,
@@ -67,7 +67,7 @@ export class AccountLinkTransaction extends Transaction {
                 /**
                  * The public key of the remote account.
                  */
-                public readonly remoteAccountKey: PublicAccount,
+                public readonly remoteAccountKey: string,
                 /**
                  * The account link action.
                  */
@@ -87,7 +87,7 @@ export class AccountLinkTransaction extends Transaction {
             .addDeadline(this.deadline.toDTO())
             .addFee(this.fee.toDTO())
             .addVersion(this.versionToDTO())
-            .addRemoteAccountKey(this.remoteAccountKey.publicKey)
+            .addRemoteAccountKey(this.remoteAccountKey)
             .addLinkAction(this.linkAction)
             .build();
     }

src/model/transaction/AccountPropertyTransaction.ts

@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
+import { Address } from '../account/Address';
+import { PropertyModificationType } from '../account/PropertyModificationType';
+import { PropertyType } from '../account/PropertyType';
 import { NetworkType } from '../blockchain/NetworkType';
-import { AccountPropertyModification,
-         Address,
-         ModifyAccountPropertyAddressTransaction,
-         ModifyAccountPropertyEntityTypeTransaction,
-         ModifyAccountPropertyMosaicTransaction,
-         PropertyModificationType, PropertyType } from '../model';
 import { MosaicId } from '../mosaic/MosaicId';
+import { AccountPropertyModification } from './AccountPropertyModification';
 import { Deadline } from './Deadline';
-import { TransactionType } from './TransactionType';
+import { ModifyAccountPropertyAddressTransaction } from './ModifyAccountPropertyAddressTransaction';
+import { ModifyAccountPropertyEntityTypeTransaction } from './ModifyAccountPropertyEntityTypeTransaction';
+import { ModifyAccountPropertyMosaicTransaction } from './ModifyAccountPropertyMosaicTransaction';
 
 export class AccountPropertyTransaction {
     /**

test/model/transaction/AccountLinkTransaction.spec.ts

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2018 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 { expect } from 'chai';
+import { Account } from '../../../src/model/account/Account';
+import { NetworkType } from '../../../src/model/blockchain/NetworkType';
+import { AccountLinkTransaction } from '../../../src/model/transaction/AccountLinkTransaction';
+import { Deadline } from '../../../src/model/transaction/Deadline';
+import { LinkAction } from '../../../src/model/transaction/LinkAction';
+import { TestingAccount } from '../../conf/conf.spec';
+
+describe('AccountLinkTransaction', () => {
+    let account: Account;
+
+    before(() => {
+        account = TestingAccount;
+    });
+
+    it('should create an AccountLinkTransaction object with link action', () => {
+        const accountLinkTransaction = AccountLinkTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            LinkAction.Link,
+            NetworkType.MIJIN_TEST,
+        );
+
+        expect(accountLinkTransaction.linkAction).to.be.equal(0);
+        expect(accountLinkTransaction.remoteAccountKey).to.be.equal(account.publicKey);
+
+        const signedTransaction = accountLinkTransaction.signWith(account);
+
+        expect(signedTransaction.payload.substring(
+            240,
+            signedTransaction.payload.length,
+        )).to.be.equal('C2F93346E27CE6AD1A9F8F5E3066F8326593A406BDF357ACB041E2F9AB402EFE00');
+    });
+
+    it('should create an AccountLinkTransaction object with unlink action', () => {
+        const accountLinkTransaction = AccountLinkTransaction.create(
+            Deadline.create(),
+            account.publicKey,
+            LinkAction.Unlink,
+            NetworkType.MIJIN_TEST,
+        );
+
+        expect(accountLinkTransaction.linkAction).to.be.equal(1);
+        expect(accountLinkTransaction.remoteAccountKey).to.be.equal(account.publicKey);
+
+        const signedTransaction = accountLinkTransaction.signWith(account);
+
+        expect(signedTransaction.payload.substring(
+            240,
+            signedTransaction.payload.length,
+        )).to.be.equal('C2F93346E27CE6AD1A9F8F5E3066F8326593A406BDF357ACB041E2F9AB402EFE01');
+    });
+});