Add a test suite to partialSignature e2e test

Considering transactions which have dynamic inputs and outputs,
a test suite named "dynamic inputs and outputs" is added.

Author: Seonpyo Kim

test/src/e2e/partialSignature.test.ts

@@ -163,6 +163,44 @@ describe("Partial signature", function() {
         expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
     });
 
+    it("Can't add inputs after signing with the signature tag of all inputs when signing burn", async function() {
+        const tx = node.sdk.core
+            .createTransferAssetTransaction()
+            .addBurns(assets[2])
+            .addOutputs({
+                assetType,
+                shardId: 0,
+                quantity: 1000,
+                recipient: address1
+            });
+        await node.sdk.key.signTransactionBurn(tx, 0);
+        tx.addInputs(assets[0]);
+        await node.sdk.key.signTransactionInput(tx, 0);
+
+        await expectTransactionFail(node, tx);
+    });
+
+    it("Can add inputs after signing with the signature tag of signle input when signing burn", async function() {
+        const tx = node.sdk.core
+            .createTransferAssetTransaction()
+            .addBurns(assets[2])
+            .addOutputs({
+                assetType,
+                shardId: 0,
+                quantity: 1000,
+                recipient: address1
+            });
+        await node.sdk.key.signTransactionBurn(tx, 0, {
+            signatureTag: { input: "single", output: "all" }
+        });
+        tx.addInputs(assets[0]);
+        await node.sdk.key.signTransactionInput(tx, 0);
+
+        const hash = await node.sendAssetTransaction(tx);
+        expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
+        expect(await node.sdk.rpc.chain.containsTransaction(hash)).be.true;
+    });
+
     // FIXME: (WIP) It fails
     it("Can't add inputs after signing with the signature tag of all inputs", async function() {
         const tx = node.sdk.core
@@ -334,6 +372,126 @@ describe("Partial signature", function() {
         });
     });
 
+    describe("dynamic inputs and outputs", function() {
+        let splitedAssets: Asset[];
+        const splitCount = 50;
+
+        beforeEach(async function() {
+            const splitTx = node.sdk.core
+                .createTransferAssetTransaction()
+                .addInputs(assets[0])
+                .addOutputs(
+                    _.times(splitCount, () => ({
+                        assetType,
+                        shardId: 0,
+                        quantity: 1000 / splitCount,
+                        recipient: address1
+                    }))
+                );
+
+            await node.sdk.key.signTransactionInput(splitTx, 0);
+            splitedAssets = splitTx.getTransferredAssets();
+            await node.sendAssetTransaction(splitTx);
+        });
+        [5, 10, 20].forEach(function(length) {
+            it(`${length} inputs and outputs : one-to-one sign`, async function() {
+                const tx = node.sdk.core.createTransferAssetTransaction();
+                for (let i = 0; i < length; i++) {
+                    tx.addInputs(splitedAssets[i]).addOutputs({
+                        assetType,
+                        shardId: 0,
+                        quantity: 1000 / splitCount,
+                        recipient: address2
+                    });
+                    await node.sdk.key.signTransactionInput(tx, i, {
+                        signatureTag: {
+                            input: "single",
+                            output: [i]
+                        }
+                    });
+                }
+
+                const hash = await node.sendAssetTransaction(tx);
+                expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
+                    .true;
+            }).timeout(length * 1000 + 5_000);
+        });
+
+        [5, 10, 20].forEach(function(length) {
+            it(`${length} inputs and outputs : one-to-many sign`, async function() {
+                const tx = node.sdk.core.createTransferAssetTransaction();
+                for (let i = 0; i < length; i++) {
+                    tx.addInputs(splitedAssets[i]).addOutputs({
+                        assetType,
+                        shardId: 0,
+                        quantity: 1000 / splitCount,
+                        recipient: address2
+                    });
+                    await node.sdk.key.signTransactionInput(tx, i, {
+                        signatureTag: {
+                            input: "single",
+                            output: _.range(i)
+                        }
+                    });
+                }
+
+                const hash = await node.sendAssetTransaction(tx);
+                expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
+                    .true;
+            }).timeout(length * 1000 + 5_000);
+        });
+
+        [5, 10, 20].forEach(function(length) {
+            it(`${length} burns, inputs and outputs : one-to-many sign`, async function() {
+                const tx = node.sdk.core.createTransferAssetTransaction();
+                for (let i = 0; i < Math.floor(length / 2); i++) {
+                    tx.addInputs(splitedAssets[i]).addOutputs({
+                        assetType,
+                        shardId: 0,
+                        quantity: 1000 / splitCount,
+                        recipient: address2
+                    });
+                    await node.sdk.key.signTransactionInput(tx, i, {
+                        signatureTag: {
+                            input: "single",
+                            output: _.range(i)
+                        }
+                    });
+                }
+
+                tx.addBurns(assets[2]);
+                await node.sdk.key.signTransactionBurn(tx, 0, {
+                    signatureTag: {
+                        input: "single",
+                        output: _.range(Math.floor(length / 2))
+                    }
+                });
+
+                for (let i = Math.floor(length / 2); i < length; i++) {
+                    tx.addInputs(splitedAssets[i]).addOutputs({
+                        assetType,
+                        shardId: 0,
+                        quantity: 1000 / splitCount,
+                        recipient: address2
+                    });
+                    await node.sdk.key.signTransactionInput(tx, i, {
+                        signatureTag: {
+                            input: "single",
+                            output: _.range(i)
+                        }
+                    });
+                }
+
+                const hash = await node.sendAssetTransaction(tx);
+                expect(await node.sdk.rpc.chain.getTransaction(hash)).not.null;
+                expect(await node.sdk.rpc.chain.containsTransaction(hash)).be
+                    .true;
+            }).timeout(length * 1000 + 5_000);
+        });
+    });
+
     afterEach(function() {
         if (this.currentTest!.state === "failed") {
             node.testFailed(this.currentTest!.fullTitle());