Chain A (Ethereum):
  1. User calls bridge.deposit(100 USDC)
  2. USDC is locked in the bridge contract
  3. Bridge emits DepositInitiated event
     ↓
Relayer (Off-chain):
  4. Listens for DepositInitiated event
  5. Verifies the transaction (checks Merkle proof, signatures, etc.)
  6. Constructs a message for Chain B
     ↓
Chain B (Polygon):
  7. Relayer calls bridge.mint(100 USDC)
  8. Bridge verifies the relayer's proof
  9. Mints 100 wrapped USDC to user
  10. Bridge emits DepositFinalized event

Chain B (Polygon):
  1. User calls bridge.withdraw(100 USDC)
  2. Wrapped USDC is burned
  3. Bridge emits WithdrawalInitiated event
     ↓
Relayer:
  4. Listens for WithdrawalInitiated event
  5. Constructs proof for Chain A
     ↓
Chain A (Ethereum):
  6. Relayer calls bridge.unlock(100 USDC)
  7. Bridge verifies proof
  8. Unlocks 100 USDC to user
  9. Bridge emits WithdrawalFinalized event

describe('Cross-Chain Bridge: End-to-End Tests', () => {
  let chainA, chainB;
  let bridgeA, bridgeB;
  let relayer;
  let user;

  before(async () => {
    // 1. Setup Chain A (e.g., Ethereum fork)
    chainA = await setupChainA();
    bridgeA = await deployBridgeOnChainA(chainA);

    // 2. Setup Chain B (e.g., Polygon fork)
    chainB = await setupChainB();
    bridgeB = await deployBridgeOnChainB(chainB);

    // 3. Deploy and configure the relayer
    relayer = await setupRelayer(bridgeA, bridgeB);

    user = await ethers.getSigner();
  });

  it('should bridge tokens from Chain A to Chain B', async () => {
    const depositAmount = ethers.utils.parseEther('100');

    // STEP 1: Deposit on Chain A
    await tokenA.connect(user).approve(bridgeA.address, depositAmount);
    
    const depositTx = await bridgeA.connect(user).deposit(
      tokenA.address,
      depositAmount,
      user.address // recipient on Chain B
    );

    const receipt = await depositTx.wait();
    console.log('Deposit initiated on Chain A');

    // STEP 2: Extract the bridge message from the event
    const depositEvent = receipt.events.find(e => e.event === 'DepositInitiated');
    const messageId = depositEvent.args.messageId;

    // STEP 3: Wait for the relayer to process the message
    // This is asynchronous and may take 30 seconds to 5 minutes
    console.log('Waiting for relayer to relay message...');
    
    await waitForRelayerToProcess(messageId, { timeout: 300000 }); // 5 min timeout

    // STEP 4: Poll Chain B to verify tokens were minted
    const maxAttempts = 60;
    let tokensMinted = false;

    for (let i = 0; i < maxAttempts; i++) {
      const balanceOnChainB = await tokenB.balanceOf(user.address);
      
      if (balanceOnChainB.gte(depositAmount)) {
        tokensMinted = true;
        console.log(`✅ Tokens minted on Chain B: ${ethers.utils.formatEther(balanceOnChainB)}`);
        break;
      }

      await sleep(5000); // Wait 5 seconds before checking again
    }

    expect(tokensMinted).to.be.true;

    // STEP 5: Verify the bridge's internal state
    const bridgeBState = await bridgeB.deposits(messageId);
    expect(bridgeBState.processed).to.be.true;
    expect(bridgeBState.amount).to.equal(depositAmount);
  });
});

describe('Replay Attack Prevention', () => {
  it('should reject duplicate message submissions', async () => {
    // STEP 1: Submit a valid message
    const messageId = await submitBridgeMessage(chainA, bridgeA, {
      amount: 100,
      recipient: user.address
    });

    // STEP 2: Wait for message to be processed on Chain B
    await waitForMessageProcessing(messageId);

    // STEP 3: Try to replay the same message
    await expect(
      bridgeB.processMessage(messageId, /* same proof */)
    ).to.be.revertedWith('Message already processed');

    console.log('✅ Replay attack blocked');
  });

  it('should use nonces to prevent replay attacks', async () => {
    // Verify that each message has a unique, incrementing nonce
    const message1 = await bridgeA.getNextMessage();
    expect(message1.nonce).to.equal(1);

    await bridgeA.deposit(/* ... */);

    const message2 = await bridgeA.getNextMessage();
    expect(message2.nonce).to.equal(2);

    // Nonces should never repeat
    expect(message2.nonce).to.not.equal(message1.nonce);
  });

  it('should track processed messages in a mapping', async () => {
    const messageId = generateMessageId();

    // Before processing
    expect(await bridgeB.processedMessages(messageId)).to.be.false;

    // Process the message
    await bridgeB.processMessage(messageId, /* ... */);

    // After processing
    expect(await bridgeB.processedMessages(messageId)).to.be.true;

    // Second attempt should fail
    await expect(
      bridgeB.processMessage(messageId, /* ... */)
    ).to.be.revertedWith('Already processed');
  });
});

