Merge branch 'task/g295_namespace_id_in_metadata_mosaic_restriction_transaction' of github.com:NEMStudios/nem2-sdk-typescript-javascript into task/g295_namespace_id_in_metadata_mosaic_restriction_transaction

rg911 · rg911 · commit 9000c0281415 · 2019-10-13T20:31:41.000+01:00
diff --git a/src/model/message/PersistentHarvestingDelegationMessage.ts b/src/model/message/PersistentHarvestingDelegationMessage.ts
@@ -32,17 +32,19 @@ export class PersistentHarvestingDelegationMessage extends Message {
 
     /**
      *
-     * @param harvesterPublicKey - Haverster account public key
-     * @param privateKey - Sender private key
+     * @param delegatedPrivateKey - Private key of delegated account
+     * @param senderPrivateKey - Sender private key
+     * @param recipientPrivateKey - Recipient public key
      * @param {NetworkType} networkType - Catapult network type
      * @return {PersistentHarvestingDelegationMessage}
      */
-    public static create(harvesterPublicKey: string,
-                         privateKey: string,
+    public static create(delegatedPrivateKey: string,
+                         senderPrivateKey: string,
+                         recipientPublicKey: string,
                          networkType: NetworkType): PersistentHarvestingDelegationMessage {
         const signSchema = SHA3Hasher.resolveSignSchema(networkType);
         const encrypted = MessageMarker.PersistentDelegationUnlock +
-            Crypto.encode(privateKey, harvesterPublicKey, harvesterPublicKey, signSchema, true).toUpperCase();
+            Crypto.encode(senderPrivateKey, recipientPublicKey, delegatedPrivateKey, signSchema, true).toUpperCase();
         return new PersistentHarvestingDelegationMessage(encrypted);
     }
 
diff --git a/src/model/transaction/AccountRestrictionTransaction.ts b/src/model/transaction/AccountRestrictionTransaction.ts
@@ -102,7 +102,7 @@ export class AccountRestrictionTransaction {
     ): AccountOperationRestrictionTransaction {
         if (![AccountRestrictionType.AllowIncomingTransactionType,
               AccountRestrictionType.AllowOutgoingTransactionType,
-              AccountRestrictionType.BlockOutgoingTransactionType,
+              AccountRestrictionType.BlockIncomingTransactionType,
               AccountRestrictionType.BlockOutgoingTransactionType].includes(restrictionType)) {
             throw new Error ('Restriction type is not allowed.');
         }
diff --git a/src/model/transaction/AddressAliasTransaction.ts b/src/model/transaction/AddressAliasTransaction.ts
@@ -93,7 +93,7 @@ export class AddressAliasTransaction extends Transaction {
                  */
                 public readonly namespaceId: NamespaceId,
                 /**
-                 * The mosaic id.
+                 * The address.
                  */
                 public readonly address: Address,
                 signature?: string,
diff --git a/src/model/transaction/AggregateTransaction.ts b/src/model/transaction/AggregateTransaction.ts
@@ -289,12 +289,19 @@ export class AggregateTransaction extends Transaction {
      * @internal
      * @returns {Uint8Array}
      */
-    protected generateBytes(): Uint8Array {
+    protected generateBytes(signer?: PublicAccount): Uint8Array {
         const signerBuffer = new Uint8Array(32);
         const signatureBuffer = new Uint8Array(64);
-
         let transactions = Uint8Array.from([]);
         this.innerTransactions.forEach((transaction) => {
+            if (!transaction.signer) {
+                if (this.type === TransactionType.AGGREGATE_COMPLETE) {
+                    transaction = Object.assign({__proto__: Object.getPrototypeOf(transaction)}, transaction, {signer});
+                } else {
+                    throw new Error(
+                        'InnerTransaction signer must be provide. Only AggregateComplete transaction can use delegated signer.');
+                }
+            }
             const transactionByte = transaction.toAggregateTransactionBytes();
             transactions = GeneratorUtils.concatTypedArrays(transactions, transactionByte);
         });
diff --git a/src/model/transaction/InnerTransaction.ts b/src/model/transaction/InnerTransaction.ts
@@ -20,4 +20,4 @@ import {Transaction} from './Transaction';
 /**
  * Transaction with signer included, used when adding signer to transactions included in an aggregate transaction.
  */
-export type InnerTransaction = Transaction &  {signer: PublicAccount};
+export type InnerTransaction = Transaction &  {signer?: PublicAccount};
diff --git a/src/model/transaction/PersistentDelegationRequestTransaction.ts b/src/model/transaction/PersistentDelegationRequestTransaction.ts
@@ -26,19 +26,22 @@ export class PersistentDelegationRequestTransaction extends TransferTransaction
      * Create a PersistentDelegationRequestTransaction with special message payload
      * for presistent harvesting delegation unlocking
      * @param deadline - The deadline to include the transaction.
-     * @param HarvestePublicKey - The harvester public key
+     * @param delegatedPrivateKey - The private key of delegated account
+     * @param recipientPublicKey - The recipient public key
      * @param senderPrivateKey - The sender's private key
      * @param networkType - The network type.
      * @param maxFee - (Optional) Max fee defined by the sender
      * @returns {TransferTransaction}
      */
     public static createPersistentDelegationRequestTransaction(
                     deadline: Deadline,
-                    HarvestePublicKey: string,
+                    delegatedPrivateKey: string,
+                    recipientPublicKey: string,
                     senderPrivateKey: string,
                     networkType: NetworkType,
                     maxFee: UInt64 = new UInt64([0, 0])): PersistentDelegationRequestTransaction {
-        const message = PersistentHarvestingDelegationMessage.create(HarvestePublicKey, senderPrivateKey, networkType);
-        return super.create(deadline, Address.createFromPublicKey(HarvestePublicKey, networkType), [], message, networkType, maxFee);
+        const message = PersistentHarvestingDelegationMessage
+            .create(delegatedPrivateKey, senderPrivateKey, recipientPublicKey, networkType);
+        return super.create(deadline, Address.createFromPublicKey(recipientPublicKey, networkType), [], message, networkType, maxFee);
     }
 }
diff --git a/src/model/transaction/Transaction.ts b/src/model/transaction/Transaction.ts
@@ -105,8 +105,9 @@ export abstract class Transaction {
 
     /**
      * @internal
+     * @param singer Optional singer for delegated aggregate complete transaction only.
      */
-    protected abstract generateBytes(): Uint8Array;
+    protected abstract generateBytes(signer?: PublicAccount): Uint8Array;
 
     /**
      * @internal
@@ -123,7 +124,7 @@ export abstract class Transaction {
     public signWith(account: Account, generationHash: string): SignedTransaction {
         const generationHashBytes = Array.from(Convert.hexToUint8(generationHash));
         const signSchema = SHA3Hasher.resolveSignSchema(account.networkType);
-        const byteBuffer = Array.from(this.generateBytes());
+        const byteBuffer = Array.from(this.generateBytes(account.publicAccount));
         const signingBytes = generationHashBytes.concat(byteBuffer.slice(4 + 64 + 32));
         const keyPairEncoded = KeyPair.createKeyPairFromPrivateKeyString(account.privateKey, signSchema);
         const signature = Array.from(KeyPair.sign(account, new Uint8Array(signingBytes), signSchema));
@@ -162,10 +163,12 @@ export abstract class Transaction {
 
     /**
      * Convert an aggregate transaction to an inner transaction including transaction signer.
-     * @param signer - Transaction signer.
+     * Signer is optional for `AggregateComplete` transaction `ONLY`.
+     * If no signer provided, aggregate transaction signer will be delegated on signing
+     * @param signer - Innre transaction signer. (Optional for `AggregateComplete` transaction `ONLY`)
      * @returns InnerTransaction
      */
-    public toAggregate(signer: PublicAccount): InnerTransaction {
+    public toAggregate(signer?: PublicAccount): InnerTransaction {
         if (this.type === TransactionType.AGGREGATE_BONDED || this.type === TransactionType.AGGREGATE_COMPLETE) {
             throw new Error('Inner transaction cannot be an aggregated transaction.');
         }
diff --git a/src/service/AggregateTransactionService.ts b/src/service/AggregateTransactionService.ts
@@ -53,7 +53,7 @@ export class AggregateTransactionService {
             signers.push(signedTransaction.signerPublicKey);
         }
         return observableFrom(aggregateTransaction.innerTransactions).pipe(
-            mergeMap((innerTransaction) => this.accountHttp.getMultisigAccountInfo(innerTransaction.signer.address)
+            mergeMap((innerTransaction) => this.accountHttp.getMultisigAccountInfo(innerTransaction.signer!.address)
                 .pipe(
                     /**
                      * For multisig account, we need to get the graph info in case it has multiple levels
diff --git a/test/model/message/PersistentHarvestingDelegationMessage.spec.ts b/test/model/message/PersistentHarvestingDelegationMessage.spec.ts
@@ -29,6 +29,7 @@ describe('PersistentHarvestingDelegationMessage', () => {
 
     let sender_nis: Account;
     let recipient_nis: Account;
+    const delegatedPrivateKey = 'F0AB1010EFEE19EE5373719881DF5123C13E643C519655F7E97347BFF77175BF';
     before(() => {
         sender = Account.createFromPrivateKey('2602F4236B199B3DF762B2AAB46FC3B77D8DDB214F0B62538D3827576C46C108',
                                               NetworkType.MIJIN_TEST);
@@ -43,7 +44,8 @@ describe('PersistentHarvestingDelegationMessage', () => {
 
     it('should create a PersistentHarvestingDelegation message', () => {
         const encryptedMessage =
-            PersistentHarvestingDelegationMessage.create(recipient.publicKey, sender.privateKey, NetworkType.MIJIN_TEST);
+            PersistentHarvestingDelegationMessage
+                .create(delegatedPrivateKey, sender.privateKey, recipient.publicKey, NetworkType.MIJIN_TEST);
         expect(encryptedMessage.payload.length).to.be.equal(208);
         expect(encryptedMessage.type).to.be.equal(MessageType.PersistentHarvestingDelegationMessage);
     });
@@ -66,17 +68,19 @@ describe('PersistentHarvestingDelegationMessage', () => {
 
     it('should create and decrypt message', () => {
         const encryptedMessage =
-            PersistentHarvestingDelegationMessage.create(recipient.publicKey, sender.privateKey, NetworkType.MIJIN_TEST);
+            PersistentHarvestingDelegationMessage
+                .create(delegatedPrivateKey, sender.privateKey, recipient.publicKey, NetworkType.MIJIN_TEST);
         const plainMessage =
             PersistentHarvestingDelegationMessage.decrypt(encryptedMessage, recipient.privateKey, sender.publicKey, NetworkType.MIJIN_TEST);
-        expect(plainMessage).to.be.equal(recipient.publicKey);
+        expect(plainMessage).to.be.equal(delegatedPrivateKey);
     });
 
     it('should return should return decrepted message reading from message payload', () => {
         const generationHash = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6';
         const tx =
             PersistentDelegationRequestTransaction.createPersistentDelegationRequestTransaction(
                 Deadline.create(),
+                delegatedPrivateKey,
                 recipient.publicKey,
                 sender.privateKey,
                 NetworkType.MIJIN_TEST,
@@ -87,18 +91,19 @@ describe('PersistentHarvestingDelegationMessage', () => {
                 .createFromPayload(signedTransaction.payload.substring(298, signedTransaction.payload.length));
         const plainMessage =
             PersistentHarvestingDelegationMessage.decrypt(encryptMessage, recipient.privateKey, sender.publicKey, NetworkType.MIJIN_TEST);
-        expect(plainMessage).to.be.equal(recipient.publicKey);
+        expect(plainMessage).to.be.equal(delegatedPrivateKey);
     });
 
     it('should encrypt and decrypt message using NIS1 schema', () => {
         const encryptedMessage =
-            PersistentHarvestingDelegationMessage.create(recipient_nis.publicKey, sender_nis.privateKey, NetworkType.TEST_NET);
+            PersistentHarvestingDelegationMessage
+                .create(delegatedPrivateKey, sender_nis.privateKey, recipient_nis.publicKey, NetworkType.TEST_NET);
         const plainMessage =
             PersistentHarvestingDelegationMessage.decrypt(encryptedMessage,
                                                           recipient_nis.privateKey,
                                                           sender_nis.publicKey,
                                                           NetworkType.TEST_NET);
-        expect(plainMessage).to.be.equal(recipient_nis.publicKey);
+        expect(plainMessage).to.be.equal(delegatedPrivateKey);
     });
 
 });
diff --git a/test/model/transaction/AccountRestrictionTransaction.spec.ts b/test/model/transaction/AccountRestrictionTransaction.spec.ts
@@ -16,11 +16,11 @@
 
 import {expect} from 'chai';
 import {Account} from '../../../src/model/account/Account';
-import { AccountRestrictionModificationAction } from '../../../src/model/restriction/AccountRestrictionModificationAction';
-import { AccountRestrictionType } from '../../../src/model/restriction/AccountRestrictionType';
 import {Address} from '../../../src/model/account/Address';
 import {NetworkType} from '../../../src/model/blockchain/NetworkType';
 import {MosaicId} from '../../../src/model/mosaic/MosaicId';
+import { AccountRestrictionModificationAction } from '../../../src/model/restriction/AccountRestrictionModificationAction';
+import { AccountRestrictionType } from '../../../src/model/restriction/AccountRestrictionType';
 import { AccountRestrictionModification } from '../../../src/model/transaction/AccountRestrictionModification';
 import {AccountRestrictionTransaction} from '../../../src/model/transaction/AccountRestrictionTransaction';
 import {Deadline} from '../../../src/model/transaction/Deadline';
diff --git a/test/model/transaction/AggregateTransaction.spec.ts b/test/model/transaction/AggregateTransaction.spec.ts
@@ -18,6 +18,7 @@ import {expect} from 'chai';
 import {ChronoUnit} from 'js-joda';
 import { TransactionMapping } from '../../../src/core/utils/TransactionMapping';
 import {CreateTransactionFromDTO} from '../../../src/infrastructure/transaction/CreateTransactionFromDTO';
+import { CreateTransactionFromPayload } from '../../../src/infrastructure/transaction/CreateTransactionFromPayload';
 import {Account} from '../../../src/model/account/Account';
 import {Address} from '../../../src/model/account/Address';
 import {PublicAccount} from '../../../src/model/account/PublicAccount';
@@ -116,6 +117,55 @@ describe('AggregateTransaction', () => {
         )).to.be.equal('019054419050B9837EFAB4BBE8A4B9BB32D812F9885C00D8FC1650E1420D000000746573742D6D657373616765');
     });
 
+    it('should createComplete an AggregateTransaction object with delegated signer', () => {
+        const transferTransaction = TransferTransaction.create(
+            Deadline.create(1, ChronoUnit.HOURS),
+            Address.createFromRawAddress('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC'),
+            [],
+            PlainMessage.create('test-message'),
+            NetworkType.MIJIN_TEST,
+        );
+
+        const aggregateTransaction = AggregateTransaction.createComplete(
+            Deadline.create(),
+            [transferTransaction.toAggregate()],
+            NetworkType.MIJIN_TEST,
+            []);
+        expect(aggregateTransaction.innerTransactions[0].signer).to.be.undefined;
+
+        const signedTransaction = aggregateTransaction.signWith(account, generationHash);
+
+        expect(signedTransaction.payload.substring(0, 8)).to.be.equal('CD000000');
+        expect(signedTransaction.payload.substring(240, 256)).to.be.equal('5100000051000000');
+        expect(signedTransaction.payload.substring(
+            320,
+            signedTransaction.payload.length,
+        )).to.be.equal('019054419050B9837EFAB4BBE8A4B9BB32D812F9885C00D8FC1650E1420D000000746573742D6D657373616765');
+
+        const createdFromPayload = CreateTransactionFromPayload(signedTransaction.payload);
+        expect((createdFromPayload as AggregateTransaction).innerTransactions[0].signer!.publicKey)
+            .to.be.equal(account.publicKey);
+    });
+
+    it('should throw exception with delegated signer', () => {
+        expect(() => {
+            const transferTransaction = TransferTransaction.create(
+                Deadline.create(1, ChronoUnit.HOURS),
+                Address.createFromRawAddress('SBILTA367K2LX2FEXG5TFWAS7GEFYAGY7QLFBYKC'),
+                [],
+                PlainMessage.create('test-message'),
+                NetworkType.MIJIN_TEST,
+            );
+            const aggregateTransaction = AggregateTransaction.createBonded(
+                Deadline.create(),
+                [transferTransaction.toAggregate()],
+                NetworkType.MIJIN_TEST,
+                []);
+
+            aggregateTransaction.signWith(account, generationHash);
+        }).to.throw(Error, 'InnerTransaction signer must be provide. Only AggregateComplete transaction can use delegated signer.');
+    });
+
     it('should createComplete an AggregateTransaction object with NamespaceRegistrationTransaction', () => {
         const registerNamespaceTransaction = NamespaceRegistrationTransaction.createRootNamespace(
             Deadline.create(),
diff --git a/test/model/transaction/PersistentDelegationRequestTransaction.spec.ts b/test/model/transaction/PersistentDelegationRequestTransaction.spec.ts
@@ -27,7 +27,8 @@ import { TestingAccount } from '../../conf/conf.spec';
 
 describe('PersistentDelegationRequestTransaction', () => {
     let account: Account;
-    const harvesterPublicKey = '8A78C9E9B0E59D0F74C0D47AB29FBD523C706293A3FA9CD9FE0EEB2C10EA924A';
+    const delegatedPrivateKey = '8A78C9E9B0E59D0F74C0D47AB29FBD523C706293A3FA9CD9FE0EEB2C10EA924A';
+    const recipientPublicKey = '9DBF67474D6E1F8B131B4EB1F5BA0595AFFAE1123607BC1048F342193D7E669F';
     const generationHash = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6';
     const messageMarker = 'FECC71C764BFE598';
 
@@ -39,7 +40,8 @@ describe('PersistentDelegationRequestTransaction', () => {
         const persistentDelegationRequestTransaction =
             PersistentDelegationRequestTransaction.createPersistentDelegationRequestTransaction(
                 Deadline.create(),
-                harvesterPublicKey,
+                delegatedPrivateKey,
+                recipientPublicKey,
                 account.privateKey,
                 NetworkType.MIJIN_TEST,
             );
@@ -52,7 +54,8 @@ describe('PersistentDelegationRequestTransaction', () => {
         const persistentDelegationRequestTransaction =
             PersistentDelegationRequestTransaction.createPersistentDelegationRequestTransaction(
                 Deadline.create(),
-                harvesterPublicKey,
+                delegatedPrivateKey,
+                recipientPublicKey,
                 account.privateKey,
                 NetworkType.MIJIN_TEST,
                 new UInt64([1, 0]),
@@ -66,7 +69,8 @@ describe('PersistentDelegationRequestTransaction', () => {
         const persistentDelegationRequestTransaction =
             PersistentDelegationRequestTransaction.createPersistentDelegationRequestTransaction(
                 Deadline.create(),
-                harvesterPublicKey,
+                delegatedPrivateKey,
+                recipientPublicKey,
                 account.privateKey,
                 NetworkType.MIJIN_TEST,
             );
@@ -76,7 +80,7 @@ describe('PersistentDelegationRequestTransaction', () => {
         expect(persistentDelegationRequestTransaction.mosaics.length).to.be.equal(0);
         expect(persistentDelegationRequestTransaction.recipientAddress).to.be.instanceof(Address);
         expect((persistentDelegationRequestTransaction.recipientAddress as Address).plain())
-            .to.be.equal('SAMA2UEQNAQ45DWYDNJVLPWKQJDAHFZIVLWACIGN');
+            .to.be.equal('SDBC4JE7GTJAKN2XJCQWWRJMYA35AFOYQBATXOUA');
 
         const signedTransaction = persistentDelegationRequestTransaction.signWith(account, generationHash);
 
@@ -91,6 +95,7 @@ describe('PersistentDelegationRequestTransaction', () => {
             PersistentDelegationRequestTransaction.createPersistentDelegationRequestTransaction(
                 Deadline.create(),
                 'abc',
+                recipientPublicKey,
                 account.privateKey,
                 NetworkType.MIJIN_TEST,
                 new UInt64([1, 0]),
@@ -102,7 +107,8 @@ describe('PersistentDelegationRequestTransaction', () => {
         expect(() => {
             PersistentDelegationRequestTransaction.createPersistentDelegationRequestTransaction(
                 Deadline.create(),
-                harvesterPublicKey,
+                delegatedPrivateKey,
+                recipientPublicKey,
                 'abc',
                 NetworkType.MIJIN_TEST,
                 new UInt64([1, 0]),
diff --git a/test/model/transaction/TransferTransaction.spec.ts b/test/model/transaction/TransferTransaction.spec.ts

Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ export class AccountRestrictionTransaction {`
`102`	`102`	`): AccountOperationRestrictionTransaction {`
`103`	`103`	`if (![AccountRestrictionType.AllowIncomingTransactionType,`
`104`	`104`	`AccountRestrictionType.AllowOutgoingTransactionType,`
`105`		`- AccountRestrictionType.BlockOutgoingTransactionType,`
	`105`	`+ AccountRestrictionType.BlockIncomingTransactionType,`
`106`	`106`	`AccountRestrictionType.BlockOutgoingTransactionType].includes(restrictionType)) {`
`107`	`107`	`throw new Error ('Restriction type is not allowed.');`
`108`	`108`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ export class AggregateTransactionService {`
`53`	`53`	`signers.push(signedTransaction.signerPublicKey);`
`54`	`54`	`}`
`55`	`55`	`return observableFrom(aggregateTransaction.innerTransactions).pipe(`
`56`		`- mergeMap((innerTransaction) => this.accountHttp.getMultisigAccountInfo(innerTransaction.signer.address)`
	`56`	`+ mergeMap((innerTransaction) => this.accountHttp.getMultisigAccountInfo(innerTransaction.signer!.address)`
`57`	`57`	`.pipe(`
`58`	`58`	`/**`
`59`	`59`	`* For multisig account, we need to get the graph info in case it has multiple levels`