Implementing Proration in Onchain Subscriptions on Ethereum for SaaS Developers

Basic Subscription Escrow Contract in Solidity

This Solidity contract provides a basic implementation for subscription payments using an escrow model. Users deposit ETH upfront into their personal balances. The contract owner—typically automated by your SaaS backend or a relayer—manually triggers payments once per billing period (30 days). This setup ensures funds are escrowed securely on-chain before release.

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

contract BasicSubscriptionEscrow {
    address public immutable owner;
    uint256 public immutable subscriptionPrice;
    uint256 public constant PERIOD = 30 days;

    mapping(address => uint256) public userBalances;
    mapping(address => uint256) public lastPaymentTime;

    event Deposited(address indexed user, uint256 amount);
    event PaymentTriggered(address indexed user, uint256 amount);

    constructor(uint256 _subscriptionPrice) {
        owner = msg.sender;
        subscriptionPrice = _subscriptionPrice;
    }

    /// @notice Users deposit ETH into their escrow balance
    function deposit() external payable {
        require(msg.value > 0, "Deposit must be greater than 0");
        userBalances[msg.sender] += msg.value;
        emit Deposited(msg.sender, msg.value);
    }

    /// @notice Owner triggers a subscription payment for a user
    /// Manual recurring logic: checks time period and balance
    function triggerPayment(address user) external {
        require(msg.sender == owner, "Only owner can trigger payments");
        require(block.timestamp >= lastPaymentTime[user] + PERIOD, "Payment period not elapsed");
        require(userBalances[user] >= subscriptionPrice, "Insufficient escrow balance");

        userBalances[user] -= subscriptionPrice;
        payable(owner).transfer(subscriptionPrice);
        lastPaymentTime[user] = block.timestamp;

        emit PaymentTriggered(user, subscriptionPrice);
    }

    /// @notice Owner can withdraw excess contract balance if any
    function withdrawExcess() external {
        require(msg.sender == owner, "Only owner");
        uint256 balance = address(this).balance;
        require(balance > 0, "No excess balance");
        payable(owner).transfer(balance);
    }

    /// @notice View function to check if a user can be billed
    function canTriggerPayment(address user) external view returns (bool) {
        return block.timestamp >= lastPaymentTime[user] + PERIOD &&
               userBalances[user] >= subscriptionPrice;
    }
}
```

**Key components:** - **Escrow balances**: Prevent overdrafts with per-user tracking. - **Time-based gating**: `PERIOD` enforces monthly billing cycles. - **Manual triggers**: `triggerPayment` simulates recurring logic; ideal for testing or custom automation. - **Safety checks**: Immutables, events, and view functions for transparency. Extend this for proration by calculating partial payments proportional to time elapsed since `lastPaymentTime[user]`. Use oracles for off-chain automation in production.