feat: add rpc test to match logIndex

contracts/test/TestRpcCompatibility.sol

@@ -7,6 +7,15 @@ contract TestRpcCompatibility {
 
     event ValueUpdated(uint256 indexed value);
     event ValueUpdatedForSubscribe(uint256 indexed value);
+    event ContractCallWithToken(
+        address indexed sender,
+        string destinationChain,
+        string destinationContractAddress,
+        bytes32 indexed payloadHash,
+        bytes payload,
+        string symbol,
+        uint256 amount
+    );
 
     function getValue() public view returns (uint256) {
         return value;
@@ -21,4 +30,15 @@ contract TestRpcCompatibility {
         subscribeValue = newValue;
         emit ValueUpdatedForSubscribe(newValue);
     }
+
+    function emitCallContractWithToken(
+        string calldata destinationChain,
+        string calldata destinationContractAddress,
+        bytes32 payloadHash,
+        bytes calldata payload,
+        string calldata symbol,
+        uint256 amount
+    ) external {
+        emit ContractCallWithToken(msg.sender, destinationChain, destinationContractAddress, payloadHash, payload, symbol, amount);
+    }
 }

test/RpcCompatibility.js

@@ -3,7 +3,7 @@
 const chai = require('chai');
 const { ethers, network } = require('hardhat');
 const {
-    utils: { hexValue, getAddress, keccak256 },
+    utils: { hexValue, getAddress, keccak256, id },
     Wallet,
     BigNumber,
 } = ethers;
@@ -384,6 +384,40 @@ describe('RpcCompatibility', () => {
         });
     });
 
+    it('should match the fetched logIndex value', async function () {
+        const destinationChain = 'Ethereum';
+        const destinationContractAddress = '0x0000000000000000000000000000000000000001';
+        const payload = '0x01';
+        const payloadHash = keccak256(payload);
+        const symbol = 'TOKEN';
+        const amount = 100;
+
+        const receipt = await rpcCompatibilityContract
+            .emitCallContractWithToken(destinationChain, destinationContractAddress, payloadHash, payload, symbol, amount)
+            .then((tx) => tx.wait());
+        const logsFromReceipt = receipt.logs;
+
+        const eventSignature = id('ContractCallWithToken(address,string,string,bytes32,bytes,string,uint256)');
+        const expectedEvent = logsFromReceipt.find((log) => log.topics[0] === eventSignature);
+        expect(expectedEvent, 'ContractCallWithToken event not found in logs from tx receipt').to.exist.and.to.not.be.null;
+
+        const blockNumber = '0x' + parseInt(receipt.blockNumber).toString(16);
+        const logsFromGetLogs = await provider.send('eth_getLogs', [
+            {
+                fromBlock: blockNumber,
+                toBlock: blockNumber,
+            },
+        ]);
+
+        const matchingEvent = logsFromGetLogs.find((log) => log.topics[0] === eventSignature);
+        expect(matchingEvent, 'ContractCallWithToken event not found in logs from eth_getLogs').to.not.be.null;
+
+        expect(parseInt(expectedEvent.logIndex)).to.equal(
+            parseInt(matchingEvent.logIndex),
+            'Log index mismatch between tx receipt and eth_getLogs',
+        );
+    });
+
     describe('eip-1559 supported rpc methods', () => {
         if (!isHardhat) {
             it('should support RPC method eth_maxPriorityFeePerGas', async () => {