Merge pull request #131 from rg911/task/g112_sign_with_cosignatories

Grégory Saive · web-flow · commit dff0235dcd9e · 2019-07-03T15:47:41.000+02:00
Added #112 sign with cosignatories
diff --git a/src/model/transaction/AggregateTransaction.ts b/src/model/transaction/AggregateTransaction.ts
@@ -22,6 +22,7 @@ import { PublicAccount } from '../account/PublicAccount';
 import { NetworkType } from '../blockchain/NetworkType';
 import { UInt64 } from '../UInt64';
 import { AggregateTransactionCosignature } from './AggregateTransactionCosignature';
+import { CosignatureSignedTransaction } from './CosignatureSignedTransaction';
 import { Deadline } from './Deadline';
 import { InnerTransaction } from './InnerTransaction';
 import { SignedTransaction } from './SignedTransaction';
@@ -96,7 +97,7 @@ export class AggregateTransaction extends Transaction {
      * @param {InnerTransaction[]} innerTransactions
      * @param {NetworkType} networkType
      * @param {AggregateTransactionCosignature[]} cosignatures
-     * @param {UInt64} maxFee - (Optional) Max fee defined by the sender
+     * @param {UInt64} maxFee - (Optional) Max fee defined by the sender
      * @return {AggregateTransaction}
      */
     public static createBonded(deadline: Deadline,
@@ -149,6 +150,29 @@ export class AggregateTransaction extends Transaction {
                                      this.type, this.networkType);
     }
 
+    /**
+     * @internal
+     * Sign transaction with cosignatories collected from cosigned transactions and creating a new SignedTransaction
+     * For off chain Aggregated Complete Transaction co-signing.
+     * @param initiatorAccount - Initiator account
+     * @param {CosignatureSignedTransaction[]} cosignatureSignedTransactions - Array of cosigned transaction
+     * @param generationHash - Network generation hash hex
+     * @param {SignSchema} signSchema The Sign Schema. (KECCAK_REVERSED_KEY / SHA3)
+     * @return {SignedTransaction}
+     */
+    public signTransactionGivenSignatures(initiatorAccount: Account,
+                                          cosignatureSignedTransactions: CosignatureSignedTransaction[],
+                                          generationHash: string,
+                                          signSchema: SignSchema= SignSchema.SHA3) {
+        const aggregateTransaction = this.buildTransaction();
+        const signedTransactionRaw = aggregateTransaction.signTransactionGivenSignatures(initiatorAccount,
+                                                                                         cosignatureSignedTransactions,
+                                                                                         generationHash,
+                                                                                         signSchema);
+        return new SignedTransaction(signedTransactionRaw.payload, signedTransactionRaw.hash, initiatorAccount.publicKey,
+                                     this.type, this.networkType);
+    }
+
     /**
      * Check if account has signed transaction
      * @param publicAccount - Signer public account
@@ -179,4 +203,4 @@ export class AggregateTransaction extends Transaction {
 
         return byteSize + byteTransactionsSize + byteTransactions;
     }
-}
+}
diff --git a/src/model/transaction/CosignatureTransaction.ts b/src/model/transaction/CosignatureTransaction.ts
@@ -19,6 +19,7 @@ import {CosignatureTransaction as CosignaturetransactionLibrary} from '../../inf
 import {Account} from '../account/Account';
 import {AggregateTransaction} from './AggregateTransaction';
 import {CosignatureSignedTransaction} from './CosignatureSignedTransaction';
+import { VerifiableTransaction } from '../../infrastructure/builders/VerifiableTransaction';
 
 /**
  * Cosignature transaction is used to sign an aggregate transactions with missing cosignatures.
@@ -46,6 +47,26 @@ export class CosignatureTransaction {
         return new CosignatureTransaction(transactionToCosign);
     }
 
+    /**
+     * Co-sign transaction with transaction payload (off chain)
+     * Creating a new CosignatureSignedTransaction
+     * @param account - The signing account
+     * @param payload - off transaction payload (aggregated transaction is unannounced)
+     * @param gernationHash - Network generation hash
+     * @returns {CosignatureSignedTransaction}
+     */
+    public static signTransactionPayload(account: Account, payload: string, gernationHash: string): CosignatureSignedTransaction {
+        /**
+         * For aggregated complete transaction, cosignatories are gathered off chain announced.
+         */
+        const transactionHash = VerifiableTransaction.createTransactionHash(payload, gernationHash);
+        const aggregateSignatureTransaction = new CosignaturetransactionLibrary(transactionHash);
+        const signedTransactionRaw = aggregateSignatureTransaction.signCosignatoriesTransaction(account);
+        return new CosignatureSignedTransaction(signedTransactionRaw.parentHash,
+            signedTransactionRaw.signature,
+            signedTransactionRaw.signer);
+    }
+
     /**
      * @internal
      * Serialize and sign transaction creating a new SignedTransaction
@@ -60,4 +81,4 @@ export class CosignatureTransaction {
             signedTransactionRaw.signature,
             signedTransactionRaw.signer);
     }
-}
+}
diff --git a/test/model/transaction/AggregateTransaction.spec.ts b/test/model/transaction/AggregateTransaction.spec.ts
@@ -16,6 +16,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 {Account} from '../../../src/model/account/Account';
 import {Address} from '../../../src/model/account/Address';
@@ -27,6 +28,8 @@ import {MosaicProperties} from '../../../src/model/mosaic/MosaicProperties';
 import {MosaicSupplyType} from '../../../src/model/mosaic/MosaicSupplyType';
 import { NetworkCurrencyMosaic } from '../../../src/model/mosaic/NetworkCurrencyMosaic';
 import {AggregateTransaction} from '../../../src/model/transaction/AggregateTransaction';
+import { CosignatureSignedTransaction } from '../../../src/model/transaction/CosignatureSignedTransaction';
+import { CosignatureTransaction } from '../../../src/model/transaction/CosignatureTransaction';
 import {Deadline} from '../../../src/model/transaction/Deadline';
 import {ModifyMultisigAccountTransaction} from '../../../src/model/transaction/ModifyMultisigAccountTransaction';
 import {MosaicDefinitionTransaction} from '../../../src/model/transaction/MosaicDefinitionTransaction';
@@ -35,6 +38,7 @@ import {MultisigCosignatoryModification} from '../../../src/model/transaction/Mu
 import {MultisigCosignatoryModificationType} from '../../../src/model/transaction/MultisigCosignatoryModificationType';
 import {PlainMessage} from '../../../src/model/transaction/PlainMessage';
 import {RegisterNamespaceTransaction} from '../../../src/model/transaction/RegisterNamespaceTransaction';
+import { TransactionType } from '../../../src/model/transaction/TransactionType';
 import {TransferTransaction} from '../../../src/model/transaction/TransferTransaction';
 import {UInt64} from '../../../src/model/UInt64';
 import {Cosignatory2Account, CosignatoryAccount, MultisigAccount, TestingAccount} from '../../conf/conf.spec';
@@ -80,7 +84,7 @@ describe('AggregateTransaction', () => {
             [transferTransaction.toAggregate(account.publicAccount)],
             NetworkType.MIJIN_TEST,
             [],
-            new UInt64([1, 0])
+            new UInt64([1, 0]),
         );
 
         expect(aggregateTransaction.maxFee.higher).to.be.equal(0);
@@ -382,6 +386,65 @@ describe('AggregateTransaction', () => {
         }).to.throw(Error, 'Inner transaction cannot be an aggregated transaction.');
     });
 
+    it('Should create signed transaction with cosignatories - Aggregated Complete', () => {
+        /**
+         * https://github.com/nemtech/nem2-sdk-typescript-javascript/issues/112
+         */
+        const accountAlice = TestingAccount;
+        const accountBob = CosignatoryAccount;
+        const accountCarol = Cosignatory2Account;
+
+        const AtoBTx = TransferTransaction.create(Deadline.create(),
+                                                  accountBob.address,
+                                                  [],
+                                                  PlainMessage.create('a to b'),
+                                                  NetworkType.MIJIN_TEST);
+        const BtoATx = TransferTransaction.create(Deadline.create(),
+                                                  accountAlice.address,
+                                                  [],
+                                                  PlainMessage.create('b to a'),
+                                                  NetworkType.MIJIN_TEST);
+        const CtoATx = TransferTransaction.create(Deadline.create(),
+                                                  accountAlice.address,
+                                                  [],
+                                                  PlainMessage.create('c to a'),
+                                                  NetworkType.MIJIN_TEST);
+
+        // 01. Alice creates the aggregated tx and serialize it, Then payload send to Bob & Carol
+        const aggregateTransactionPayload = AggregateTransaction.createComplete(
+            Deadline.create(),
+            [
+                AtoBTx.toAggregate(accountAlice.publicAccount),
+                BtoATx.toAggregate(accountBob.publicAccount),
+                CtoATx.toAggregate(accountCarol.publicAccount)],
+            NetworkType.MIJIN_TEST,
+            [],
+        ).serialize();
+
+        // 02.1 Bob cosigns the tx and sends it back to Alice
+        const signedTxBob = CosignatureTransaction.signTransactionPayload(accountBob, aggregateTransactionPayload, generationHash);
+
+        // 02.2 Carol cosigns the tx and sends it back to Alice
+        const signedTxCarol = CosignatureTransaction.signTransactionPayload(accountCarol, aggregateTransactionPayload, generationHash);
+
+        // 03. Alice collects the cosignatures, recreate, sign, and announces the transaction
+
+        // First Alice need to append cosignatories to current transaction.
+        const cosignatureSignedTransactions = [
+            new CosignatureSignedTransaction(signedTxBob.parentHash, signedTxBob.signature, signedTxBob.signer),
+            new CosignatureSignedTransaction(signedTxCarol.parentHash, signedTxCarol.signature, signedTxCarol.signer),
+        ];
+
+        const recreatedTx = TransactionMapping.createFromPayload(aggregateTransactionPayload) as AggregateTransaction;
+
+        const signedTransaction = recreatedTx.signTransactionGivenSignatures(accountAlice, cosignatureSignedTransactions, generationHash);
+
+        expect(signedTransaction.type).to.be.equal(TransactionType.AGGREGATE_COMPLETE);
+        expect(signedTransaction.signer).to.be.equal(accountAlice.publicKey);
+        expect(signedTransaction.payload.indexOf(accountBob.publicKey) > -1).to.be.true;
+        expect(signedTransaction.payload.indexOf(accountCarol.publicKey) > -1).to.be.true;
+    });
+
     describe('size', () => {
         it('should return 282 for AggregateTransaction byte size with TransferTransaction with 1 mosaic and message NEM', () => {
             const transaction = TransferTransaction.create(
@@ -402,4 +465,4 @@ describe('AggregateTransaction', () => {
             expect(aggregateTransaction.size).to.be.equal(120 + 4 + 158);
         });
     });
-});
+});
diff --git a/test/model/transaction/CosignatureTransaction.spec.ts b/test/model/transaction/CosignatureTransaction.spec.ts
@@ -17,13 +17,17 @@
 import {expect} from 'chai';
 import {CreateTransactionFromDTO} from '../../../src/infrastructure/transaction/CreateTransactionFromDTO';
 import {Account} from '../../../src/model/account/Account';
