Connect, share wins, swap ideas, and chill with fellow community members

Member Lounge

 An architectural and smart contract breakdown of `StreamingPay.sol` (from `rdmbtc/puls-primitives`)—a lightweight smart contract that streams 6-decimal USDC second-by-second between accounts on Arc without requiring per-second gas costs.

: Developers building subscription protocols, real-time creator payroll, pay-per-minute services, or continuous liquidity streaming on Arc.

How lazy evaluation and linear balance interpolation avoid onchain execution loops, how cancellation and withdrawal math guarantees solvency, and why Arc’s native USDC gas and sub-second Malachite blocks make micro-streaming viable.

1. The Problem: Why Traditional Blockchains Break Streaming Payments

Discrete billing models (like monthly subscription charges or bi-weekly invoices) create friction for modern digital workflows. If an agreement ends on day 5 of a 30-day cycle, refund processing requires manual intervention and dispute handling.

While continuous streaming payments (paying fractions of a cent every second) solve this by aligning value transfer with time elapsed, traditional blockchains introduce severe barriers:

1. Gas Volatility Overhead: On Ethereum and L2s, claiming accumulated micro-streams costs volatile gas fees that can easily exceed the value of the stream itself.

2. Dual-Token Friction: Users must manage both a volatile native gas token (ETH) and their stablecoin balance (USDC), complicating auto-withdrawal loops.

Arc eliminates both pain points: gas fees are settled natively in 6-decimal USDC with stable EWMA pricing, making continuous payment primitives clean and deterministic.

2. Architecture & Lifecycle of StreamingPay.sol

A common misconception about streaming contracts is that they execute a transaction every second. Instead, StreamingPay.sol uses lazy balance interpolation:

1. Stream Creation: The sender approves and deposits a total USDC allocation (e.g., $100.00 USDC for 30 days) and specifies `startTime` and `stopTime`.

2. Lazy Balance Calculation: At any timestamp T, the contract computes the recipient's accrued balance on-the-fly:

 ElapsedTime = min(T, stopTime) - startTime

AccruedUSDC = ElapsedTime × ratePerSecond

AvailableToWithdraw = AccruedUSDC - withdrawnAmount

3. Partial Withdrawals: The recipient can call `withdrawFromStream()` at any moment to claim whatever balance has accumulated to date.

4. Early Cancellation: Either party can cancel an active stream. The contract transfers accrued USDC to the recipient and immediately refunds all unstreamed collateral back to the sender.

Below is the core implementation of StreamingPay.sol designed for 6-decimal USDC on Arc Testnet:

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

import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

 * @dev Continuous pay-per-second USDC streaming contract on Arc.

 * Reference implementation from rdmbtc/puls-primitives

