Fixed race condition issue through copying a parameter

package.json

@@ -1,6 +1,6 @@
 {
   "name": "caver-js",
-  "version": "1.6.6",
+  "version": "1.6.7",
   "description": "caver-js is a JavaScript API library that allows developers to interact with a Klaytn node",
   "main": "index.js",
   "types": "types/index.d.ts",

packages/caver-core-subscriptions/src/subscription.js

@@ -235,10 +235,14 @@ Subscription.prototype.subscribe = function() {
         isFinite(payload.params[1].fromBlock)
     ) {
         // send the subscription request
+
+        // copy the params to avoid race-condition with deletion below this block
+        const blockParams = { ...payload.params[1] }
+
         this.options.requestManager.send(
             {
                 method: 'klay_getLogs',
-                params: [payload.params[1]],
+                params: [blockParams],
             },
             function(err, logs) {
                 if (!err) {

test/subscription.js

@@ -26,6 +26,8 @@ const caver = new Caver(websocketURL)
 let senderPrvKey
 let senderAddress
 let receiver
+let contractAddress
+let contractAbi
 
 // If you are using websocket provider, subscribe the 'newBlockHeaders' event through the subscriptions object after sending the transaction.
 // When receiving the 'newBlockHeaders' event, it queries the transaction receipt.
@@ -42,19 +44,41 @@ let receiver
 // -> [request] klay_getTransactionReceipt
 // -> [response] receipt
 
-before(() => {
-    senderPrvKey =
-        process.env.privateKey && String(process.env.privateKey).indexOf('0x') === -1
-            ? `0x${process.env.privateKey}`
-            : process.env.privateKey
+async function prepareContractTesting() {
+    const kip7 = await caver.kct.kip7.deploy(
+        {
+            name: 'Jamie',
+            symbol: 'JME',
+            decimals: 18,
+            initialSupply: '1000000000000',
+        },
+        senderAddress
+    )
+    contractAddress = kip7.options.address
+    contractAbi = kip7.options.jsonInterface
 
-    senderAddress = caver.klay.accounts.wallet.add(senderPrvKey).address
+    return kip7.transfer(receiver.address, 1000, { from: senderAddress })
+}
 
-    receiver = caver.klay.accounts.wallet.add(caver.klay.accounts.create())
-})
+describe('subscription should work well with websocket connection', () => {
+    before(function(done) {
+        this.timeout(200000)
+
+        senderPrvKey =
+            process.env.privateKey && String(process.env.privateKey).indexOf('0x') === -1
+                ? `0x${process.env.privateKey}`
+                : process.env.privateKey
+
+        senderAddress = caver.klay.accounts.wallet.add(senderPrvKey).address
+        caver.wallet.add(caver.wallet.keyring.createFromPrivateKey(senderPrvKey))
 
-describe('get transaction', () => {
-    it('CAVERJS-UNIT-ETC-094: getTransaction should return information of transaction.', async () => {
+        receiver = caver.klay.accounts.wallet.add(caver.klay.accounts.create())
+        caver.wallet.add(caver.wallet.keyring.createFromPrivateKey(receiver.privateKey))
+
+        prepareContractTesting().then(() => done())
+    })
+
+    it('CAVERJS-UNIT-ETC-094: sendTransaction should return a transaction receipt.', async () => {
         const txObj = {
             from: senderAddress,
             to: receiver.address,
@@ -83,17 +107,42 @@ describe('get transaction', () => {
         expect(receipt.typeInt).not.to.undefined
         expect(receipt.value).not.to.undefined
     }).timeout(10000)
-})
 
-describe('Subscribe test throught contract event', () => {
     it('CAVERJS-UNIT-ETC-262: should emit subscription id when subscription is created', done => {
-        caver.wallet.add(caver.wallet.keyring.createFromPrivateKey(senderPrvKey)).address
         caver.kct.kip17.deploy({ name: 'Jasmine', symbol: 'JAS' }, senderAddress).then(deployed => {
             deployed.events.MinterAdded({}).on('connected', subscriptionId => {
                 expect(subscriptionId).not.to.be.undefined
-                caver.currentProvider.connection.close()
                 done()
             })
         })
     }).timeout(30000)
+
+    // Regression test for a race-condition where a fresh caver instance
+    // subscribing to past events would have its call parameters deleted while it
+    // made initial Websocket handshake and return an incorrect response.
+    it('CAVERJS-UNIT-ETC-398: should immediately listen for events in the past', async () => {
+        const freshCaver = new Caver(websocketURL)
+        const contract = freshCaver.contract.create(contractAbi, contractAddress)
+
+        let counter = 0
+        const latestBlock = await caver.rpc.klay.getBlockNumber()
+        caver.currentProvider.connection.close()
+
+        await new Promise(resolve => {
+            contract.events
+                .allEvents({
+                    fromBlock: 0,
+                })
+                .on('data', function(event) {
+                    counter++
+                    expect(event.blockNumber < latestBlock).to.be.true
+
+                    if (counter === 2) {
+                        this.removeAllListeners()
+                        freshCaver.currentProvider.connection.close()
+                        resolve()
+                    }
+                })
+        })
+    }).timeout(30000)
 })