npm install @chainlink/contracts
npm install @chainlink/contracts-ccip
npm install @openzeppelin/contracts

import {IRouterClient} from "@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";

import {IRouterClient} from "../../node_modules/@chainlink/contracts-ccip/src/v0.8/ccip/interfaces/IRouterClient.sol";

private static final String LINK_SEPOLIA_ADDRESS = "0x779877A7B0D9E8603169DdbD7836e478b4624789";
private static final String CCIP_ROUTER_SEPOLIA = "0x0bf3de8c5d3e8a2b34d2beeb17abfcebaf363a59";

private static void deploySender() throws Exception {
    Configuration config = new Configuration();
    Web3jService ethereumService = new HttpService(config.getEthereumTestnetUrl());
    Web3j web3jEth = Web3j.build(ethereumService);

    Credentials credentials = Credentials.create(config.getPrivateKey());
    ContractGasProvider gasProvider = new DefaultGasProvider();

    Sender sender = Sender.deploy(web3jEth, credentials, gasProvider, CCIP_ROUTER_SEPOLIA, LINK_SEPOLIA_ADDRESS).send();
    Address senderAddress = new Address(sender.getContractAddress());
    log.info("Deployed Sender at: {}", senderAddress);
}

private static final String CCIP_ROUTER_MUMBAI = "0x1035cabc275068e0f4b745a29cedf38e13af41b1";
private static final int CHAIN_ID_POLYGON_MUMBAI = 80001;

private static void deployReceiver() throws Exception {
    log.debug("Will deploy Receiver contract...");
    Configuration config = new Configuration();
    Web3jService polygonService = new HttpService(config.getPolygonTestnetUrl());
    Web3j web3jMatic = Web3j.build(polygonService);

    Credentials credentials = Credentials.create(config.getPrivateKey());
    TransactionManager txManager = new RawTransactionManager(web3jMatic, credentials, CHAIN_ID_POLYGON_MUMBAI);
    ContractGasProvider gasProvider = new DefaultGasProvider();
    Receiver receiver = Receiver.deploy(web3jMatic, txManager, gasProvider, CCIP_ROUTER_MUMBAI).send();
    Address receiverAddress = new Address(receiver.getContractAddress());
    log.info("Deployed Receiver at: {}", receiverAddress);
}

public static void main(String[] args) throws ConfigurationException, URISyntaxException, IOException {
    Configuration config = new Configuration();
    Web3jService ethereumService = new HttpService(config.getEthereumTestnetUrl());
    Web3j web3jEth = Web3j.build(ethereumService);
    Web3jService polygonService = new HttpService(config.getPolygonTestnetUrl());
    Web3j web3jMatic = Web3j.build(polygonService);
    WebSocketService wsServiceMumbai = new WebSocketService(new WebSocketClient(new URI(config.getPolygonTestnetWsUrl())), false);
    Web3j web3jMaticWs = Web3j.build(wsServiceMumbai);
    wsServiceMumbai.connect();
    try {
        testCCIP(web3jEth, web3jMatic, web3jMaticWs, config);
    } catch (Exception e) {
        log.error(e.getMessage(), e);
    } finally {
        web3jEth.shutdown();
        web3jMatic.shutdown();
        web3jMaticWs.shutdown();
    }
}

private static void testCCIP(Web3j web3jEth, Web3j web3jMatic, Web3j web3jMaticWs, Configuration config) throws Exception {
    Credentials credentials = Credentials.create(config.getPrivateKey());
    ContractGasProvider gasProvider = new DefaultGasProvider();

    ERC20 link = getSepoliaLINK(web3jEth, credentials, gasProvider);

    // Use deployed Sender.
    String senderAddress = "0x7952972249afa780f0d17d40cf603afdf333ffb5";
    Sender sender = Sender.load(senderAddress, web3jEth, credentials, gasProvider);

    // Transfer LINK to Sender.
    BigInteger juels = new BigDecimal("0.1").multiply(BigDecimal.TEN.pow(18)).toBigInteger();
    log.info("Transferring {} juels to Sender contract at {}", juels, senderAddress);
    link.transfer(senderAddress, juels).send();

    // Use deployed Receiver.
    String receiverAddress = "0x85f2af0e58a3ac8c91d37cd7ba9bb005d706caad";
    Receiver receiver = Receiver.load(receiverAddress, web3jMatic, credentials, gasProvider);
    log.info("Loaded Receiver at: {}", receiverAddress);

    // Send data from Sender to Receiver.
    log.info("Sending message through CCIP...");
    TransactionReceipt tx = sender.sendMessage(CHAIN_SELECTOR_POLYGON_MUMBAI, receiverAddress, "Automated message between chains!").send();
    log.info("SendMessage Transaction: {} status: {}", tx.getTransactionHash(), tx.getStatus());
    String txHash = tx.getTransactionHash();
    TransactionReceiptProcessor trp = new PollingTransactionReceiptProcessor(web3jEth, TransactionManager.DEFAULT_POLLING_FREQUENCY, TransactionManager.DEFAULT_POLLING_ATTEMPTS_PER_TX_HASH);
    tx = trp.waitForTransactionReceipt(txHash);
    log.debug("Transaction {} mined on source chain at block {} (status {})", tx.getTransactionHash(), tx.getBlockNumber(), tx.getStatus());
        
    // Get last block of destination chain to start filter from.
    EthBlockNumber block = web3jMatic.ethBlockNumber().send();
    BigInteger from = block.getBlockNumber();
    log.debug("Filtering destination chain blocks from {} to latest", from);

    // Filters require WS connection (cannot use direct HTTP).
    EthFilter filter = new EthFilter(
        new DefaultBlockParameterNumber(from),
        DefaultBlockParameterName.LATEST,
        receiverAddress
    );
    Receiver receiverWs = Receiver.load(receiverAddress, web3jMaticWs, credentials, gasProvider);

    // Wait for our message to arrive at the destination chain.
    CountDownLatch latch = new CountDownLatch(1); // waiting for 1 message.
    Disposable disp = receiverWs.messageReceivedEventFlowable(filter)
        .onErrorResumeNext(s -> {log.error("Error while waiting for message: {}", s);})
        .subscribe(event -> {
            String msgId = Hex.encodeHexString(event.messageId);
            log.debug("New event of type 'MessageReceived' - event id {} from {}: {} (source chain {})",
                msgId,
                event.sender,
                event.text,
                event.sourceChainSelector);
            if (event.sender.equals(senderAddress) && event.sourceChainSelector.equals(CHAIN_SELECTOR_ETHEREUM_SEPOLIA)) {
                log.info("RECEIVED MESSAGE THROUGH CCIP! from {}: '{}'", event.sender, event.text);
                latch.countDown();
            }
        });
    log.info("Waiting for the message to arrive at the destination chain...");
    latch.await();
    disp.dispose();

    // Call the receiver to get its last received message.
    Tuple2<byte[], String> msg = receiver.getLastReceivedMessageDetails().send();
    String msgId = Hex.encodeHexString(msg.component1());
    log.info("[Receiver] last received message id 0x{}, content: '{}'", msgId, msg.component2());
}