describe('Data Integrity Verification', () => {
  it('should reject messages with manipulated amounts', async () => {
    // STEP 1: Lock 100 tokens on Chain A
    const actualAmount = ethers.utils.parseEther('100');
    await bridgeA.deposit(tokenA.address, actualAmount, user.address);

    // STEP 2: Attacker tries to relay a message claiming 1000 tokens
    const fakeAmount = ethers.utils.parseEther('1000');
    const fakeMessage = {
      token: tokenA.address,
      amount: fakeAmount, // Manipulated!
      recipient: user.address
    };

    // STEP 3: Bridge should reject the fake message
    await expect(
      bridgeB.processMessage(fakeMessage, /* invalid proof */)
    ).to.be.revertedWith('Invalid proof');

    console.log('✅ Amount manipulation blocked');
  });

  it('should verify Merkle proofs for data integrity', async () => {
    // This test verifies that the bridge uses Merkle proofs to ensure
    // that the data on Chain B matches the data committed on Chain A

    const depositAmount = ethers.utils.parseEther('100');

    // Deposit on Chain A
    const tx = await bridgeA.deposit(tokenA.address, depositAmount, user.address);
    const receipt = await tx.wait();

    // Extract the Merkle root from Chain A
    const merkleRoot = await bridgeA.getMerkleRoot();

    // Generate a Merkle proof for this deposit
    const proof = generateMerkleProof(receipt, merkleRoot);

    // Verify the proof on Chain B
    const isValid = await bridgeB.verifyProof(
      proof,
      merkleRoot,
      depositAmount,
      user.address
    );

    expect(isValid).to.be.true;

    // Now try with a manipulated amount
    const fakeAmount = ethers.utils.parseEther('1000');
    const isValidFake = await bridgeB.verifyProof(
      proof,
      merkleRoot,
      fakeAmount, // Wrong amount
      user.address
    );

    expect(isValidFake).to.be.false;
    console.log('✅ Merkle proof verification working correctly');
  });

  it('should use hash commitments for data integrity', async () => {
    // Some bridges commit a hash of the data on Chain A
    // and verify it matches on Chain B

    const data = {
      token: tokenA.address,
      amount: ethers.utils.parseEther('100'),
      recipient: user.address,
      nonce: 1
    };

    // Compute hash on Chain A
    const commitmentA = await bridgeA.computeMessageHash(data);

    // Submit the message to Chain B with the hash
    await bridgeB.processMessage(data, commitmentA);

    // Bridge B should recompute the hash and verify it matches
    const commitmentB = await bridgeB.computeMessageHash(data);
    expect(commitmentB).to.equal(commitmentA);

    // If data is tampered with, hashes won't match
    const tamperedData = { ...data, amount: ethers.utils.parseEther('1000') };
    const tamperedCommitment = await bridgeB.computeMessageHash(tamperedData);
    expect(tamperedCommitment).to.not.equal(commitmentA);
  });
});

