@bitpay-labs/bitcore-wallet-service 11.6.6 → 11.7.0

package/ts_build/test/integration/server.test.js

@@ -7274,6 +7274,287 @@ describe('Wallet service', function () {
             });
         });
     });
+    describe('#prepareTx (deferred nonce)', function () {
+        const ETH_ADDR = '0x37d7B3bBD88EFdE6a93cF74D2F5b0385D3E3B08A';
+        let server, wallet, fromAddr;
+        beforeEach(async function () {
+            ({ server, wallet } = await helpers_1.default.createAndJoinWallet(1, 1, { coin: 'eth' }));
+            const address = await util_1.default.promisify(server.createAddress).call(server, {});
+            fromAddr = address.address;
+            await helpers_1.default.stubUtxos(server, wallet, [1, 2], { coin: 'eth' });
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '5');
+        });
+        it('should create txp with nonce=null when deferNonce is true', async function () {
+            const txOpts = {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            };
+            const txp = await util_1.default.promisify(server.createTx).call(server, txOpts);
+            should.exist(txp);
+            txp.deferNonce.should.be.true;
+            should.not.exist(txp.nonce);
+        });
+        it('should create txp with nonce when deferNonce is absent', async function () {
+            const txOpts = {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr
+            };
+            const txp = await util_1.default.promisify(server.createTx).call(server, txOpts);
+            should.exist(txp);
+            should.not.exist(txp.deferNonce);
+            txp.nonce.should.equal('5');
+        });
+        it('should publish a deferred-nonce txp and save prePublishRaw', async function () {
+            const txOpts = {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            };
+            const txp = await util_1.default.promisify(server.createTx).call(server, txOpts);
+            should.not.exist(txp.nonce);
+            const publishOpts = helpers_1.default.getProposalSignatureOpts(txp, TestData.copayers[0].privKey_1H_0);
+            const published = await util_1.default.promisify(server.publishTx).call(server, publishOpts);
+            should.exist(published);
+            published.status.should.equal('pending');
+            published.deferNonce.should.be.true;
+            should.exist(published.prePublishRaw);
+        });
+        it('should assign nonce to a deferred-nonce txp', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '10');
+            const txp = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            }, TestData.copayers[0].privKey_1H_0);
+            should.not.exist(txp.nonce);
+            const result = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: txp.id
+            });
+            should.exist(result);
+            result.nonce.should.equal(10);
+        });
+        it('should return txp as-is if deferNonce is not set', async function () {
+            const txp = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr
+            }, TestData.copayers[0].privKey_1H_0);
+            txp.nonce.should.equal('5');
+            const result = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: txp.id
+            });
+            result.nonce.should.equal('5');
+        });
+        it('should fail for non-existent txp', function (done) {
+            server.prepareTx({ txProposalId: 'nonexistent' }, function (err) {
+                should.exist(err);
+                err.message.should.contain('not found');
+                done();
+            });
+        });
+        it('should calculate gap-free nonce skipping pending txp nonces', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '5');
+            const txp1 = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 1000 }],
+                feePerKb: 123e2,
+                from: fromAddr
+            }, TestData.copayers[0].privKey_1H_0);
+            txp1.nonce.should.equal('5');
+            const txp2 = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 2000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            }, TestData.copayers[0].privKey_1H_0);
+            should.not.exist(txp2.nonce);
+            const result = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: txp2.id
+            });
+            result.nonce.should.equal(6);
+        });
+        it('should assign sequential nonces for multiple deferred txps', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '0');
+            const txps = [];
+            for (let i = 0; i < 3; i++) {
+                const txp = await helpers_1.default.createAndPublishTx(server, {
+                    outputs: [{ toAddress: ETH_ADDR, amount: 1000 * (i + 1) }],
+                    feePerKb: 123e2,
+                    from: fromAddr,
+                    deferNonce: true
+                }, TestData.copayers[0].privKey_1H_0);
+                txps.push(txp);
+            }
+            const results = [];
+            for (const txp of txps) {
+                const result = await util_1.default.promisify(server.prepareTx).call(server, {
+                    txProposalId: txp.id
+                });
+                results.push(result);
+            }
+            results[0].nonce.should.equal(0);
+            results[1].nonce.should.equal(1);
+            results[2].nonce.should.equal(2);
+        });
+        it('should handle mix of normal and deferred-nonce txps', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '3');
+            const normalTxp = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 1000 }],
+                feePerKb: 123e2,
+                from: fromAddr
+            }, TestData.copayers[0].privKey_1H_0);
+            normalTxp.nonce.should.equal('3');
+            const deferred1 = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 2000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            }, TestData.copayers[0].privKey_1H_0);
+            const deferred2 = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 3000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            }, TestData.copayers[0].privKey_1H_0);
+            const result1 = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: deferred1.id
+            });
+            result1.nonce.should.equal(4);
+            const result2 = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: deferred2.id
+            });
+            result2.nonce.should.equal(5);
+        });
+        it('should sign a deferred-nonce txp after assignNonce', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '7');
+            helpers_1.default.stubBroadcast('txid123');
+            const txp = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            }, TestData.copayers[0].privKey_1H_0);
+            const withNonce = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: txp.id
+            });
+            withNonce.nonce.should.equal(7);
+            const fetched = await util_1.default.promisify(server.getTx).call(server, { txProposalId: txp.id });
+            const signatures = helpers_1.default.clientSign(fetched, TestData.copayers[0].xPrivKey_44H_0H_0H);
+            const signed = await util_1.default.promisify(server.signTx).call(server, {
+                txProposalId: txp.id,
+                signatures
+            });
+            signed.status.should.equal('accepted');
+        });
+        it('should not trigger nonce conflict for deferred txps with null nonce', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '5');
+            const normalTxp = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 1000 }],
+                feePerKb: 123e2,
+                from: fromAddr
+            }, TestData.copayers[0].privKey_1H_0);
+            normalTxp.nonce.should.equal('5');
+            const deferredTxp = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 2000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            }, TestData.copayers[0].privKey_1H_0);
+            const withNonce = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: deferredTxp.id
+            });
+            withNonce.nonce.should.equal(6);
+            const sigs1 = helpers_1.default.clientSign(normalTxp, TestData.copayers[0].xPrivKey_44H_0H_0H);
+            const signed1 = await util_1.default.promisify(server.signTx).call(server, {
+                txProposalId: normalTxp.id,
+                signatures: sigs1
+            });
+            signed1.status.should.equal('accepted');
+            helpers_1.default.stubBroadcast(signed1.txid);
+            await util_1.default.promisify(server.broadcastTx).call(server, { txProposalId: normalTxp.id });
+            const fetchedDeferred = await util_1.default.promisify(server.getTx).call(server, { txProposalId: deferredTxp.id });
+            const sigs2 = helpers_1.default.clientSign(fetchedDeferred, TestData.copayers[0].xPrivKey_44H_0H_0H);
+            const signed2 = await util_1.default.promisify(server.signTx).call(server, {
+                txProposalId: deferredTxp.id,
+                signatures: sigs2
+            });
+            signed2.status.should.equal('accepted');
+        });
+        it('should complete full lifecycle for a deferred-nonce txp', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '42');
+            const txOpts = {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            };
+            const created = await util_1.default.promisify(server.createTx).call(server, txOpts);
+            created.isTemporary().should.be.true;
+            created.deferNonce.should.be.true;
+            should.not.exist(created.nonce);
+            const publishOpts = helpers_1.default.getProposalSignatureOpts(created, TestData.copayers[0].privKey_1H_0);
+            const published = await util_1.default.promisify(server.publishTx).call(server, publishOpts);
+            published.status.should.equal('pending');
+            should.exist(published.prePublishRaw);
+            const withNonce = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: created.id
+            });
+            withNonce.nonce.should.equal(42);
+            const fetched = await util_1.default.promisify(server.getTx).call(server, { txProposalId: created.id });
+            const signatures = helpers_1.default.clientSign(fetched, TestData.copayers[0].xPrivKey_44H_0H_0H);
+            const signed = await util_1.default.promisify(server.signTx).call(server, {
+                txProposalId: created.id,
+                signatures
+            });
+            signed.status.should.equal('accepted');
+            helpers_1.default.stubBroadcast(signed.txid);
+            const broadcasted = await util_1.default.promisify(server.broadcastTx).call(server, {
+                txProposalId: created.id
+            });
+            broadcasted.status.should.equal('broadcasted');
+            should.exist(broadcasted.txid);
+        });
+        it('should handle bulk sign scenario (3 deferred txps signed sequentially)', async function () {
+            blockchainExplorer.getTransactionCount = sinon_1.default.stub().callsArgWith(1, null, '10');
+            const txps = [];
+            for (let i = 0; i < 3; i++) {
+                const txp = await helpers_1.default.createAndPublishTx(server, {
+                    outputs: [{ toAddress: ETH_ADDR, amount: 1000 * (i + 1) }],
+                    feePerKb: 123e2,
+                    from: fromAddr,
+                    deferNonce: true
+                }, TestData.copayers[0].privKey_1H_0);
+                txps.push(txp);
+            }
+            const assignedNonces = [];
+            for (let i = 0; i < txps.length; i++) {
+                const withNonce = await util_1.default.promisify(server.prepareTx).call(server, {
+                    txProposalId: txps[i].id
+                });
+                withNonce.nonce.should.equal(10 + i);
+                assignedNonces.push(withNonce.nonce);
+            }
+            assignedNonces.should.deep.equal([10, 11, 12]);
+        });
+        it('should return txp with nonce set (extensibility baseline)', async function () {
+            const txp = await helpers_1.default.createAndPublishTx(server, {
+                outputs: [{ toAddress: ETH_ADDR, amount: 8000 }],
+                feePerKb: 123e2,
+                from: fromAddr,
+                deferNonce: true
+            }, TestData.copayers[0].privKey_1H_0);
+            should.not.exist(txp.nonce);
+            const result = await util_1.default.promisify(server.prepareTx).call(server, {
+                txProposalId: txp.id
+            });
+            result.nonce.should.be.a('number');
+            result.nonce.should.equal(5);
+        });
+    });
     describe('#broadcastTx & #broadcastRawTx', function () {
         let server;
         let wallet;