more tests

Author: bogdan-rosianu

config/config.e2e.mainnet.yaml

@@ -24,7 +24,7 @@ features:
     enabled: false
     port: 6002
   stateChanges:
-    enabled: false
+    enabled: true
     port: 5675
     url: 'amqp://guest:guest@127.0.0.1:5672'
     exchange: 'state_accesses'

src/test/chain-simulator/state-changes/balances.state-changes-e2e.ts

@@ -60,14 +60,24 @@ describe('State changes: balances parity (v1 vs v2)', () => {
   const bob = config.bobAddress;
 
   it('Alice balance matches between v1 and v2', async () => {
-    const v1 = await fetchBalance(base, alice);
-    const v2 = await fetchBalanceV2(base, alice);
+    let v1 = await fetchBalance(base, alice);
+    let v2 = await fetchBalanceV2(base, alice);
+    for (let i = 0; i < 20 && v1 !== v2; i++) {
+      await sleep(1000);
+      v1 = await fetchBalance(base, alice);
+      v2 = await fetchBalanceV2(base, alice);
+    }
     expect(v1).toBe(v2);
   });
 
   it('Bob balance matches between v1 and v2', async () => {
-    const v1 = await fetchBalance(base, bob);
-    const v2 = await fetchBalanceV2(base, bob);
+    let v1 = await fetchBalance(base, bob);
+    let v2 = await fetchBalanceV2(base, bob);
+    for (let i = 0; i < 20 && v1 !== v2; i++) {
+      await sleep(1000);
+      v1 = await fetchBalance(base, bob);
+      v2 = await fetchBalanceV2(base, bob);
+    }
     expect(v1).toBe(v2);
   });
 });

src/test/chain-simulator/state-changes/contract.state-changes-e2e.ts

@@ -0,0 +1,84 @@
+import axios from 'axios';
+import { config } from '../config/env.config';
+import { ChainSimulatorUtils } from '../utils/test.utils';
+
+const sleep = (ms: number) => new Promise((res) => setTimeout(res, ms));
+
+async function fetchAccount(baseUrl: string, address: string): Promise<any> {
+  for (let i = 0; i < 45; i++) {
+    const resp = await axios.get(`${baseUrl}/accounts/${address}`).catch(() => undefined);
+    const acc = resp?.data;
+    if (acc) return acc;
+    await sleep(1000);
+  }
+  throw new Error(`Could not fetch account ${address}`);
+}
+
+async function fetchNonce(baseUrl: string, address: string): Promise<number> {
+  for (let i = 0; i < 45; i++) {
+    const resp = await axios.get(`${baseUrl}/proxy/address/${address}/nonce`).catch(() => undefined);
+    const n = resp?.data?.data?.nonce;
+    if (typeof n === 'number') return n;
+    await sleep(1000);
+  }
+  throw new Error(`Could not fetch nonce for ${address}`);
+}
+
+async function fetchMetaNonce(baseUrl: string): Promise<number> {
+  for (let i = 0; i < 45; i++) {
+    const resp = await axios.get(`${baseUrl}/proxy/network/status/4294967295`).catch(() => undefined);
+    const n = resp?.data?.data?.status?.erd_nonce;
+    if (typeof n === 'number') return n;
+    await sleep(1000);
+  }
+  throw new Error('Could not fetch meta-chain nonce');
+}
+
+describe('State changes: smart contract deploy visibility', () => {
+  const sim = config.chainSimulatorUrl;
+  const api = config.apiServiceUrl;
+  const deployer = config.aliceAddress;
+
+  it('Deploys ping-pong contract and exposes codeHash/rootHash; meta nonce increases', async () => {
+    const startMeta = await fetchMetaNonce(api);
+    const startNonce = await fetchNonce(api, deployer);
+
+    const scAddress = await ChainSimulatorUtils.deployPingPongSc(deployer);
+
+    // Wait until /accounts reflects deployment
+    let account: any = null;
+    for (let i = 0; i < 45; i++) {
+      account = await fetchAccount(api, scAddress).catch(() => undefined);
+      const codeHash = account?.codeHash ?? account?.data?.codeHash;
+      const rootHash = account?.rootHash ?? account?.data?.rootHash;
+      if (codeHash && codeHash !== '' && rootHash && rootHash !== '') break;
+      await sleep(1000);
+    }
+
+    const codeHash = account?.codeHash ?? account?.data?.codeHash;
+    const rootHash = account?.rootHash ?? account?.data?.rootHash;
+    expect(typeof codeHash).toBe('string');
+    expect(codeHash.length).toBeGreaterThan(0);
+    expect(typeof rootHash).toBe('string');
+    expect(rootHash.length).toBeGreaterThan(0);
+
+    // Nonce of deployer should increase
+    let endNonce = startNonce;
+    for (let i = 0; i < 30; i++) {
+      endNonce = await fetchNonce(api, deployer);
+      if (endNonce >= startNonce + 1) break;
+      await sleep(1000);
+    }
+    expect(endNonce).toBeGreaterThanOrEqual(startNonce + 1);
+
+    // Meta-chain nonce should advance as well
+    let endMeta = startMeta;
+    for (let i = 0; i < 30; i++) {
+      endMeta = await fetchMetaNonce(api);
+      if (endMeta > startMeta) break;
+      await sleep(1000);
+    }
+    expect(endMeta).toBeGreaterThan(startMeta);
+  });
+});
+