describe('Access Control & Key Management', () => {
  it('should require multisig approval for critical operations', async () => {
    // STEP 1: Verify that upgrading the bridge requires multiple signatures
    const newImplementation = await deployNewBridgeImplementation();

    // Try to upgrade with a single signer (should fail)
    await expect(
      bridgeA.connect(admin1).upgradeTo(newImplementation.address)
    ).to.be.revertedWith('Requires multisig approval');

    // STEP 2: Submit upgrade proposal
    await multisig.submitProposal(
      bridgeA.address,
      'upgradeTo',
      [newImplementation.address]
    );

    // STEP 3: Multiple signers must approve
    await multisig.connect(admin1).approve(proposalId);
    await multisig.connect(admin2).approve(proposalId);

    // Still not enough (need 3 of 5)
    await expect(
      multisig.execute(proposalId)
    ).to.be.revertedWith('Insufficient approvals');

    // STEP 4: Third signer approves
    await multisig.connect(admin3).approve(proposalId);

    // Now it succeeds
    await multisig.execute(proposalId);

    const currentImplementation = await bridgeA.implementation();
    expect(currentImplementation).to.equal(newImplementation.address);

    console.log('✅ Multisig upgrade successful');
  });

  it('should prevent single-key control over minting', async () => {
    // No single address should be able to mint tokens on the destination chain

    await expect(
      bridgeB.connect(attacker).mint(user.address, ethers.utils.parseEther('1000000'))
    ).to.be.revertedWith('Unauthorized');

    // Only the bridge itself (with proper message verification) should be able to mint
  });

  it('should have proper role separation', async () => {
    // Different roles should have different permissions

    // Check admin role
    expect(await bridgeA.hasRole(ADMIN_ROLE, admin.address)).to.be.true;

    // Check relayer role
    expect(await bridgeA.hasRole(RELAYER_ROLE, relayer.address)).to.be.true;

    // Relayer should NOT have admin permissions
    await expect(
      bridgeA.connect(relayer).pause()
    ).to.be.revertedWith('Requires ADMIN_ROLE');

    // Admin should NOT be able to relay messages
    await expect(
      bridgeB.connect(admin).processMessage(/* ... */)
    ).to.be.revertedWith('Requires RELAYER_ROLE');

    console.log('✅ Role separation enforced');
  });

  it('should audit the multisig configuration', async () => {
    // This is a manual checklist, but you can automate some checks

    // 1. How many signers are required?
    const requiredSigners = await multisig.required();
    const totalSigners = await multisig.getOwners();

    console.log(`Multisig: ${requiredSigners} of ${totalSigners.length} required`);

    // Best practices:
    // - At least 3 of 5 (60% threshold)
    // - Signers should be separate entities (not one person with 3 wallets)
    // - Geographic distribution (not all in one jurisdiction)

    expect(requiredSigners).to.be.gte(3);
    expect(totalSigners.length).to.be.gte(5);

    // 2. Are signers stored securely?
    // This requires off-chain verification:
    // - Hardware wallets (Ledger, Trezor)?
    // - Multisig services (Gnosis Safe)?
    // - Air-gapped machines?

    console.log('Signers:', totalSigners);
    // Flag for manual review
  });

  it('should test emergency pause functionality', async () => {
    // Critical: Can the bridge be paused in an emergency?

    // Normal operation works
    await bridgeA.deposit(tokenA.address, 100, user.address);

    // Admin pauses the bridge
    await bridgeA.connect(admin).pause();

    // New deposits should be blocked
    await expect(
      bridgeA.deposit(tokenA.address, 100, user.address)
    ).to.be.revertedWith('Pausable: paused');

    // Unpause
    await bridgeA.connect(admin).unpause();

    // Deposits work again
    await bridgeA.deposit(tokenA.address, 100, user.address);

    console.log('✅ Emergency pause works correctly');
  });
});

describe('Economic Security', () => {
  it('should enforce collateral requirements', async () => {
    // Verify that validators must stake sufficient collateral

    const totalValueLocked = await bridgeA.getTotalValueLocked();
    const totalCollateral = await validatorSet.getTotalCollateral();

    // Collateral should be at least 1.5x the value locked (150% collateralization)
    expect(totalCollateral).to.be.gte(totalValueLocked.mul(15).div(10));

    console.log(`TVL: $${ethers.utils.formatEther(totalValueLocked)}`);
    console.log(`Collateral: $${ethers.utils.formatEther(totalCollateral)}`);
  });

  it('should slash validators for fraudulent messages', async () => {
    const validator = validators[0];
    const initialStake = await validatorSet.getStake(validator.address);

    // Validator submits a fraudulent message
    const fraudulentMessage = {
      amount: ethers.utils.parseEther('1000000'), // Fake amount
      proof: '0x' + '00'.repeat(32) // Invalid proof
    };

    // Fraud proof is submitted by a watcher
    await validatorSet.submitFraudProof(validator.address, fraudulentMessage);

    // Validator's stake should be slashed
    const finalStake = await validatorSet.getStake(validator.address);
    expect(finalStake).to.be.lt(initialStake);

    console.log(`Validator slashed: ${ethers.utils.formatEther(initialStake.sub(finalStake))} ETH`);
  });
});

