Change pay, shard, and regularkey e2e tests

Author: MSNTCS

test/src/e2e/pay.test.ts

@@ -29,33 +29,57 @@ describe("Pay", async function() {
 
     it("Allow zero pay", async function() {
         const pay = await node.sendPayTx({ quantity: 0 });
-        expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
-            .true;
-        expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not.null;
+        expect(
+            await node.rpc.chain.containsTransaction({
+                transactionHash: `0x${pay.hash().toString()}`
+            })
+        ).be.true;
+        expect(
+            await node.rpc.chain.getTransaction({
+                transactionHash: `0x${pay.hash().toString()}`
+            })
+        ).not.null;
     });
 
     it("Allow pay to itself", async function() {
         const pay = await node.sendPayTx({
             quantity: 100,
             recipient: faucetAddress
         });
-        expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
-            .true;
-        expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not.null;
+        expect(
+            await node.rpc.chain.containsTransaction({
+                transactionHash: `0x${pay.hash().toString()}`
+            })
+        ).be.true;
+        expect(
+            await node.rpc.chain.getTransaction({
+                transactionHash: `0x${pay.hash().toString()}`
+            })
+        ).not.null;
     });
 
     it("Cannot pay to regular key", async function() {
         const charge = await node.sendPayTx({
             quantity: 100000,
             recipient: aliceAddress
         });
-        expect(await node.sdk.rpc.chain.containsTransaction(charge.hash())).be
-            .true;
-        expect(await node.sdk.rpc.chain.getTransaction(charge.hash())).not.null;
+        expect(
+            await node.rpc.chain.containsTransaction({
+                transactionHash: `0x${charge.hash().toString()}`
+            })
+        ).be.true;
+        expect(
+            await node.rpc.chain.getTransaction({
+                transactionHash: `0x${charge.hash().toString()}`
+            })
+        ).not.null;
 
         const privKey = node.sdk.util.generatePrivateKey();
         const pubKey = node.sdk.util.getPublicFromPrivate(privKey);
-        const aliceSeq = await node.sdk.rpc.chain.getSeq(aliceAddress);
+        const aliceSeq = (await node.rpc.chain.getSeq({
+            address: aliceAddress.toString(),
+            blockNumber: null
+        }))!;
         await node.setRegularKey(pubKey, {
             seq: aliceSeq,
             secret: aliceSecret
@@ -64,10 +88,13 @@ describe("Pay", async function() {
             networkId: node.sdk.networkId
         });
 
-        const seq = await node.sdk.rpc.chain.getSeq(faucetAddress);
+        const seq = (await node.rpc.chain.getSeq({
+            address: faucetAddress.toString(),
+            blockNumber: null
+        }))!;
         const blockNumber = await node.getBestBlockNumber();
 
-        await node.sdk.rpc.devel.stopSealing();
+        await node.rpc.devel!.stopSealing();
 
         const pay = await node.sendPayTx({ quantity: 0, seq });
         const fail = await node.sendPayTx({
@@ -76,16 +103,30 @@ describe("Pay", async function() {
             seq: seq + 1
         });
 
-        await node.sdk.rpc.devel.startSealing();
+        await node.rpc.devel!.startSealing();
         await node.waitBlockNumber(blockNumber + 1);
 
-        expect(await node.sdk.rpc.chain.containsTransaction(pay.hash())).be
-            .true;
-        expect(await node.sdk.rpc.chain.getTransaction(pay.hash())).not.null;
+        expect(
+            await node.rpc.chain.containsTransaction({
+                transactionHash: `0x${charge.hash().toString()}`
+            })
+        ).be.true;
+        expect(
+            await node.rpc.chain.getTransaction({
+                transactionHash: `0x${pay.hash().toString()}`
+            })
+        ).not.null;
 
-        expect(await node.sdk.rpc.chain.containsTransaction(fail.hash())).be
-            .false;
-        expect(await node.sdk.rpc.chain.getTransaction(fail.hash())).null;
+        expect(
+            await node.rpc.chain.containsTransaction({
+                transactionHash: `0x${fail.hash().toString()}`
+            })
+        ).be.false;
+        expect(
+            await node.rpc.chain.getTransaction({
+                transactionHash: `0x${fail.hash().toString()}`
+            })
+        ).null;
         expect(await node.sdk.rpc.chain.getErrorHint(fail.hash())).not.null;
     });
 

test/src/e2e/regularkey.test.ts

@@ -80,12 +80,15 @@ describe("solo - 1 node", function() {
     });
 
     it("Try to use the master key instead of the regular key", async function() {
-        const seq = await node.sdk.rpc.chain.getSeq(faucetAddress);
-        const blockNumber = await node.sdk.rpc.chain.getBestBlockNumber();
-        await node.sdk.rpc.devel.stopSealing();
+        const seq = (await node.rpc.chain.getSeq({
+            address: faucetAddress.toString(),
+            blockNumber: null
+        }))!;
+        const blockNumber = await node.rpc.chain.getBestBlockNumber();
+        await node.rpc.devel!.stopSealing();
         const hash = await node.setRegularKey(pubKey, { seq });
         const tx = await node.sendPayTx({ seq: seq + 1 });
-        await node.sdk.rpc.devel.startSealing();
+        await node.rpc.devel!.startSealing();
         await node.waitBlockNumber(blockNumber + 1);
 
         expect(await node.sdk.rpc.chain.getErrorHint(hash)).be.null;
@@ -99,16 +102,19 @@ describe("solo - 1 node", function() {
             { networkId: "tc" }
         ).toString();
 
-        await node.sdk.rpc.devel.stopSealing();
-        const blockNumber = await node.sdk.rpc.chain.getBestBlockNumber();
-        const seq = await node.sdk.rpc.chain.getSeq(faucetAddress);
+        await node.rpc.devel!.stopSealing();
+        const blockNumber = await node.rpc.chain.getBestBlockNumber();
+        const seq = (await node.rpc.chain.getSeq({
+            address: faucetAddress.toString(),
+            blockNumber: null
+        }))!;
         const tx1 = await node.sendPayTx({
             quantity: 5,
             recipient: address,
             seq
         });
         const hash2 = await node.setRegularKey(pubKey, { seq: seq + 1 });
-        await node.sdk.rpc.devel.startSealing();
+        await node.rpc.devel!.startSealing();
         await node.waitBlockNumber(blockNumber + 1);
 
         const block = (await node.sdk.rpc.chain.getBlock(blockNumber + 1))!;
@@ -127,19 +133,22 @@ describe("solo - 1 node", function() {
         ).toString();
 
         await node.sendPayTx({ quantity: 100, recipient: address });
-        const seq = await node.sdk.rpc.chain.getSeq(address);
+        const seq = (await node.rpc.chain.getSeq({
+            address: address.toString(),
+            blockNumber: null
+        }))!;
 
         const blockNumber = await node.sdk.rpc.chain.getBestBlockNumber();
 
-        await node.sdk.rpc.devel.stopSealing();
+        await node.rpc.devel!.stopSealing();
         const hash1 = await node.setRegularKey(pubKey, {
             seq,
             secret: newPrivKey
         });
         const hash2 = await node.setRegularKey(pubKey, {
             seq: seq + 1
         });
-        await node.sdk.rpc.devel.startSealing();
+        await node.rpc.devel!.startSealing();
 
         await node.waitBlockNumber(blockNumber);