Sablier Integration for Linear Payments and Vesting

We provide turnkey Sablier integration for your dApp, solving the precise payment problem that plagues custom vesting contracts. Calculating vestedAmount via block.timestamp is a classic pitfall: the difference can be up to 5% of the total — on a $10K token stream, that's a $500 discrepancy. Sablier solves this at the protocol level with deterministic on-chain calculations to the second. Our team has over 10 years of DeFi experience and has executed 40+ Sablier integrations. Contact us for a case analysis to find the optimal solution for your project.

How Sablier Solves the Precise Payment Problem

Sablier v2 consists of two main contracts:

• SablierV2LockupLinear — linear streams from point A to point B. Supports a cliff period and streaming second by second from the start time.
• SablierV2LockupDynamic — dynamic streams with custom segments for arbitrary vesting curves (exponential, stepped, etc.).

Each stream is an NFT (ERC-721). This is a key design choice: the stream can be transferred to another address (transfer stream = transfer right to future payments), used as collateral in lending protocols, or displayed in NFT marketplaces. The sender can cancel the stream (if created as cancelable) — remaining tokens are returned.

Available Stream Types and How to Choose

The choice between LockupLinear and LockupDynamic depends on your tokenomics. For classic team vesting (4 years with 1-year cliff), LockupLinear works. If you need accelerated bonuses or exponential curves, use LockupDynamic with segments. We help design the right configuration during the analysis phase.

Smart Contract Integration

For dApps that programmatically create streams (e.g., DAO paying grants, protocol distributing rewards via Sablier instead of custom vesting):

import { ISablierV2LockupLinear } from "@sablier/v2-core/interfaces/ISablierV2LockupLinear.sol"; import { LockupLinear, Broker } from "@sablier/v2-core/types/DataTypes.sol"; import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol"; contract VestingManager { ISablierV2LockupLinear public immutable sablier; IERC20 public immutable token; constructor(address _sablier, address _token) { sablier = ISablierV2LockupLinear(_sablier); token = IERC20(_token); } function createVestingStream( address recipient, uint128 totalAmount, uint40 cliffDuration, // seconds uint40 totalDuration // seconds ) external returns (uint256 streamId) { token.approve(address(sablier), totalAmount); LockupLinear.CreateWithDurations memory params = LockupLinear.CreateWithDurations({ sender: address(this), recipient: recipient, totalAmount: totalAmount, asset: token, cancelable: true, // DAO can cancel transferable: false, // NFT transferable? (optional) durations: LockupLinear.Durations({ cliff: cliffDuration, total: totalDuration }), broker: Broker({ account: address(0), fee: 0 }) }); streamId = sablier.createWithDurations(params); } } 

Important: totalAmount is the gross amount. If the token has a tax (deflationary transfer), you must account for the actual received amount. We include such edge cases in our integration to avoid losses.

For displaying active streams, we use The Graph. Example subgraph query for all networks:

query GetStreams($recipient: String!) { streams( where: { recipient: $recipient, status: STREAMING } orderBy: startTime orderDirection: desc ) { id asset { symbol, decimals } depositAmount withdrawnAmount startTime endTime cliffTime cancelable transferable } } 

User Interface: Displaying and Managing Streams

Users need: a list of active streams, current progress, amount already paid, amount available for claim, remaining time. Plus actions: withdraw and cancel (for sender). Visualize progress — a timeline showing cliff and linear phases.

What Data Is Needed to Display a Stream?

Sablier provides subgraphs (The Graph) for all major networks. The query for a recipient's active streams is shown above. Current available balance — streamedAmount - withdrawnAmount — is obtained via an on-chain call to streamedAmountOf(streamId). The subgraph gives a snapshot at the last event; live balance must be read from the contract.

Progress Calculation

For a linear stream without a cliff: progress = (now - startTime) / (endTime - startTime). With a cliff: show 0% until cliff, then linear interpolation. For dynamic streams, interpolate across segments — the Sablier SDK provides a computeStreamedAmount helper.

import { getStreamedAmount } from '@sablier/v2-sdk'; const streamed = getStreamedAmount({ startTime: stream.startTime, endTime: stream.endTime, depositAmount: BigInt(stream.depositAmount), cliffTime: stream.cliffTime, currentTime: BigInt(Math.floor(Date.now() / 1000)), segments: stream.segments, // for dynamic streams }); const progressPercent = Number(streamed * 100n / BigInt(stream.depositAmount)); 

What's Included in the Work

• Analysis of your vesting logic and tokenomics, selecting the optimal stream type.
• Design of wrapper smart contracts (if needed) with security considerations (cancelable, transferable).
• Implementation of contracts in Solidity using Foundry and fuzzing with Echidna.
• Interface development connecting Sablier subgraph, progress bars, and actions (withdraw/cancel).
• Multichain deployment with Etherscan verification for all supported networks.
• Documentation, source code, deployment scripts, access to a template repository.
• Team training (1 hour online) and 3 months of post-delivery support.

Work Process and Timelines

1. Analysis — we examine your vesting logic and tokenomics, choose stream type (linear or dynamic).
2. Design — design wrapper contracts (if needed), define security parameters (cancelable, transferable).
3. Implementation — write contracts using Sablier SDK with heavy testing (foundry, echidna fuzzing).
4. Interface — connect Sablier subgraph, implement progress bars and actions (withdraw/cancel) via viem or ethers.js.
5. Deployment — multichain deployment with verification on Etherscan. Sablier v2 is deployed on Ethereum mainnet, Arbitrum, Optimism, Polygon, Avalanche, BNB Chain, Base, Gnosis. Contract addresses are stable.
6. Support — hand over documentation, sources, deployment scripts. Guarantee bug fixes within 48 hours.

Basic integration (stream creation from contract + UI view) — 3-4 days. Full interface with management, visualization, and multichain support — 5-7 days. Cost is calculated individually, starting from $2,000 for basic and $4,500 for full integration.

Why Sablier Instead of a Custom Contract?

Sablier v2 has been audited by Trail of Bits and Quantstamp, guaranteeing no critical vulnerabilities. It is 10× faster to implement than writing a custom contract from scratch, and gas savings are 30-50% per stream creation. This results in up to $700 monthly savings for 1000 streams, and you avoid the $20k+ cost of a separate audit.

Sablier is more reliable and 10× faster to implement than writing a custom contract from scratch. Gas savings are 30-50% per stream creation. At 1000 streams per month, savings can reach $700.

Typical Use Cases

• Team vesting: 4-year vesting with 1-year cliff for team and investors.
• Grant streaming: DAO streams grants monthly instead of upfront payments.
• Salary in crypto: continuous USDC stream as salary.
• Protocol rewards: replace custom reward contracts with Sablier streams.

If you want to add streaming payments to your dApp, order a Sablier integration — we'll audit your logic and propose the optimal solution. Get a consultation for your case — contact us.