describe('LayerZero Bridge', () => {
  it('should send a cross-chain message', async () => {
    // Send a message from Chain A to Chain B
    const message = ethers.utils.defaultAbiCoder.encode(
      ['address', 'uint256'],
      [user.address, ethers.utils.parseEther('100')]
    );

    const tx = await layerZeroA.send(
      chainBId, // Destination chain ID
      bridgeB.address, // Destination contract
      message, // Payload
      user.address, // Refund address
      ethers.constants.AddressZero, // zro payment address
      '0x', // Adapter params
      { value: ethers.utils.parseEther('0.01') } // Fees
    );

    await tx.wait();

    // Wait for message to be delivered
    await waitForLayerZeroMessage(chainBId, message);

    // Verify message was received
    const received = await bridgeB.receivedMessages(message);
    expect(received).to.be.true;
  });

  it('should configure trusted remote addresses', async () => {
    // LayerZero requires setting "trusted remotes" to prevent spoofing

    // Set Chain A's bridge as trusted on Chain B
    await bridgeB.setTrustedRemote(
      chainAId,
      ethers.utils.solidityPack(['address', 'address'], [bridgeA.address, bridgeB.address])
    );

    // Verify it's set
    const trustedRemote = await bridgeB.trustedRemoteLookup(chainAId);
    expect(trustedRemote).to.not.equal('0x');

    console.log('✅ Trusted remote configured');
  });
});

describe('Chainlink CCIP Bridge', () => {
  it('should send tokens via CCIP', async () => {
    const amount = ethers.utils.parseEther('100');

    // Approve CCIP router
    await tokenA.approve(ccipRouter.address, amount);

    // Build CCIP message
    const message = {
      receiver: ethers.utils.defaultAbiCoder.encode(['address'], [user.address]),
      data: '0x', // Additional data
      tokenAmounts: [{ token: tokenA.address, amount: amount }],
      feeToken: ethers.constants.AddressZero, // Pay in native token
      extraArgs: '0x'
    };

    // Send via CCIP
    const tx = await ccipRouter.ccipSend(
      chainBSelector, // Destination chain selector
      message,
      { value: ethers.utils.parseEther('0.1') } // Estimated fees
    );

    const receipt = await tx.wait();

    // Extract message ID
    const messageId = receipt.events.find(e => e.event === 'CCIPSendRequested').args.messageId;

    // Wait for CCIP to deliver the message
    await waitForCCIPMessage(messageId);

    // Verify tokens arrived on Chain B
    const balanceB = await tokenB.balanceOf(user.address);
    expect(balanceB).to.equal(amount);

    console.log('✅ CCIP message delivered successfully');
  });

  it('should respect rate limits', async () => {
    // CCIP has built-in rate limiting to prevent draining attacks

    const rateLimit = await ccipRouter.getRateLimiterState(tokenA.address);
    console.log(`Rate limit: ${ethers.utils.formatEther(rateLimit.capacity)} tokens per ${rateLimit.refillRate} seconds`);

    // Try to send more than the rate limit
    const excessAmount = rateLimit.capacity.add(1);

    await expect(
      ccipRouter.ccipSend(chainBSelector, {
        /* ... */
        tokenAmounts: [{ token: tokenA.address, amount: excessAmount }]
      })
    ).to.be.revertedWith('Rate limit exceeded');

    console.log('✅ Rate limit enforced');
  });
});

// VULNERABLE CODE
function process(bytes memory _message, bytes32[32] memory _proof) external {
    bytes32 messageHash = keccak256(_message);
    
    // BUG: This check was supposed to verify the Merkle proof
    // but it was initialized to 0x00...00, which is the default value
    // for uninitialized messages!
    require(messages[messageHash] != bytes32(0), "Message not proven");
    
    // Process the message
    _processMessage(_message);
}

describe('Nomad Bridge Vulnerability', () => {
  it('should reject messages with invalid proofs', async () => {
    // This test would have caught the bug

    const fakeMessage = ethers.utils.defaultAbiCoder.encode(
      ['address', 'uint256'],
      [attacker.address, ethers.utils.parseEther('1000000')]
    );

    // No deposit was ever made on the source chain
    // This message should be rejected

    await expect(
      bridge.process(fakeMessage, Array(32).fill(ethers.constants.HashZero))
    ).to.be.revertedWith('Invalid proof');

    // But in the vulnerable version, this passed!
  });

  it('should require valid Merkle proofs', async () => {
    // Generate a valid message on Chain A
    const validMessage = await bridgeA.createMessage(/* ... */);
    const merkleRoot = await bridgeA.getMerkleRoot();
    const proof = generateMerkleProof(validMessage, merkleRoot);

    // This should succeed
    await bridgeB.process(validMessage, proof);

    // Now try with an invalid proof
    const invalidProof = Array(32).fill(ethers.constants.HashZero);

    await expect(
      bridgeB.process(validMessage, invalidProof)
    ).to.be.reverted;

    console.log('✅ Merkle proof validation works');
  });
});