src/test/chain-simulator/state-changes/transfers.state-changes-e2e.ts

@@ -45,6 +45,17 @@ async function fetchApiBalance(baseUrl: string, address: string): Promise<bigint
   return BigInt(bal);
 }
 
+async function waitForBalance(baseUrl: string, address: string, expected: bigint, timeoutMs = 60000): Promise<bigint> {
+  const start = Date.now();
+  let last: bigint = BigInt(0);
+  while (Date.now() - start < timeoutMs) {
+    last = await fetchApiBalance(baseUrl, address);
+    if (last === expected) return last;
+    await sleep(1000);
+  }
+  return last;
+}
+
 async function fetchTxFeeFromSimulator(simUrl: string, txHash: string): Promise<bigint> {
   // Prefer explicit fee, fallback to gasUsed * gasPrice if needed
   for (let i = 0; i < 30; i++) {
@@ -89,11 +100,13 @@ describe('State changes: native EGLD transfers reflect in balances', () => {
 
     const fee = await fetchTxFeeFromSimulator(sim, txHash);
 
-    const afterAlice = await fetchApiBalance(api, alice);
-    const afterBob = await fetchApiBalance(api, bob);
+    const expectedAlice = beforeAlice - amount - fee;
+    const expectedBob = beforeBob + amount;
+    const afterAlice = await waitForBalance(api, alice, expectedAlice);
+    const afterBob = await waitForBalance(api, bob, expectedBob);
 
-    expect(afterAlice).toBe(beforeAlice - amount - fee);
-    expect(afterBob).toBe(beforeBob + amount);
+    expect(afterAlice).toBe(expectedAlice);
+    expect(afterBob).toBe(expectedBob);
   });
 
   it('Round-trip transfers: Alice->Bob then Bob->Alice yields expected finals', async () => {
@@ -123,13 +136,13 @@ describe('State changes: native EGLD transfers reflect in balances', () => {
     }));
     const fee2 = await fetchTxFeeFromSimulator(sim, hash2);
 
-    const endAlice = await fetchApiBalance(api, alice);
-    const endBob = await fetchApiBalance(api, bob);
+    const expectedAlice = startAlice - amount1 - fee1 + amount2;
+    const expectedBob = startBob + amount1 - fee2 - amount2;
+    const endAlice = await waitForBalance(api, alice, expectedAlice);
+    const endBob = await waitForBalance(api, bob, expectedBob);
 
-    // Alice: -amount1 - fee1 + amount2
-    expect(endAlice).toBe(startAlice - amount1 - fee1 + amount2);
-    // Bob:   +amount1 - fee2 - amount2
-    expect(endBob).toBe(startBob + amount1 - fee2 - amount2);
+    expect(endAlice).toBe(expectedAlice);
+    expect(endBob).toBe(expectedBob);
   });
 
   it('Multiple sequential transfers accumulate correctly (Alice->Bob x3)', async () => {
@@ -160,11 +173,39 @@ describe('State changes: native EGLD transfers reflect in balances', () => {
       totalFees += fee;
     }
 
-    const endAlice = await fetchApiBalance(api, alice);
-    const endBob = await fetchApiBalance(api, bob);
+    const expectedAlice = startAlice - totalSent - totalFees;
+    const expectedBob = startBob + totalSent;
+    const endAlice = await waitForBalance(api, alice, expectedAlice);
+    const endBob = await waitForBalance(api, bob, expectedBob);
 
-    expect(endAlice).toBe(startAlice - totalSent - totalFees);
-    expect(endBob).toBe(startBob + totalSent);
+    expect(endAlice).toBe(expectedAlice);
+    expect(endBob).toBe(expectedBob);
   });
-});
 
+  it('Sender nonce increases after successful transfers', async () => {
+    await fundAddress(sim, alice);
+    const nonceResp = await axios.get(`${api}/proxy/address/${alice}/nonce`);
+    const startNonce: number = nonceResp?.data?.data?.nonce ?? 0;
+
+    const amount = BigInt('1000000000000000'); // 0.001 EGLD
+    const hash = await sendTransaction(new SendTransactionArgs({
+      chainSimulatorUrl: sim,
+      sender: alice,
+      receiver: bob,
+      value: amount.toString(),
+      dataField: '',
+    }));
+    // Ensure simulator included the tx
+    await fetchTxFeeFromSimulator(sim, hash);
+
+    // Nonce should increase by 1
+    let newNonce = startNonce;
+    for (let i = 0; i < 30; i++) {
+      const n = await axios.get(`${api}/proxy/address/${alice}/nonce`).then(r => r?.data?.data?.nonce ?? 0).catch(() => startNonce);
+      if (typeof n === 'number') newNonce = n;
+      if (newNonce >= startNonce + 1) break;
+      await sleep(1000);
+    }
+    expect(newNonce).toBeGreaterThanOrEqual(startNonce + 1);
+  });
+});