contract StreamingPay is ReentrancyGuard {

    IERC20 public immutable usdcToken;

        uint256 deposit;          // Total 6-decimal USDC deposited

        uint256 ratePerSecond;    // 6-decimal USDC per second

        uint256 startTime;        // Unix timestamp

        uint256 stopTime;         // Unix timestamp

        uint256 withdrawnAmount;  // Total USDC withdrawn so far

    mapping(uint256 => Stream) public streams;

    event StreamCreated(uint256 indexed streamId, address indexed sender, address indexed recipient, uint256 deposit, uint256 ratePerSecond);

    event StreamWithdrawn(uint256 indexed streamId, address indexed recipient, uint256 amount);

    event StreamCancelled(uint256 indexed streamId, uint256 senderRefund, uint256 recipientPayout);

    constructor(address _usdcToken) {

        require(_usdcToken != address(0), "Invalid token address");

        usdcToken = IERC20(_usdcToken);

    ) external nonReentrant returns (uint256 streamId) {

        require(recipient != address(0) && recipient != msg.sender, "Invalid recipient");

        require(startTime >= block.timestamp, "Start time must be in future");

        require(stopTime > startTime, "Stop time must follow start time");

        require(deposit > 0, "Deposit must be non-zero");

        uint256 duration = stopTime - startTime;

        uint256 ratePerSecond = deposit / duration;

        require(ratePerSecond > 0, "Rate per second too small for duration");

        // Transfer 6-decimal USDC collateral into contract escrow

        require(usdcToken.transferFrom(msg.sender, address(this), deposit), "USDC transfer failed");

        streamId = nextStreamId++;

        streams[streamId] = Stream({

            sender: msg.sender,

            recipient: recipient,

            deposit: deposit,

            ratePerSecond: ratePerSecond,

            startTime: startTime,

            stopTime: stopTime,

            withdrawnAmount: 0,

        emit StreamCreated(streamId, msg.sender, recipient, deposit, ratePerSecond);

    function balanceOf(uint256 streamId) public view returns (uint256 recipientBalance, uint256 senderBalance) {

        Stream storage stream = streams[streamId];

        if (!stream.isActive || block.timestamp < stream.startTime) {

            return (0, stream.deposit - stream.withdrawnAmount);

        uint256 effectiveTime = block.timestamp > stream.stopTime ? stream.stopTime : block.timestamp;

        uint256 totalAccrued = (effectiveTime - stream.startTime) * stream.ratePerSecond;

        recipientBalance = totalAccrued - stream.withdrawnAmount;

        senderBalance = stream.deposit - totalAccrued;

    function withdrawFromStream(uint256 streamId, uint256 amount) external nonReentrant {

        require(stream.isActive, "Stream inactive");

        require(msg.sender == stream.recipient, "Only recipient can withdraw");

        (uint256 availableRecipient, ) = balanceOf(streamId);

        require(amount <= availableRecipient, "Amount exceeds available balance");

        stream.withdrawnAmount += amount;

        require(usdcToken.transfer(stream.recipient, amount), "USDC payout failed");

        emit StreamWithdrawn(streamId, stream.recipient, amount);

    function cancelStream(uint256 streamId) external nonReentrant {

        require(stream.isActive, "Stream already inactive");

        require(msg.sender == stream.sender || msg.sender == stream.recipient, "Unauthorized cancellation");

        (uint256 recipientPayout, uint256 senderRefund) = balanceOf(streamId);

        if (recipientPayout > 0) {

            require(usdcToken.transfer(stream.recipient, recipientPayout), "Recipient payout failed");

            require(usdcToken.transfer(stream.sender, senderRefund), "Sender refund failed");

        emit StreamCancelled(streamId, senderRefund, recipientPayout);

1. Timestamp Granularity vs Sub-Second Blocks: Arc produces blocks in sub-seconds (~400–800ms), but block.timestamp follows standard EVM 1-second unix granularity. Defining flow rates in integer 6-decimal USDC per second (10^6 units/sec) works cleanly without timestamp truncation artifacts.

2. Sub-Second Claim Finality: When a recipient withdraws from a stream, Arc’s Malachite consensus finalizes the payout in single-block inclusion, allowing frontend balances to reflect withdrawals immediately without waiting through multi-block confirmation spinners.

5. Official References & Open Source Primitives

• Arc Official Documentation — Architecture, Gas, and EVM compatibility.

• Circle Developer Docs — USDC smart contract guides.

• Standalone Primitives Repository: github.com/rdmbtc/puls-primitives.

For teams implementing streaming or subscription billing on Arc: are you pairing streaming contracts with EIP-3009 gasless permits, or letting recipients trigger periodic pull withdrawals directly from their wallets?

Building a Pay-Per-Second Streaming Payment Engine on Arc Testnet: How StreamingPay.sol Handles Continuous USDC Flows

Home

Forum

Events

Content

Courses

Collections

People

Contributors

Albums

Groups

Chat

Channels

Not being used

Help

Join the global network of builders developing the Economic OS for the internet. We’re reimagining how value moves, creating the tools that make the economy work for everyone.

Arc House

What do you do professionally (be specific especially if you are self employed)

Join a global network of builders developing the Economic OS for the internet. We’re reimagining how value moves, creating the tools that make that economy work for everyone. 

Arc House | Build the economic OS for the internet with us

Copyright

Terms of Service

Privacy

Code of Conduct

Your Privacy Choices

It looks like there is no account associated with the email you provided. The event is for members only. Please complete the application to join our community first.

Thank you for your interest in joining us

Thanks for your interest in joining the event. However, your account is still pending. Once it's approved, you'll be able to register for the event. Please contact us via dev@arc.io if you need support.

Pending Approval

Login to the The Arc Community Hub community to connect with others, attend community events, and more!

Login or Sign Up for even more

To unlock all parts of the community complete your profile using verifiable and real information.

Hey, complete your profile

It looks like there is no account associated with the email you provided. Please complete the application to join our community.

Thank you for your interest in joining Arc House.

Thanks for your interest in joining Arc House. We will review your request shortly and email you once it's approved. Meanwhile, please feel free to contact us via dev@arc.io for any questions.

Accounts are unapproved when profile information cannot be verified or when activity patterns indicate spam, inorganic participation, or behavior that undermines trust in the program.

To strengthen your profile for future consideration, sign in with a verified LinkedIn account, use real and current profile information, and participate constructively in other community spaces.

Commercial customers should raise concerns through their support channel.

https://www.arc.network/community-guidelines