added consecutive mint e2e test

Author: dan13ram

e2e/Makefile

@@ -5,4 +5,4 @@ clean:
 	sudo rm -rf /tmp/data
 
 test:
-	cd tester && yarn install && yarn test
+	cd tester && yarn install && yarn debug-test

e2e/tester/flows/burn.ts

@@ -1,4 +1,4 @@
-import { parseUnits, recoverAddress } from "viem";
+import { parseUnits } from "viem";
 import ethereum from "../util/ethereum";
 import pocket from "../util/pocket";
 import { expect } from "chai";
@@ -16,7 +16,9 @@ type MessageSend = {
 };
 
 export const burnFlow = async () => {
-  it("should burn for send tx to vault with valid memo", async () => {
+  it("should burn and return amount from vault", async () => {
+    debug("\nTesting -- should burn and return amount from vault");
+
     const fromAddress = await ethereum.getAddress();
     const recipientAddress = await pocket.getAddress();
     const amount = parseUnits("1", 6);
@@ -25,8 +27,6 @@ export const burnFlow = async () => {
     const recipientBeforeBalance = await pocket.getBalance(recipientAddress);
     const fromBeforeBalance = await ethereum.getWPOKTBalance(fromAddress);
 
-    expect(fromBeforeBalance).to.be.equal(amount);
-
     debug("Sending transaction...");
     const burnTx = await ethereum.burnAndBridgeWPOKT(
       await ethereum.walletPromise,

e2e/tester/flows/mint.ts

@@ -1,9 +1,9 @@
-import { parseUnits } from "viem";
+import { TransactionReceipt, parseUnits } from "viem";
 import ethereum from "../util/ethereum";
 import pocket from "../util/pocket";
 import { expect } from "chai";
 import { findInvalidMint, findMint } from "../util/mongodb";
-import { MintMemo, Status } from "../types";
+import { Mint, MintMemo, Status } from "../types";
 import { sleep, debug } from "../util/helpers";
 
 type MessageSend = {
@@ -17,6 +17,8 @@ type MessageSend = {
 
 export const mintFlow = async () => {
   it("should mint for send tx to vault with valid memo", async () => {
+    debug("\nTesting -- should mint for send tx to vault with valid memo");
+
     const signer = await pocket.signerPromise;
     const fromAddress = await pocket.getAddress();
     const recipientAddress = await ethereum.getAddress();
@@ -166,6 +168,10 @@ export const mintFlow = async () => {
   });
 
   it("should fail mint to invalidMint for failed send tx to vault", async () => {
+    debug(
+      "\nTesting -- should fail mint to invalidMint for failed send tx to vault"
+    );
+
     const signer = await pocket.signerPromise;
     const fromAddress = await pocket.getAddress();
     const toAddress = pocket.VAULT_ADDRESS;
@@ -204,6 +210,10 @@ export const mintFlow = async () => {
   });
 
   it("should return amount for send tx to vault with invalid memo", async () => {
+    debug(
+      "\nTesting -- should return amount for send tx to vault with invalid memo"
+    );
+
     const signer = await pocket.signerPromise;
     const fromAddress = await pocket.getAddress();
     const toAddress = pocket.VAULT_ADDRESS;
@@ -332,4 +342,217 @@ export const mintFlow = async () => {
 
     debug("InvalidMint success");
   });
+
+  it("should do multiple consecutive mints", async () => {
+    debug("\nTesting -- should do multiple consecutive mints");
+
+    const signer = await pocket.signerPromise;
+    const fromAddress = await pocket.getAddress();
+    const recipientAddress = await ethereum.getAddress();
+    const toAddress = pocket.VAULT_ADDRESS;
+    const amounts = [
+      parseUnits("1", 6),
+      parseUnits("2", 6),
+      parseUnits("3", 6),
+    ];
+    const fee = BigInt(10000);
+    const startNonce = 2;
+
+    const memo: MintMemo = {
+      address: recipientAddress,
+      chain_id: ethereum.CHAIN.id.toString(),
+    };
+
+    const fromBeforeBalance = await pocket.getBalance(fromAddress);
+    const toBeforeBalance = await pocket.getBalance(toAddress);
+
+    debug("Sending transactions...");
+    const sendTxs = await Promise.all(
+      amounts.map(async (amount) =>
+        pocket.sendPOKT(
+          signer,
+          toAddress,
+          amount.toString(),
+          JSON.stringify(memo),
+          fee.toString()
+        )
+      )
+    );
+
+    expect(sendTxs).to.not.be.null;
+    expect(sendTxs.length).to.equal(amounts.length);
+
+    if (!sendTxs) return;
+
+    sendTxs.forEach((sendTx, i) => {
+      expect(sendTx).to.not.be.null;
+
+      if (!sendTx) return;
+      debug(`Transaction ${i} sent: `, sendTx.hash);
+    });
+
+    const fromAfterBalance = await pocket.getBalance(fromAddress);
+    const toAfterBalance = await pocket.getBalance(toAddress);
+
+    const totalAmount = amounts.reduce(
+      (total, amount) => total + amount,
+      BigInt(0)
+    );
+
+    expect(fromAfterBalance).to.equal(
+      fromBeforeBalance - totalAmount - BigInt(amounts.length) * fee
+    );
+    expect(toAfterBalance).to.equal(toBeforeBalance + totalAmount);
+
+    debug(`Waiting for mints to be created...`);
+    await sleep(2000);
+
+    await Promise.all(
+      sendTxs.map(async (sendTx, i) => {
+        if (!sendTx) return;
+
+        const mint = await findMint(sendTx.hash);
+
+        expect(mint).to.not.be.null;
+
+        if (!mint) return;
+        debug(`Mint ${i} created`);
+
+        expect(mint.height.toString()).to.equal(sendTx.height.toString());
+        expect(mint.sender_address.toLowerCase()).to.equal(
+          fromAddress.toLowerCase()
+        );
+        expect(mint.recipient_address.toLowerCase()).to.equal(
+          recipientAddress.toLowerCase()
+        );
+        const amount = amounts[i];
+        expect(mint.amount.toString()).to.equal(amount.toString());
+        expect(mint.status).to.equal(Status.PENDING);
+      })
+    );
+
+    await sleep(12000);
+
+    await Promise.all(
+      sendTxs.map(async (sendTx, i) => {
+        if (!sendTx) return;
+
+        const mint = await findMint(sendTx.hash);
+
+        expect(mint).to.not.be.null;
+
+        if (!mint) return;
+
+        expect(mint.status).to.be.oneOf([Status.CONFIRMED, Status.SIGNED]);
+        debug(`Mint ${i} confirmed`);
+      })
+    );
+
+    await sleep(3000);
+
+    const noncesToSee = sendTxs.map((_, i) => (i + startNonce).toString());
+
+    const sortedMints: Array<Mint | null> = [null, null, null];
+
+    for (let i = 0; i < sendTxs.length; i++) {
+      const sendTx = sendTxs[i];
+
+      if (!sendTx) return;
+
+      const mint = await findMint(sendTx.hash);
+
+      expect(mint).to.not.be.null;
+
+      if (!mint) return;
+
+      expect(mint.status).to.equal(Status.SIGNED);
+      debug(`Mint ${i} signed`);
+
+      expect(mint.signers.length).to.equal(3);
+      expect(mint.signatures.length).to.equal(3);
+      const nonce = mint.nonce.toString();
+      expect(noncesToSee).to.include(nonce);
+      noncesToSee.splice(noncesToSee.indexOf(nonce), 1);
+
+      const sortedIndex = parseInt(nonce) - startNonce;
+      sortedMints[sortedIndex] = mint;
+    }
+
+    const mintTxs: Array<TransactionReceipt> = [];
+
+    for (let i = 0; i < sortedMints.length; i++) {
+      const mint = sortedMints[i];
+      expect(mint).to.not.be.null;
+
+      if (!mint) return;
+
+      expect(mint.data).to.not.be.null;
+
+      if (!mint.data) return;
+
+      const beforeWPOKTBalance = await ethereum.getWPOKTBalance(
+        recipientAddress
+      );
+
+      debug(`Minting ${i} WPOKT...`);
+      const mintTx = await ethereum.mintWPOKT(
+        await ethereum.walletPromise,
+        mint.data,
+        mint.signatures
+      );
+
+      expect(mintTx).to.not.be.null;
+
+      if (!mintTx) return;
+      debug(`WPOKT ${i} minted: `, mintTx.transactionHash);
+
+      expect(mintTx.transactionHash).to.be.a("string");
+
+      mintTxs.push(mintTx);
+
+      const mintedEvent = ethereum.findMintedEvent(mintTx);
+
+      expect(mintedEvent).to.not.be.null;
+
+      if (!mintedEvent) return;
+
+      expect(mintedEvent.nonce.toString()).to.equal(mint.nonce.toString());
+      expect(mintedEvent.recipient.toLowerCase()).to.equal(
+        recipientAddress.toLowerCase()
+      );
+      expect(mintedEvent.amount.toString()).to.equal(mint.amount.toString());
+
+      const afterWPOKTBalance = await ethereum.getWPOKTBalance(
+        recipientAddress
+      );
+
+      expect(afterWPOKTBalance).to.equal(
+        beforeWPOKTBalance + BigInt(mint.amount)
+      );
+    }
+
+    await sleep(2000);
+
+    await Promise.all(
+      sortedMints.map(async (oldMint, i) => {
+        expect(oldMint).to.not.be.null;
+        if (!oldMint) return;
+
+        const mint = await findMint(oldMint.transaction_hash);
+
+        expect(mint).to.not.be.null;
+
+        if (!mint) return;
+
+        expect(mint.status).to.equal(Status.SUCCESS);
+
+        const mintTx = mintTxs[i];
+
+        expect(mint.mint_tx_hash.toLowerCase()).to.equal(
+          mintTx.transactionHash.toLowerCase()
+        );
+        debug(`Mint ${i} success`);
+      })
+    );
+  });
 };

e2e/tester/package.json

@@ -5,8 +5,8 @@
   "author": "dan13ram",
   "license": "MIT",
   "scripts": {
-    "test": "mocha --exit -t 30000 -r ts-node/register index.ts",
-    "debug": "DEBUG=true yarn test"
+    "test": "mocha --exit -t 60000 -r ts-node/register index.ts",
+    "debug-test": "DEBUG=true yarn test"
   },
   "dependencies": {
     "@pokt-foundation/pocketjs-provider": "^2.1.3",

e2e/tester/util/ethereum.ts

@@ -101,7 +101,7 @@ const walletPromise: Promise<WalletClient<Transport, Chain, Account>> =
     await sendETH(
       defaultWalletClient,
       walletClient.account.address,
-      parseUnits("1000", 18)
+      parseUnits("10", 18)
     );
 
     return walletClient;

e2e/tester/util/pocket.ts

@@ -85,7 +85,7 @@ const signerPromise = (async (): Promise<AbstractSigner> => {
   await sendPOKT(
     defaultSigner,
     newSigner.getAddress(),
-    parseUnits("1000", 6).toString(),
+    parseUnits("100", 6).toString(),
     "init"
   );
   return newSigner;