+import { NetworkType } from '../../../src/model/blockchain/NetworkType';
 import {AggregateTransaction} from '../../../src/model/transaction/AggregateTransaction';
 import {CosignatureTransaction} from '../../../src/model/transaction/CosignatureTransaction';
+import { Deadline } from '../../../src/model/transaction/Deadline';
+import { PlainMessage } from '../../../src/model/transaction/PlainMessage';
+import { TransferTransaction } from '../../../src/model/transaction/TransferTransaction';
 import {TestingAccount} from '../../conf/conf.spec';
 
 describe('CosignatureTransaction', () => {
     let account: Account;
-
+    const generationHash = '57F7DA205008026C776CB6AED843393F04CD458E0AA2D9F1D5F31A402072B2D6';
     before(() => {
         account = TestingAccount;
     });
@@ -112,4 +116,17 @@ describe('CosignatureTransaction', () => {
             '93D2F8522C8DEAC74BEFBCB61AF6414ADF27B2176D6A24FEF612AA6DB2F562176A11C46BA6D5E05430042CB5705');
         expect(cosignatureSignedTransaction.signer).to.be.equal(account.publicKey);
     });
+
+    it('should sign a transaction with transaction payload', () => {
+        const txPayload = TransferTransaction.create(Deadline.create(),
+                                              account.address,
+                                              [],
+                                              PlainMessage.create('a to b'),
+                                              NetworkType.MIJIN_TEST).serialize();
+
+        const signedTx = CosignatureTransaction.signTransactionPayload(account, txPayload, generationHash);
+
+        expect(signedTx.signer).to.be.equal('C2F93346E27CE6AD1A9F8F5E3066F8326593A406BDF357ACB041E2F9AB402EFE');
+        expect(signedTx.signer).to.be.equal(account.publicKey);
+    });
 });
