Skip to main content

Create a Lockup Linear stream

Lockup Linear are streams with a strictly linear streaming function. In this guide, we will show you how to programmatically create a Lockup Linear stream.

This guide assumes that you have already gone through the Protocol Concepts section.


This guide interacts with the Core contracts directly.


The code in this guide is not production-ready, and is implemented in a simplistic manner for the purpose of learning.

Set up a contract

Declare the Solidity version used to compile the contract:

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.8.19;

Import the relevant symbols from @sablier/v2-core:

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ud60x18 } from "@prb/math/src/UD60x18.sol";
import { ISablierV2LockupLinear } from "@sablier/v2-core/src/interfaces/ISablierV2LockupLinear.sol";
import { Broker, LockupLinear } from "@sablier/v2-core/src/types/DataTypes.sol";

Create a contract called LockupLinearStreamCreator, and declare a constant DAI of type IERC20 and a constant LOCKUP_LINEAR of type ISablierV2LockupLinear:

contract LockupLinearStreamCreator {
IERC20 public constant DAI = IERC20(0x6B175474E89094C44Da98b954EedeAC495271d0F);
ISablierV2LockupLinear public constant LOCKUP_LINEAR =

In the code above, the contract addresses are hard-coded for demonstration purposes. However, in production, you would likely use input parameters to allow flexibility in changing the addresses.

Also, these addresses are deployed on Mainnet. If you need to work with a different chain, the Sablier addresses can be obtained from the Deployment Addresses page.

Create functions

There are two create functions in the Lockup Linear contract:

Which one you choose depends upon your use case. In this guide, we will use createWithDurations.

Function definition

Define a function called createStream which takes a single parameter totalAmount, and which returns the id of the created stream:

function createStream(uint128 totalAmount) public returns (uint256 streamId) {
// ...

ERC-20 steps

To create a stream, the caller must approve the creator contract to pull the tokens from the calling address's account. Then, we have to also approve the Sablier contract to pull the assets that the creator contract will be in possession of after they are transferred from the calling address (you):

// Transfer the provided amount of DAI tokens to this contract
DAI.transferFrom(msg.sender, address(this), totalAmount);

// Approve the Sablier contract to spend DAI
DAI.approve(address(LOCKUP_LINEAR), totalAmount);

For more guidance on how to approve and transfer ERC-20 assets, see this article on the Ethereum website.


Sablier uses structs to encode the parameters of its create functions. The struct associated with createWithDurations is LockupLinear.CreateWithDurations, and it can be initialized like this:

LockupLinear.CreateWithDurations memory params;

Let's review each parameter in detail.


The address streaming the assets, with the ability to cancel the stream:

params.sender = msg.sender;


The address receiving the assets:

params.recipient = address(0xCAFE);

Total amount

The total amount of ERC-20 assets to be paid, including the stream deposit and any potential fees, all denoted in units of the asset's decimals.

params.totalAmount = totalAmount;


The contract address of the ERC-20 asset used for streaming. In this example, we will stream DAI:

params.asset = DAI;


Boolean that indicates whether the stream will be cancelable or not.

params.cancelable = true;


Boolean that indicates whether the stream will be transferable or not.

params.transferable = true;


An optional parameter that can be set in order to charge a fee as a percentage of totalAmount.

In the following example, we will leave this parameter uninitialized (i.e. set to zero), because it doesn't make sense to charge yourself a fee. In practice, this parameter will mostly be used by front-end applications. = Broker(address(0), ud60x18(0));

Wondering what's up with that ud60x18 function? It's a casting function that wraps a basic integer to the UD60x18 value type. This type is part of the math library PRBMath, which is used in Sablier for fixed-point calculations.


Struct containing (i) cliff period duration and (ii) total stream duration, both in seconds.

params.durations = LockupLinear.Durations({
cliff: 4 weeks,
total: 52 weeks

Invoke the create function

With all parameters set, we can now call the createWithDurations function, and assign the id of the newly created stream to a variable:

streamId = LOCKUP_LINEAR.createWithDurations(params);

The complete Lockup Linear stream creator contract

Below you can see the complete functioning code: a contract that creates Lockup Linear streams that start at block.timestamp. You can access the code on GitHub through this link.

Lockup Linear Stream Creator