How to Set Up Prorated Onchain Subscriptions for Web3 SaaS in 2026

Multi-Chain Proration Magic: Solidity + Chainlink CCIP for Eth & Polygon Tier Upgrades

Ready to supercharge your Web3 SaaS with prorated subscriptions that work seamlessly across chains? 🚀 Here's a battle-tested Solidity contract using Chainlink CCIP to handle tier upgrades from Ethereum to Polygon (or vice versa). It calculates proration based on time used, refunds the difference, and propagates the upgrade cross-chain automatically!

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

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

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract ProratedSubscription {
    IRouterClient public immutable router;
    IERC20 public immutable link; // For CCIP fees

    uint256 public constant MONTH = 30 days;
    uint256[] public tierPrices = [10 ether, 20 ether, 50 ether]; // Basic, Pro, Enterprise (in native token)

    struct Subscription {
        uint256 tier;
        uint256 startTime;
        uint256 endTime;
    }

    mapping(address => Subscription) public subscriptions;

    // Chain selectors: Ethereum Mainnet = 1, Polygon = 137
    uint64 public constant ETHEREUM_SELECTOR = 1;
    uint64 public constant POLYGON_SELECTOR = 137;

    event TierUpgraded(address indexed user, uint256 oldTier, uint256 newTier, uint256 prorationRefund);
    event CrossChainMessageSent(uint64 indexed destinationChain, address indexed user, uint256 newTier);

    constructor(address _router, address _link) {
        router = IRouterClient(_router);
        link = IERC20(_link);
    }

    function upgradeTier(uint256 newTier, uint64 destinationChainSelector) external payable {
        Subscription storage sub = subscriptions[msg.sender];
        require(sub.endTime > block.timestamp, "No active subscription!");
        require(newTier < tierPrices.length && newTier > sub.tier, "Invalid tier upgrade!");

        // Calculate proration
        uint256 timeElapsed = block.timestamp - sub.startTime;
        uint256 oldMonthlyPrice = tierPrices[sub.tier];
        uint256 prorationUsed = (timeElapsed * oldMonthlyPrice) / MONTH;
        uint256 prorationRefund = oldMonthlyPrice - prorationUsed;

        uint256 newMonthlyPrice = tierPrices[newTier];
        uint256 netPayment = newMonthlyPrice - prorationRefund;
        require(msg.value >= netPayment, "Insufficient payment for upgrade!");

        // Refund excess
        if (msg.value > netPayment) {
            payable(msg.sender).transfer(msg.value - netPayment);
        }

        // Update subscription
        sub.tier = newTier;
        sub.startTime = block.timestamp;
        sub.endTime = block.timestamp + MONTH;

        emit TierUpgraded(msg.sender, sub.tier, newTier, prorationRefund);

        // Cross-chain propagation if specified
        if (destinationChainSelector != 0) {
            _sendCrossChainUpgrade(destinationChainSelector, msg.sender, newTier);
        }
    }

    function _sendCrossChainUpgrade(uint64 destinationChainSelector, address user, uint256 newTier) internal {
        bytes32 messageId = router.ccipSend{value: msg.value}(destinationChainSelector, _buildMessage(user, newTier));
        emit CrossChainMessageSent(destinationChainSelector, user, newTier);
    }

    function _buildMessage(address user, uint256 newTier) internal pure returns (Client.EVM2AnyMessage memory) {
        return Client.EVM2AnyMessage({
            receiver: abi.encode(user), // Target receiver on dest chain
            data: abi.encode(user, newTier),
            tokenAmounts: new Client.EVMTokenAmount[](0),
            extraArgs: bytes(""),
            feeToken: address(0) // Native token for fees
        });
    }

    // Receiver function for CCIP messages (deploy on both chains)
    function ccipReceive(Client.Any2EVMMessage memory message) external {
        require(msg.sender == address(router), "Only router");
        (address user, uint256 newTier) = abi.decode(message.data, (address, uint256));
        // Sync subscription on this chain
        subscriptions[user].tier = newTier;
    }
}
```

Boom! Deploy this on both Ethereum and Polygon with the correct Chainlink CCIP router and LINK token addresses. Pro tip: Fund it with LINK for fees and test on Sepolia/Mumbai testnets first. Your users will love the smooth, fair upgrades—no more full-month resets. What's next? Hook it up to your React frontend! 💥 Questions? Drop 'em below! 👇