contracts/minimal_receiver.tolk

fun onInternalMessage(in: InMessage) {
    val msg = lazy MinimalReceiver_InMessage.fromSlice(in.body);
    match (msg) {
        Receiver_CCIPReceive => {
            val st = lazy Storage.load();

            // 1. Accept messages only from the authorized CCIP Router.
            assert(in.senderAddress == st.router) throw ERROR_UNAUTHORIZED;

            // 2. Verify enough value is attached to cover gas costs.
            //    Router needs ≥0.02 TON for CCIPReceiveConfirm; increase for your own costs.
            assert(in.valueCoins >= MIN_VALUE) throw ERROR_LOW_VALUE;

            // 3. Send CCIPReceiveConfirm back to the Router.
            val receiveConfirm = createMessage({
                bounce: true,
                value: 0,
                dest: in.senderAddress,
                body: Router_CCIPReceiveConfirm { execId: msg.execId },
            });
            receiveConfirm.send(SEND_MODE_CARRY_ALL_REMAINING_MESSAGE_VALUE);

            // ★ YOUR LOGIC: call your application function(s) with msg.message
            processMessage(msg.message);
        }
        else => {
            // Ignore plain TON transfers; reject unknown opcodes.
            assert(in.body.isEmpty()) throw 0xFFFF;
        }
    }
}

Terminal

npm run deploy:ton:receiver:minimal

contracts/receiver_with_validateAndConfirm.tolk

Receiver_CCIPReceive => {
    val st = lazy Storage.load();

    // Performs all three mandatory protocol steps in one call:
    //   1. Verifies sender == st.router
    //   2. Verifies valueCoins >= MIN_VALUE
    //   3. Sends CCIPReceiveConfirm with SEND_MODE_CARRY_ALL_REMAINING_MESSAGE_VALUE
    msg.validateAndConfirm({
        router: st.router,
        minValue: MIN_VALUE,
        inMsg: {
            senderAddress: in.senderAddress,
            valueCoins: in.valueCoins,
        },
        confirmationMsg: {
            sendMode: SEND_MODE_CARRY_ALL_REMAINING_MESSAGE_VALUE,
        },
    });

    // ★ YOUR LOGIC: call your application function(s) with msg.message
    processMessage(msg.message);
}

Terminal

npm run deploy:ton:receiver:validate-and-confirm

chainlink-ton/contracts/contracts/ccip/test/receiver/storage.tolk

struct Storage {
    id: uint32;
    ownable: Ownable2Step;     // Two-step ownership — admin messages require requireOwner()
    authorizedCaller: address; // Must be the CCIP Router address for production use
    behavior: TestReceiverBehavior;
}

enum TestReceiverBehavior : uint8 {
    Accept = 0,    // Normal — emit event for each received message
    RejectAll,     // Always throw (simulates a failing receiver)
    ConsumeAllGas  // Infinite loop (simulates an out-of-gas receiver)
}

chainlink-ton/contracts/contracts/ccip/test/receiver/contract.tolk

fun onInternalMessage(in: InMessage) {
    val msg = lazy TestReceiver_InMessage.fromSlice(in.body);
    match (msg) {
        Receiver_CCIPReceive => {
            var st = lazy Storage.load();

            // 1. Check that enough value is received to process this message.
            assert( in.valueCoins >= ton("0.03") ) throw (Receiver_Error.LowValue as int);

            // 2. Check CCIPReceive only comes from router.
            assert( in.senderAddress == st.authorizedCaller) throw (Receiver_Error.Unauthorized as int);

            // 3. Process the message according to your product logic.
            match (st.behavior) {
                TestReceiverBehavior.Accept        => { processAccept(msg, in.senderAddress) },
                TestReceiverBehavior.RejectAll     => { processRejectAll() },
                TestReceiverBehavior.ConsumeAllGas => { processConsumeAllGas() },
            }

            // 4. Send CCIPReceiveConfirm back to the Router after processing.
            //    reserveToncoinsOnBalance preserves the contract's existing balance;
            //    SEND_MODE_CARRY_ALL_BALANCE then forwards everything above that amount —
            //    effectively the TON that arrived with this message minus compute/action fees.
            //    At least 0.02 TON is required for the Router to process the confirmation;
            //    send ~0.025 TON or more to account for fee fluctuations.
            reserveToncoinsOnBalance(0, RESERVE_MODE_INCREASE_BY_ORIGINAL_BALANCE);
            val receiveConfirm = createMessage({
                bounce: true,
                value: 0,
                dest: in.senderAddress,
                body: Router_CCIPReceiveConfirm { execId: msg.execId },
            });
            receiveConfirm.send(SEND_MODE_CARRY_ALL_BALANCE);
        }
        TestReceiver_UpdateAuthorizedCaller => { onUpdateAuthorizedCaller(msg, in.senderAddress) }
        TestReceiver_UpdateBehavior         => { onUpdateBehavior(msg, in.senderAddress) }
        Upgradeable_Upgrade => {
            var st = lazy Storage.load();
            st.ownable.requireOwner(in.senderAddress);
            onUpgrade(msg);
        }
        else => { assert(in.body.isEmpty()) throw 0xFFFF }
    }
}

Terminal

npm run deploy:ton:receiver