Skip to main content

Create a Lockup Linear Stream

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

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

caution

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.22;

Import the relevant symbols from @sablier/lockup:

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ud60x18 } from "@prb/math/src/UD60x18.sol";
import { ISablierLockup } from "@sablier/lockup/src/interfaces/ISablierLockup.sol";
import { Broker, Lockup, LockupLinear } from "@sablier/lockup/src/types/DataTypes.sol";

Create a contract called LockupLinearStreamCreator, and declare a constant DAI of type IERC20 and a constant LOCKUP of type ISablierLockup:

contract LockupLinearStreamCreator {
    IERC20 public constant DAI = IERC20(0x68194a729C2450ad26072b3D33ADaCbcef39D574);
    ISablierLockup public constant LOCKUP = ISablierLockup(0xC2Da366fD67423b500cDF4712BdB41d0995b0794);
}
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 Sepolia. If you need to work with a different chain, Lockup addresses can be obtained from the Lockup Deployments page.

There are two create functions in the Lockup contract that can be used to create Linear streams:

  • createWithDurationsLL: takes duration and calculates the start and end timestamps based on the provided durations.
  • createWithTimestampsLL: takes start and end timestamps.

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

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 approve the Lockup contract to pull the tokens 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), totalAmount);

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

Parameters​

The struct associated with createWithDurationsLL are Lockup.CreateWithDurations (a shared struct across all the lockup streams), LockupLinear.durations and LockupLinear.unlockamounts.

Lockup.CreateWithDurations memory params;
LockupLinear.UnlockAmounts memory unlockAmounts;
LockupLinear.Durations memory durations;

Let's review each parameter in detail.

Let's review each parameter in detail.

Broker​

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.

params.broker = Broker(address(0), ud60x18(0));
info

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.

Cancelable​

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

params.cancelable = true;

Recipient​

The address receiving the tokens:

params.recipient = address(0xCAFE);

Sender​

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

params.sender = msg.sender;

Token​

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

params.token = DAI;

Total amount​

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

params.totalAmount = totalAmount;

Transferable​

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

params.transferable = true;

Durations​

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

durations = LockupLinear.Durations({
    cliff: 0,
    total: 52 weeks
});

Unlock Amounts​

Struct containing details on unlock amounts at start time and at cliff time.

unlockAmounts = LockupLinear.UnlockAmounts({ start: 0, cliff: 0 });

Invoke the create function​

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

streamId = LOCKUP.createWithDurationsLL(params, unlockAmounts, durations);

Full code​

Below you can see the full code. You can also access the code on GitHub through this link.

Lockup Linear Stream Creator
loading...