Merge pull request #80 from rg911/task/g52_delegated_harvesting

Task/g52 delegated harvesting

Author: Grégory Saive

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/model.ts

@@ -61,6 +61,7 @@ export * from './namespace/NamespaceType';
 export * from './namespace/AliasActionType';
 
 // Transaction
+export * from './transaction/AccountLinkTransaction';
 export * from './transaction/AccountPropertyTransaction';
 export * from './transaction/ModifyAccountPropertyAddressTransaction';
 export * from './transaction/ModifyAccountPropertyEntityTypeTransaction';
@@ -77,6 +78,7 @@ export * from './transaction/Deadline';
 export * from './transaction/HashLockTransaction';
 export * from './transaction/HashType';
 export * from './transaction/InnerTransaction';
+export * from './transaction/LinkAction';
 export * from './transaction/LockFundsTransaction';
 export * from './transaction/Message';
 export * from './transaction/ModifyMultisigAccountTransaction';

src/model/transaction/AccountLinkTransaction.ts

@@ -0,0 +1,95 @@
+/*
+ * 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 { AccountLinkTransaction as AccountLinkTransactionLibrary, VerifiableTransaction } from 'nem2-library';
+import { PublicAccount } from '../account/PublicAccount';
+import { NetworkType } from '../blockchain/NetworkType';
+import { UInt64 } from '../UInt64';
+import { Deadline } from './Deadline';
+import { LinkAction } from './LinkAction';
+import { Transaction } from './Transaction';
+import { TransactionInfo } from './TransactionInfo';
+import { TransactionType } from './TransactionType';
+import { TransactionVersion } from './TransactionVersion';
+
+/**
+ * Announce an AccountLinkTransaction to delegate the account importance to a proxy account.
+ * By doing so, you can enable delegated harvesting
+ */
+export class AccountLinkTransaction extends Transaction {
+    /**
+     * Create a link account transaction object
+     * @param deadline - The deadline to include the transaction.
+     * @param remoteAccountKey - The public key of the remote account.
+     * @param linkAction - The account link action.
+     * @returns {AccountLinkTransaction}
+     */
+    public static create(deadline: Deadline,
+                         remoteAccountKey: string,
+                         linkAction: LinkAction,
+                         networkType: NetworkType): AccountLinkTransaction {
+        return new AccountLinkTransaction(networkType,
+            TransactionVersion.LINK_ACCOUNT,
+            deadline,
+            new UInt64([0, 0]),
+            remoteAccountKey,
+            linkAction);
+    }
+
+    /**
+     * @param networkType
+     * @param version
+     * @param deadline
+     * @param fee
+     * @param remoteAccountKey
+     * @param linkAction
+     * @param signature
+     * @param signer
+     * @param transactionInfo
+     */
+    constructor(networkType: NetworkType,
+                version: number,
+                deadline: Deadline,
+                fee: UInt64,
+                /**
+                 * The public key of the remote account.
+                 */
+                public readonly remoteAccountKey: string,
+                /**
+                 * The account link action.
+                 */
+                public readonly linkAction: LinkAction,
+                signature?: string,
+                signer?: PublicAccount,
+                transactionInfo?: TransactionInfo) {
+        super(TransactionType.LINK_ACCOUNT, networkType, version, deadline, fee, signature, signer, transactionInfo);
+    }
+
+    /**
+     * @internal
+     * @returns {VerifiableTransaction}
+     */
+    protected buildTransaction(): VerifiableTransaction {
+        return new AccountLinkTransactionLibrary.Builder()
+            .addDeadline(this.deadline.toDTO())
+            .addFee(this.fee.toDTO())
+            .addVersion(this.versionToDTO())
+            .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 {
     /**

src/model/transaction/LinkAction.ts

@@ -0,0 +1,20 @@
+/*
+ * 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.
+ */
+
+export enum LinkAction {
+    Link = 0,
+    Unlink = 1,
+}

src/model/transaction/TransactionType.ts

@@ -107,4 +107,10 @@ export class TransactionType {
      * @type {number}
      */
     public static readonly MODIFY_ACCOUNT_PROPERTY_ENTITY_TYPE = 0x4350;
+
+    /**
+     * Link account transaction type
+     * @type {number}
+     */
+    public static readonly LINK_ACCOUNT = 0x414C;
 }

src/model/transaction/TransactionVersion.ts

@@ -115,4 +115,10 @@ export class TransactionVersion {
      * @type {number}
      */
     public static readonly MODIFY_ACCOUNT_PROPERTY_ENTITY_TYPE = 1;
+
+    /**
+     * Link account transaction version
+     * @type {number}
+     */
+    public static readonly LINK_ACCOUNT = 2;
 }

test/model/transaction/AccountLinkTransaction.spec.ts

@@ -0,0 +1,69 @@
+/*
+ * 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 { 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');
+    });
+});