Sablier

https://docs.sablier.com/
Admin
Sablier is a token distribution protocol designed for streaming and distributing tokens over time,...
Tokens:604,891
Snippets:3,298
Trust Score:8.5
Update:1 year ago
Show doc for...
Tokens:
Raw
### Sablier Strategy Example Setup (JSON)

Source: https://docs.sablier.com/guides/snapshot-voting

An example JSON configuration for setting up Sablier strategies, specifying the sender and token addresses.

```json
{
  "sender": "0xC9F2D9adfa6C24ce0D5a999F2BA3c6b06E36F75E",
  "token": "0x7f8F6E42C169B294A384F5667c303fd8Eedb3CF3"
}
```

--------------------------------

### Solidity Contract Setup for Sablier Lockup Dynamic

Source: https://docs.sablier.com/guides/lockup/examples/create-stream/lockup-dynamic

This snippet demonstrates the initial setup of a Solidity contract for creating dynamic streams using Sablier's Lockup protocol. It includes setting the Solidity version, importing necessary interfaces, and declaring constants for token and lockup contract addresses. Note that these addresses are hardcoded for demonstration and should be handled dynamically in production environments.

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

// Import the relevant symbols from @sablier/lockup
// (Actual import statement would go here if provided in the text)

contract LockupDynamicStreamCreator {
    IERC20 public constant DAI = IERC20(0x68194a729C2450ad26072b3D33ADaCbcef39D574);
    ISablierLockup public constant LOCKUP = ISablierLockup(0xC2Da366fD67423b500cDF4712BdB41d0995b0794);
}
```

--------------------------------

### Full Lockup Tranched Stream Creator Example

Source: https://docs.sablier.com/guides/lockup/examples/create-stream/lockup-tranched

Provides the complete Solidity code for the LockupTranchedStreamCreator contract, demonstrating stream creation with tranches and durations.

```solidity
https://github.com/sablier-labs/examples/blob/main/lockup/LockupTranchedStreamCreator.sol
```

--------------------------------

### Full FlowBatchable Contract Example

Source: https://docs.sablier.com/guides/flow/examples/batchable

Presents the complete Solidity code for the FlowBatchable contract, integrating the setup and the multiple stream creation functionality for a comprehensive example.

```solidity
pragma solidity >=0.8.22;

import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ISablierFlow } from "./ISablierFlow.sol";
import { UD21x18 } from "./types/UD21x18.sol";

contract FlowBatchable {
    IERC20 public constant USDC = IERC20(0xf08A50178dfcDe18524640EA6618a1f965821715);
    ISablierFlow public constant FLOW = ISablierFlow(0x52ab22e769E31564E17D524b683264B65662A014);

    function createMultiple() external returns (uint256[] memory streamIds) {
        address sender = msg.sender;
        address firstRecipient = address(0xCAFE);
        address secondRecipient = address(0xBEEF);
        UD21x18 firstRatePerSecond = UD21x18(0.0001e18);
        UD21x18 secondRatePerSecond = UD21x18(0.0002e18);
        bool transferable = true;

        bytes[] memory calls = new bytes[](2);
        calls[0] = abi.encodeCall(FLOW.create, (sender, firstRecipient, firstRatePerSecond, USDC, transferable));
        calls[1] = abi.encodeCall(FLOW.create, (sender, secondRecipient, secondRatePerSecond, USDC, transferable));

        uint256 nextStreamId = FLOW.nextStreamId();
        streamIds = new uint256[](2);
        streamIds[0] = nextStreamId;
        streamIds[1] = nextStreamId + 1;

        FLOW.batch(calls);
    }
}
```

--------------------------------

### Full Flow Stream Creator Contract Example

Source: https://docs.sablier.com/guides/flow/examples/create-stream

The complete Solidity code for the `FlowStreamCreator` contract, demonstrating how to set up constants and implement the stream creation logic. This is an example for learning purposes and not production-ready.

```solidity
pragma solidity >=0.8.22;

import { ISablierFlow } from "@sablier/flow/ISablierFlow.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { FlowUtilities } from "@sablier/flow/FlowUtilities.sol";

contract FlowStreamCreator {
    IERC20 public constant USDC = IERC20(0xf08A50178dfcDe18524640EA6618a1f965821715);
    ISablierFlow public constant FLOW = ISablierFlow(0x52ab22e769E31564E17D524b683264B65662A014);

    function createStream_1K_PerMonth() external returns (uint256) {
        uint256 streamId = FLOW.create({
            sender: msg.sender,
            recipient: address(0xCAFE),
            ratePerSecond: FlowUtilities.ratePerSecondWithDuration({
                token: address(USDC),
                amount: 1000e6, // 1000 USDC
                duration: 30 days
            }),
            token: USDC,
            transferable: true
        });

        return streamId;
    }
}
```

--------------------------------

### Full Batch LD Stream Creator Example (Solidity)

Source: https://docs.sablier.com/guides/lockup/examples/batch-create-streams/batch-lockup-dynamic

Provides the complete Solidity smart contract code for creating dynamic streams in batches using timestamps. This example integrates all previously shown snippets into a functional contract. Found on GitHub.

```solidity
https://github.com/sablier-labs/examples/blob/main/lockup/BatchLDStreamCreator.sol
```

--------------------------------

### Install Sablier Protocol npm Package with Bun

Source: https://docs.sablier.com/guides/airdrops/examples/local-environment

Installs the Sablier protocol Node.js packages using the Bun package manager. This command downloads the necessary contracts and dependencies into the node_modules directory.

```bash
$ bun add @sablier/sablier
```

--------------------------------

### Example: Calculating Flow Rate Per Second (JavaScript)

Source: https://docs.sablier.com/llms

This example demonstrates how to calculate the rate per second for a Flow stream using Sablier. It likely involves interacting with a Sablier smart contract or SDK. The input is a stream's total amount and duration, and the output is the rate per second.

```javascript
import CodeBlock from "@theme/CodeBlock";

// Assume 'stream' object contains properties like 'amount' and 'duration'
// const stream = { amount: 1000000, duration: 86400 };

// Example placeholder for calculation logic
// const ratePerSecond = stream.amount / stream.duration;

<CodeBlock language="javascript">
{
  `// To calculate rate per second for a Flow stream:\nconst ratePerSecond = stream.amount / stream.duration;\nconsole.log(ratePerSecond);`
}
</CodeBlock>
```

--------------------------------

### URL Schemes Guide

Source: https://docs.sablier.com/llms

Guide for integrators on using URL schemes to link to specific users or entities within the Sablier Interface.

```APIDOC
## URL Schemes Guide

### Description
This guide explains how integrators can leverage URL schemes provided by the Sablier Interface to create direct links to specific users or entities.

### Method
GET

### Endpoint
/apps/guides/url-schemes.md

### Parameters
None

### Request Example
(No direct request example, access via browser)

### Response
#### Success Response (200)
- **content** (string) - Guide on URL schemes.

#### Response Example
(Content details the usage of URL schemes for linking.)
```

--------------------------------

### Remap Package Names for Solidity Compiler

Source: https://docs.sablier.com/guides/airdrops/examples/local-environment

Creates or appends to a remappings.txt file to help the Solidity compiler locate installed contracts. This is crucial for importing contracts from installed packages like Sablier, OpenZeppelin, and PRB/Math.

```bash
$ echo "@sablier/${props.protocol.toLowerCase()}=node_modules/@sablier/${props.protocol.toLowerCase()}/" >> remappings.txt
$ echo "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/" >> remappings.txt
$ echo "@prb/math/=node_modules/@prb/math/" >> remappings.txt
```

--------------------------------

### Define Start and End Timestamps for Token Stream

Source: https://docs.sablier.com/guides/lockup/examples/create-stream/lockup-dynamic

Specifies the start and end times for the token stream using Unix timestamps. The end timestamp must align with the timestamp of the last segment to ensure accurate stream completion. Calculated using `block.timestamp` for dynamic timing.

```solidity
params.timestamps.start = uint40(block.timestamp + 100 seconds);
params.timestamps.end = uint40(block.timestamp + 52 weeks);
```

--------------------------------

### CSV Support Guide

Source: https://docs.sablier.com/llms

Guide on how the Sablier Interface supports CSV files for efficient and automated operations.

```APIDOC
## CSV Support Guide

### Description
Instructions on utilizing CSV files within the Sablier Interface to streamline processing and automate large-scale operations.

### Method
GET

### Endpoint
/apps/guides/csv-support.md

### Parameters
None

### Request Example
(No direct request example, access via browser)

### Response
#### Success Response (200)
- **content** (string) - Guide on CSV file support.

#### Response Example
(Content explains how to use CSV files with Sablier.)
```

--------------------------------

### Get Claim Information via GraphQL (The Graph)

Source: https://docs.sablier.com/api/airdrops/merkle-api/examples

Fetches claim details, including the token ID, recipient, and campaign information, for a specific campaign and recipient using The Graph. This is useful for displaying stream previews or NFT details after a claim.

```graphql
query getClaimForRecipient($campaignId: String!, $recipient: String) {
  actions(where: { campaign: $campaignId, category: Claim, claimRecipient: $recipient }) {
    campaign {
      id
      lockup
    }
    claimTokenId
    claimRecipient
    claimIndex
  }
}
```

--------------------------------

### Build Optimized Contracts with Foundry

Source: https://docs.sablier.com/guides/airdrops/verify-campaign

This command sequence clones the airdrop repository, checks out a specific version, installs dependencies, and builds the optimized contracts. It requires Foundry to be installed and assumes the use of `bun` as the package manager.

```bash
git clone git@github.com:sablier-labs/airdrops.git
git checkout v1.3.0
bun install --frozen-lockfile
bun run build-optimized
```

--------------------------------

### Get Campaign IPFS CID via GraphQL (Envio)

Source: https://docs.sablier.com/api/airdrops/merkle-api/examples

Retrieves the IPFS CID for a given campaign ID using a GraphQL query against the Envio indexer. This allows fetching campaign data stored on IPFS through Envio's infrastructure.

```graphql
query getCampaignData($campaignId: String!){
  Campaign(where: {id: {_eq: $campaignId}} ){
    id
    lockup
    root
    ipfsCID
    aggregateAmount
    totalRecipients
  }
}

```

--------------------------------

### Example Airdrop Stream URL on Sepolia

Source: https://docs.sablier.com/apps/guides/url-schemes

An example URL pointing to a specific Airstream on the Ethereum Sepolia testnet. The URL follows the format 'app.sablier.com/stream/' followed by the contract alias, chain ID, and stream ID.

```text
https://app.sablier.com/airstream/0xe72175dd12ac7efca6b7d12dfc913a5f661bbabc-11155111
```

--------------------------------

### Check if Campaign Has Started (Rust)

Source: https://docs.sablier.com/solana/program-reference/merkle-instant/merkle-instant

Returns a flag indicating whether the campaign has started. This function requires the 'campaign' account within the CampaignView context.

```rust
pub fn has_campaign_started(ctx: Context<CampaignView>) -> Result<bool>
```

--------------------------------

### Example Sablier Search URL for Streams by IDs

Source: https://docs.sablier.com/apps/guides/url-schemes

An example URL to access the Sablier search view, pre-filtered to show streams associated with particular IDs. This uses the 't' for tab, 'c' for chain, and 'i' for IDs parameters.

```text
https://app.sablier.com/?t=search&c=1&i=LL2-1-2,LL-1-29
```

--------------------------------

### Build Optimized Contracts with Bun

Source: https://docs.sablier.com/guides/custom-deployments

Installs project dependencies using Bun and then builds the contracts in an optimized manner. This step is necessary before contract deployment.

```bash
bun install --frozen-lockfile
bun run build-optimized
```

--------------------------------

### Example Sablier Search URL for Streams by Sender

Source: https://docs.sablier.com/apps/guides/url-schemes

An example URL to access the Sablier search view, pre-filtered to show streams created by a specific user (sender). This utilizes the 't' for tab, 'c' for chain, and 's' for sender parameters.

```text
https://app.sablier.com/?t=search&c=1&s=0x0aAeF7BbC21c627f14caD904E283e199cA2b72cC
```

--------------------------------

### Initialize Program

Source: https://docs.sablier.com/solana/program-reference/merkle-instant/merkle-instant

Initializes the Sablier Merkle Instant program, setting up essential configurations like the fee collector and Chainlink oracle details.

```APIDOC
## POST /initialize

### Description
Initializes the program with the provided fee collector address.

### Method
POST

### Endpoint
/initialize

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **fee_collector** (Pubkey) - Required - The address that will have the authority to collect fees.
- **chainlink_program** (Pubkey) - Required - The Chainlink program used to retrieve on-chain price feeds.
- **chainlink_sol_usd_feed** (Pubkey) - Required - The account providing the SOL/USD price feed data.

### Request Example
```json
{
  "fee_collector": "<FEE_COLLECTOR_ADDRESS>",
  "chainlink_program": "<CHAINLINK_PROGRAM_ID>",
  "chainlink_sol_usd_feed": "<SOL_USD_FEED_ACCOUNT>"
}
```

### Response
#### Success Response (200)
- **message** (string) - Success message indicating the program was initialized.

#### Response Example
```json
{
  "message": "Program initialized successfully."
}
```

--------------------------------

### How-to Videos

Source: https://docs.sablier.com/llms

Links to video explanations for using Sablier, found in the Support section.

```APIDOC
## How-to Videos

### Description
Provides access to a collection of video tutorials and explanations for using Sablier, located within the Support section.

### Method
GET

### Endpoint
/apps/guides/how-to.md

### Parameters
None

### Request Example
(No direct request example, access via browser)

### Response
#### Success Response (200)
- **content** (string) - Information and links to how-to videos.

#### Response Example
(Content directs users to the relevant support section for videos.)
```

--------------------------------

### Calculate Stream Time Delta - Solidity & Javascript

Source: https://docs.sablier.com/reference/legacy/contracts/constant-functions

Calculates the time delta for a stream, returning the smaller of the time elapsed since the start or the time remaining until the stop time. If the stream has not started, it returns 0. Useful for determining the active duration of a stream. Examples in Solidity and Ethers.js.

```solidity
function deltaOf(uint256 streamId) view returns (uint256)
```

```solidity
Sablier sablier = Sablier(0xabcd...);
uint256 streamId = 42;
uint256 delta = sablier.deltaOf(streamId);
```

```javascript
const sablier = new ethers.Contract(0xabcd..., sablierABI, signerOrProvider);
const streamId = 42;
const delta = await sablier.deltaOf(streamId);
```

--------------------------------

### Initialize Foundry Project

Source: https://docs.sablier.com/guides/lockup/examples/local-environment

Creates a new project using the standard Foundry template. This command sets up the basic file structure for a Foundry project, including directories for source code, tests, and scripts.

```bash
forge init my-project
cd my-project
```

--------------------------------

### Solidity: Set Recipient Parameter

Source: https://docs.sablier.com/guides/lockup/examples/create-stream/lockup-tranched

Specifies the `recipient` address for the stream. This is the address that will ultimately receive the streamed tokens. In this example, a placeholder address `0xCAFE` is used.

```solidity
params.recipient = address(0xCAFE);
```

--------------------------------

### Initialize Project with Sablier Integration Template (Bash)

Source: https://docs.sablier.com/guides/flow/examples/local-environment

Initializes a new project using the Sablier integration template and installs dependencies. This sets up a basic project structure with pre-configured Sablier imports.

```bash
$ mkdir sablier-integration-template
$ cd sablier-integration-template
$ forge init --template sablier-labs/sablier-integration-template
$ bun install
```

--------------------------------

### Get Campaign IPFS CID via GraphQL (The Graph)

Source: https://docs.sablier.com/api/airdrops/merkle-api/examples

Retrieves the IPFS CID for a given campaign ID using a GraphQL query against The Graph indexer. This is useful for accessing campaign-related data stored on IPFS.

```graphql
query getCampaignData($campaignId: String!){
  campaign(id: $campaignId){
    id
    lockup
    root
    ipfsCID
    aggregateAmount
    totalRecipients
  }
}
```

--------------------------------

### Initialize and Navigate Foundry Project

Source: https://docs.sablier.com/guides/airdrops/examples/local-environment

Commands to initialize a new Foundry project and change the directory into the newly created project folder. Foundry is a toolkit for Ethereum projects used for compiling and testing contracts.

```bash
$ forge init my-project
$ cd my-project
```

--------------------------------

### Get Claim Information via GraphQL (Envio)

Source: https://docs.sablier.com/api/airdrops/merkle-api/examples

Retrieves claim details for a specific campaign and recipient using Envio's GraphQL API. This query helps in obtaining the `tokenId` (or `streamId`) related to a user's claim.

```graphql
query getClaimForRecipient($campaignId: String!, $recipient: String) {
  Action(
    where: {
      _and: [{ campaign: { _eq: $campaignId } }, { category: { _eq: Claim } }, { claimRecipient: { _eq: $recipient } }]
    }
  ) {
    campaignObject {
      id
      lockup
    }
    claimTokenId
    claimRecipient
    claimIndex
  }
}

```

--------------------------------

### Query Block Number with API Key (JavaScript)

Source: https://docs.sablier.com/api/flow/indexers

Example using JavaScript with GraphQLClient to query the block number from a production endpoint. It demonstrates setting the Authorization header with a Bearer token. Requires a PRODUCTION_URL and an API_KEY. Make sure to install the 'graphql-request' package.

```javascript
import { GraphQLClient } from 'graphql-request';

async function getBlockNumber() {
  const client = new GraphQLClient("<PRODUCTION_URL>", {
    headers: {
      Authorization: `Bearer <API_KEY>`,
    },
  });

  const query = `query { _meta: { block { number } } }`;
  const result = await client.request(query);
  console.log(result);
}
```

--------------------------------

### Full LockupLinearStreamCreator Example

Source: https://docs.sablier.com/guides/lockup/examples/create-stream/lockup-linear

Provides the complete source code for the LockupLinearStreamCreator contract, demonstrating the implementation of linear streams with lockup functionalities. This code can be referenced for detailed understanding and integration.

```solidity
https://github.com/sablier-labs/examples/blob/main/lockup/LockupLinearStreamCreator.sol
```

--------------------------------

### Initialize Program Function (Rust)

Source: https://docs.sablier.com/solana/program-reference/merkle-instant/merkle-instant

Sets up the Sablier Merkle Instant program by defining the fee collector's address and specifying the Chainlink program and SOL/USD feed accounts. This is a one-time initialization step for the program.

```rust
pub fn initialize(
    ctx: Context<Initialize>,
    fee_collector: Pubkey,
    chainlink_program: Pubkey,
    chainlink_sol_usd_feed: Pubkey,
) -> Result<()>
```

--------------------------------

### Solidity: Set Broker Parameter

Source: https://docs.sablier.com/guides/lockup/examples/create-stream/lockup-tranched

Configures the `broker` parameter for the stream creation. In this example, it's set to a zero address and zero fee, as it's typically used by front-end applications to charge a percentage fee of the `totalAmount`.

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

--------------------------------

### Get Account Balance for a Stream - Solidity & Javascript

Source: https://docs.sablier.com/reference/legacy/contracts/constant-functions

Returns the real-time balance of a specific account for a given stream ID. This indicates the amount of tokens available for withdrawal, not the total tokens streamed. Essential for tracking user balances within streams. Examples provided for Solidity and Javascript.

```solidity
function balanceOf(uint256 streamId, address who) view returns (uint256)
```

```solidity
Sablier sablier = Sablier(0xabcd...);
uint256 streamId = 42;
uint256 senderAddress = 0xcdef...;
uint256 balance = sablier.balanceOf(streamId, senderAddress);
```

```javascript
const sablier = new ethers.Contract(0xabcd..., sablierABI, signerOrProvider);
const streamId = 42;
const senderAddress = 0xcdef...;
const balance = await sablier.balanceOf(streamId, senderAddress);
```

--------------------------------

### Full Merkle Campaign Creator Example

Source: https://docs.sablier.com/guides/airdrops/examples/create-campaign

Provides the complete Solidity code for the Merkle Creator contract, demonstrating how to set up and launch a Merkle Airdrop campaign. This code can be found on GitHub for detailed review and integration.

```solidity
https://github.com/sablier-labs/examples/blob/main/airdrops/MerkleCreator.sol
```

--------------------------------

### Get Stream Properties - Solidity & Javascript

Source: https://docs.sablier.com/reference/legacy/contracts/constant-functions

Retrieves all properties associated with a given stream ID. This includes sender, recipient, token address, start and stop times, remaining balance, and rate per second. Useful for monitoring and managing active streams. Provided for both Solidity and Ethers.js.

```solidity
function getStream(uint256 streamId) view returns (address sender, address recipient, address tokenAddress, uint256 balance, uint256 startTime, uint256 stopTime, uint256 remainingBalance, uint256 ratePerSecond)
```

```solidity
Sablier sablier = Sablier(0xabcd...);
uint256 streamId = 42;
(uint256 sender, uint256 recipient, uint256 deposit, address tokenAddress, uint256 startTime, uint256 stopTime, uint256 remainingBalance, uint256 ratePerSecond) = sablier.getStream(streamId);
```

```javascript
const sablier = new ethers.Contract(0xabcd..., sablierABI, signerOrProvider);
const streamId = 42;
const stream = await sablier.getStream(streamId);
```

--------------------------------

### Sablier V2 Lockup Strategy Configuration (JSON)

Source: https://docs.sablier.com/guides/snapshot-voting

Example JSON configuration for a Sablier V2 Lockup strategy in Snapshot. This setup defines the token address, symbol, decimals, and the policy to be used for calculating voting power. It also mentions common Snapshot parameters like Network, Snapshot block, and Addresses.

```json
{
  "address": "0x97cb342cf2f6ecf48c1285fb8668f5a4237bf862",
  "symbol": "DAI",
  "decimals": 18,
  "policy": "withdrawable-recipient" // recommended,
}
```

--------------------------------

### Rust: CreateCampaign Instruction Accounts for Sablier

Source: https://docs.sablier.com/solana/program-reference/merkle-instant/context%20accounts

Outlines the accounts required for the 'CreateCampaign' instruction, such as the creator, token mint, campaign data, campaign ATA, and program interfaces for token and system operations.

```rust
pub creator: Signer<'info>,
pub airdrop_token_mint: Box<InterfaceAccount<'info, Mint>>,
pub campaign: Box<Account<'info, Campaign>>,
pub campaign_ata: Box<InterfaceAccount<'info, TokenAccount>>,
pub airdrop_token_program: Interface<'info, TokenInterface>,
pub associated_token_program: Program<'info, AssociatedToken>,
pub system_program: Program<'info, System>
```

--------------------------------

### API Overview

Source: https://docs.sablier.com/llms

General overview of the Sablier API.

```APIDOC
## API Overview

This documentation has been automatically generated from the GraphQL schema, with details on available enums, input types, and query capabilities.
```

--------------------------------

### Tranche_variance_order_by Input Type

Source: https://docs.sablier.com/api/lockup/graphql/envio/inputs/tranche-variance-order-by

Defines the sorting options for Tranche variance, allowing ordering by amount, end amount, end time, position, start amount, and start time using the 'order_by' enum.

```APIDOC
## Tranche_variance_order_by

### Description
This input type is used to specify the ordering for Tranche variance calculations across various columns. It supports ordering by `amount`, `endAmount`, `endTime`, `position`, `startAmount`, and `startTime`.

### Method
N/A (This is a GraphQL input type, not a REST endpoint)

### Endpoint
N/A

### Parameters
#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```graphql
{
  tranche(orderBy: { Tranche_variance_order_by: { amount: asc } }) {
    # fields
  }
}
```

### Response
#### Success Response (200)
N/A (This is a GraphQL input type)

#### Response Example
N/A
```

--------------------------------

### Set up FlowBatchable Contract

Source: https://docs.sablier.com/guides/flow/examples/batchable

Declares the Solidity version, imports necessary interfaces, and defines constants for USDC and SablierFlow contracts. Contract addresses are hardcoded for demonstration and may need to be flexible in production.

```solidity
pragma solidity >=0.8.22;

import {IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ISablierFlow } from "./ISablierFlow.sol";
import { UD21x18 } from "./types/UD21x18.sol";

contract FlowBatchable {
    IERC20 public constant USDC = IERC20(0xf08A50178dfcDe18524640EA6618a1f965821715);
    ISablierFlow public constant FLOW = ISablierFlow(0x52ab22e769E31564E17D524b683264B65662A014);
}
```

--------------------------------

### UserTransaction Stream Cursor Input

Source: https://docs.sablier.com/api/flow/graphql/envio/inputs/user-transaction-stream-cursor-value-input

Defines the input structure for starting a stream of user transactions. This is used to specify the starting point for streaming data, ensuring that new transactions are captured from a particular block, timestamp, or other identifier.

```APIDOC
## UserTransaction_stream_cursor_value_input

### Description
Initial value of the column from where the streaming should start.

### Method
N/A (Input Type Definition)

### Endpoint
N/A (Input Type Definition)

### Parameters

#### Request Body

- **block** (numeric) - Optional - The block number from where to start streaming.
- **db_write_timestamp** (timestamp) - Optional - The database write timestamp from where to start streaming.
- **fee** (float8) - Optional - The transaction fee associated with the user transaction.
- **hash** (String) - Optional - The unique hash of the user transaction.
- **id** (String) - Optional - The unique identifier of the user transaction.
- **isAirdropClaim** (Boolean) - Optional - Indicates if the transaction is an airdrop claim.
- **timestamp** (numeric) - Optional - The timestamp of the user transaction.
- **user_id** (String) - Optional - The identifier of the user associated with the transaction.

### Request Example
```json
{
  "block": 12345,
  "timestamp": 1678886400
}
```

### Response

#### Success Response (N/A)
This is an input type definition and does not have a direct success response.

#### Response Example
N/A
```

--------------------------------

### Create and Load Environment Variables for Lockup Deployment

Source: https://docs.sablier.com/guides/custom-deployments

Creates a .env file with necessary deployment variables and loads them into the shell. These variables include deployer address, Etherscan API key, private key, RPC URL, and verifier URL.

```bash
touch .env
EOA="DEPLOYER ADDRESS"
ETHERSCAN_API_KEY="EXPLORER API KEY"
PRIVATE_KEY="PRIVATE KEY OF DEPLOYER ADDRESS"
RPC_URL="RPC ENDPOINT URL"
VERIFIER_URL="EXPLORER VERIFICATION URL"
source .env
```

--------------------------------

### Example: Creating a Flow Stream (JavaScript)

Source: https://docs.sablier.com/llms

This snippet illustrates how to create a new Flow stream using Sablier. It requires importing the CodeBlock component for rendering. The actual stream creation logic would involve calling relevant Sablier SDK functions with parameters like recipient, amount, and duration.

```javascript
import CodeBlock from "@theme/CodeBlock";

// Assume 'sablier' is an initialized Sablier SDK instance
// Assume 'sender', 'recipient', 'token', 'amount', 'duration' are defined variables

// Example placeholder for stream creation logic
// async function createFlowStream() {
//   const stream = await sablier.createStream({
//     sender, recipient, token, amount, duration
//   });
//   console.log('Stream created:', stream);
// }

<CodeBlock language="javascript">
{
  `// To create a Flow stream:\n// const stream = await sablier.createStream({\n//   sender: '0x...',\n//   recipient: '0x...',\n//   token: '0x...', // Token address\n//   amount: 1000000, // Total amount to stream\n//   duration: 86400 // Duration in seconds\n// });\n// console.log('Stream created:', stream);`
}
</CodeBlock>
```

--------------------------------

### Compile Contract with Forge (Bash)

Source: https://docs.sablier.com/guides/flow/examples/local-environment

This command compiles the Solidity smart contracts using the Forge build tool. Successful compilation indicates that the contract syntax is correct and all dependencies are met. It verifies the contract's readiness for testing and deployment.

```bash
forge build
```

--------------------------------

### Rust: Initialize Instruction Accounts for Sablier

Source: https://docs.sablier.com/solana/program-reference/merkle-instant/context%20accounts

Defines the accounts for the 'Initialize' instruction, including the initializer, the treasury account for fees, and the system program.

```rust
pub initializer: Signer<'info>,
pub treasury: Box<Account<'info, Treasury>>,
pub system_program: Program<'info, System>
```

--------------------------------

### Set Unlock Amounts at Start and Cliff

Source: https://docs.sablier.com/guides/lockup/examples/create-stream/lockup-linear

Defines the amounts to be unlocked at the stream's start time and at the cliff time using a struct. These values are crucial for managing the release schedule of tokens within the stream.

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

--------------------------------

### Create and Load .env File for Flow Deployment

Source: https://docs.sablier.com/guides/custom-deployments

Creates a `.env` file and populates it with necessary deployment variables such as API keys, private keys, and RPC endpoints. Subsequently, it loads these variables into the current shell session.

```bash
touch .env
# Add variables to .env file:
# ETH_FROM="DEPLOYER ADDRESS"
# ETHERSCAN_API_KEY="EXPLORER API KEY"
# PRIVATE_KEY="PRIVATE KEY OF DEPLOYER ADDRESS"
# RPC_URL="RPC ENDPOINT URL"
# VERIFIER_URL="EXPLORER VERIFICATION URL"
source .env
```

--------------------------------

### Create Airdrop Campaign

Source: https://docs.sablier.com/solana/program-reference/merkle-instant/merkle-instant

Creates a new Merkle Instant airdrop campaign, specifying distribution details and metadata.

```APIDOC
## POST /create_campaign

### Description
Creates a Merkle Instant airdrop campaign.

### Method
POST

### Endpoint
/create_campaign

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **merkle_root** ([u8; 32]) - Required - The Merkle root of the claim data.
- **campaign_start_time** (u64) - Required - The time when the campaign starts, in seconds since the Unix epoch.
- **expiration_time** (u64) - Required - The time when the campaign expires, in seconds since the Unix epoch. A value of zero means the campaign does not expire.
- **name** (String) - Required - The name of the campaign.
- **ipfs_cid** (String) - Optional - The content identifier for indexing the campaign on IPFS. An empty value may break some UI features that depend upon the IPFS CID.
- **aggregate_amount** (u64) - Required - The total amount of tokens to be distributed to all recipients.
- **recipient_count** (u32) - Required - The total number of recipient addresses eligible for the airdrop.

### Request Example
```json
{
  "merkle_root": "0x1122334455667788...",
  "campaign_start_time": 1678886400,
  "expiration_time": 1678886400,
  "name": "Spring Airdrop 2023",
  "ipfs_cid": "Qm...",
  "aggregate_amount": 1000000000,
  "recipient_count": 1000
}
```

### Response
#### Success Response (200)
- **message** (string) - Success message indicating the campaign was created.

#### Response Example
```json
{
  "message": "Campaign created successfully."
}
```

--------------------------------

### ISablierMerkleBase Interface Documentation

Source: https://docs.sablier.com/reference/airdrops/contracts/interfaces/interface

This section provides detailed documentation for each function within the ISablierMerkleBase smart contract interface.

```APIDOC
## ISablierMerkleBase

_Common interface between Merkle Lockups and Merkle Instant._

### EXPIRATION

The cut-off point for the campaign, as a Unix timestamp. A value of zero means there is no expiration.

_This is an immutable state variable._

#### Method
GET

#### Endpoint
/EXPIRATION

#### Response
##### Success Response (200)
- **uint40** - The expiration timestamp.

### FACTORY

Retrieves the address of the factory contract.

#### Method
GET

#### Endpoint
/FACTORY

#### Response
##### Success Response (200)
- **address** - The address of the factory contract.

### FEE

Retrieves the minimum fee required to claim the airdrop, which is paid in the native token of the chain, e.g. ETH for Ethereum Mainnet.

#### Method
GET

#### Endpoint
/FEE

#### Response
##### Success Response (200)
- **uint256** - The minimum fee amount.

### MERKLE_ROOT

The root of the Merkle tree used to validate the proofs of inclusion.

_This is an immutable state variable._

#### Method
GET

#### Endpoint
/MERKLE_ROOT

#### Response
##### Success Response (200)
- **bytes32** - The Merkle root.

### TOKEN

The ERC-20 token to distribute.

_This is an immutable state variable._

#### Method
GET

#### Endpoint
/TOKEN

#### Response
##### Success Response (200)
- **IERC20** - The ERC-20 token contract interface.

### campaignName

Retrieves the name of the campaign.

#### Method
GET

#### Endpoint
/campaignName

#### Response
##### Success Response (200)
- **string memory** - The campaign name.

### getFirstClaimTime

Returns the timestamp when the first claim is made.

#### Method
GET

#### Endpoint
/getFirstClaimTime

#### Response
##### Success Response (200)
- **uint40** - The timestamp of the first claim.

### hasClaimed

Returns a flag indicating whether a claim has been made for a given index.

_Uses a bitmap to save gas._

#### Method
GET

#### Endpoint
/hasClaimed

#### Parameters
##### Query Parameters
- **index** (uint256) - Required - The index of the recipient to check.

#### Response
##### Success Response (200)
- **bool** - True if the claim has been made, false otherwise.

### hasExpired

Returns a flag indicating whether the campaign has expired.

#### Method
GET

#### Endpoint
/hasExpired

#### Response
##### Success Response (200)
- **bool** - True if the campaign has expired, false otherwise.

### ipfsCID

The content identifier for indexing the campaign on IPFS.

#### Method
GET

#### Endpoint
/ipfsCID

#### Response
##### Success Response (200)
- **string memory** - The IPFS CID.

### shape

Retrieves the shape of the lockup stream that the campaign produces upon claiming.

#### Method
GET

#### Endpoint
/shape

#### Response
##### Success Response (200)
- **string memory** - The shape of the lockup stream.

### claim

Makes the claim.

Depending on the Merkle campaign, it either transfers tokens to the recipient or creates a Lockup stream with an NFT minted to the recipient. Requirements:

- The campaign must not have expired.
- The stream must not have been claimed already.
- The Merkle proof must be valid.
- The `msg.value` must not be less than `FEE`.

#### Method
POST

#### Endpoint
/claim

#### Parameters
##### Request Body
- **index** (uint256) - Required - The index of the recipient in the Merkle tree.
- **recipient** (address) - Required - The address of the airdrop recipient.
- **amount** (uint128) - Required - The amount of ERC-20 tokens to be transferred to the recipient.
- **merkleProof** (bytes32[]) - Required - The proof of inclusion in the Merkle tree.

#### Request Example
```json
{
  "index": 1,
  "recipient": "0x...",
  "amount": 1000,
  "merkleProof": ["0x..."]
}
```

#### Response
##### Success Response (200)
- This endpoint does not return a specific success response body, but indicates successful execution.

### clawback

Claws back the unclaimed tokens from the campaign.

Emits a [Clawback](/docs/reference/airdrops/contracts/interfaces/interface.ISablierMerkleBase.md#clawback) event. Requirements:

- `msg.sender` must be the admin.
- No claim must be made, OR The current timestamp must not exceed 7 days after the first claim, OR The campaign must be expired.

#### Method
POST

#### Endpoint
/clawback

#### Parameters
##### Request Body
- **to** (address) - Required - The address to receive the tokens.
- **amount** (uint128) - Required - The amount of tokens to claw back.

#### Request Example
```json
{
  "to": "0x...",
  "amount": 500
}
```

#### Response
##### Success Response (200)
- This endpoint does not return a specific success response body, but indicates successful execution.
```

--------------------------------

### Configure Lockup Linear Vesting Schedule

Source: https://docs.sablier.com/guides/airdrops/examples/create-campaign

Sets up the vesting schedule for a Lockup Linear campaign. This includes defining the start time, initial percentages unlocked, cliff duration, cliff percentage unlocked after the cliff, and the total duration of the vesting period.

```solidity
MerkleLL.Schedule memory schedule = MerkleLL.Schedule({
    startTime: 0,
    startPercentage: ud2x18(0.01e18),
    cliffDuration: 30 days,
    cliffPercentage: ud2x18(0.01e18),
    totalDuration: 90 days
});
```

--------------------------------

### Campaign Filtering

Source: https://docs.sablier.com/api/airdrops/graphql/the-graph/inputs/campaign-filter

Filter campaigns by IPFS CID and position. Supports various comparison operators for IPFS CID (equals, not equals, in list, not in list, contains, not contains, starts with, not starts with, ends with, not ends with) and exact match or not equals for position.

```APIDOC
## GET /websites/sablier/campaigns

### Description
Retrieves a list of campaigns, with optional filtering based on IPFS CID and position.

### Method
GET

### Endpoint
/websites/sablier/campaigns

### Parameters
#### Query Parameters
- **filter.ipfsCID_gte** (String) - Optional - Filters campaigns where ipfsCID is greater than or equal to the provided value.
- **filter.ipfsCID_lte** (String) - Optional - Filters campaigns where ipfsCID is less than or equal to the provided value.
- **filter.ipfsCID_in** ([String!]) - Optional - Filters campaigns where ipfsCID is present in the provided list.
- **filter.ipfsCID_not_in** ([String!]) - Optional - Filters campaigns where ipfsCID is not present in the provided list.
- **filter.ipfsCID_contains** (String) - Optional - Filters campaigns where ipfsCID contains the provided substring.
- **filter.ipfsCID_contains_nocase** (String) - Optional - Filters campaigns where ipfsCID contains the provided substring, case-insensitive.
- **filter.ipfsCID_not_contains** (String) - Optional - Filters campaigns where ipfsCID does not contain the provided substring.
- **filter.ipfsCID_not_contains_nocase** (String) - Optional - Filters campaigns where ipfsCID does not contain the provided substring, case-insensitive.
- **filter.ipfsCID_starts_with** (String) - Optional - Filters campaigns where ipfsCID starts with the provided prefix.
- **filter.ipfsCID_starts_with_nocase** (String) - Optional - Filters campaigns where ipfsCID starts with the provided prefix, case-insensitive.
- **filter.ipfsCID_not_starts_with** (String) - Optional - Filters campaigns where ipfsCID does not start with the provided prefix.
- **filter.ipfsCID_not_starts_with_nocase** (String) - Optional - Filters campaigns where ipfsCID does not start with the provided prefix, case-insensitive.
- **filter.ipfsCID_ends_with** (String) - Optional - Filters campaigns where ipfsCID ends with the provided suffix.
- **filter.ipfsCID_ends_with_nocase** (String) - Optional - Filters campaigns where ipfsCID ends with the provided suffix, case-insensitive.
- **filter.ipfsCID_not_ends_with** (String) - Optional - Filters campaigns where ipfsCID does not end with the provided suffix.
- **filter.ipfsCID_not_ends_with_nocase** (String) - Optional - Filters campaigns where ipfsCID does not end with the provided suffix, case-insensitive.
- **filter.position** (BigInt) - Optional - Filters campaigns where position exactly matches the provided value.
- **filter.position_not** (BigInt) - Optional - Filters campaigns where position does not match the provided value.

### Request Example
```json
{
  "example": "GET /websites/sablier/campaigns?filter.ipfsCID_contains=QmXYZ...&filter.position=123"
}
```

### Response
#### Success Response (200)
- **campaigns** ([Campaign]) - A list of campaign objects matching the filter criteria.

#### Response Example
```json
{
  "example": "{\"campaigns\": [{\"id\": \"campaign1\", \"ipfsCID\": \"QmXYZ...\", \"position\": 123}] }"
}
```
```

--------------------------------

### Sablier Interface Overview

Source: https://docs.sablier.com/llms

An overview of the Sablier Interface, a web application for interacting with the Sablier Protocol.

```APIDOC
## Sablier Interface Overview

### Description
Provides a general overview of the Sablier Interface, its functionalities, and how users can interact with the Sablier Protocol through this web application.

### Method
GET

### Endpoint
/apps/features/overview.md

### Parameters
None

### Request Example
(No direct request example, access via browser)

### Response
#### Success Response (200)
- **content** (string) - Overview of the Sablier Interface.

#### Response Example
(Content describes the purpose and basic features of the interface.)
```

--------------------------------

### event_sync_state_stream_cursor_value_input

Source: https://docs.sablier.com/api/airdrops/graphql/envio/inputs/event-sync-state-stream-cursor-value-input

The `event_sync_state_stream_cursor_value_input` type specifies the initial value of the column from where the streaming should start.

```APIDOC
## GraphQL Input: event_sync_state_stream_cursor_value_input

### Description
Initial value of the column from where the streaming should start.

### Type
Input Object

### Fields

#### block_number
- **Type**: `Int`
- **Description**: The block number to start streaming from.

#### block_timestamp
- **Type**: `Int`
- **Description**: The block timestamp to start streaming from.

#### chain_id
- **Type**: `Int`
- **Description**: The chain ID to specify the network for streaming.

#### is_pre_registering_dynamic_contracts
- **Type**: `Boolean`
- **Description**: Indicates if pre-registering dynamic contracts is active.

#### log_index
- **Type**: `Int`
- **Description**: The log index to start streaming from within a block.
```

--------------------------------

### Run Fork Test for Stream Creator (Bash)

Source: https://docs.sablier.com/guides/flow/examples/local-environment

This command executes tests for the StreamCreator contract against a fork of Ethereum Mainnet. It leverages Foundry's native forking capabilities to test interactions with live on-chain protocols like Sablier. Ensure you have an RPC endpoint configured for forking.

```bash
forge test
```

--------------------------------

### persisted_state_stream_cursor_value_input

Source: https://docs.sablier.com/api/lockup/graphql/envio/inputs/persisted-state-stream-cursor-value-input

The persisted_state_stream_cursor_value_input defines the parameters for specifying the initial value of a column from where streaming should start.

```APIDOC
## persisted_state_stream_cursor_value_input

### Description
Initial value of the column from where the streaming should start.

### Method
N/A (GraphQL Input Type)

### Endpoint
N/A (GraphQL Input Type)

### Parameters
#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
```json
{
  "abi_files_hash": "string",
  "config_hash": "string",
  "envio_version": "string",
  "handler_files_hash": "string",
  "id": 0,
  "schema_hash": "string"
}
```

### Response
#### Success Response (200)
N/A (GraphQL Input Type)

#### Response Example
```json
{
  "message": "Response depends on the specific GraphQL query."
}
```

### Fields
#### abi_files_hash (String) - Optional - Hash of the ABI files.
#### config_hash (String) - Optional - Hash of the configuration files.
#### envio_version (String) - Optional - Version of the Envio environment.
#### handler_files_hash (String) - Optional - Hash of the handler files.
#### id (Int) - Optional - Identifier for the cursor state.
#### schema_hash (String) - Optional - Hash of the schema files.
```

--------------------------------

### nextStreamId

Source: https://docs.sablier.com/reference/flow/contracts/interfaces/interface

Gets the next available stream ID. This is a counter for stream IDs.

```APIDOC
## GET /websites/sablier/nextStreamId

### Description
Counter for stream ids.

### Method
GET

### Endpoint
/websites/sablier/nextStreamId

### Response
#### Success Response (200)
- **nextStreamId** (uint256) - The next stream ID.

#### Response Example
```json
{
  "nextStreamId": 100
}
```
```

--------------------------------

### Retrieve Campaign Details (Rust)

Source: https://docs.sablier.com/solana/program-reference/merkle-instant/merkle-instant

Retrieves the campaign details by taking a CampaignView context. It expects a 'campaign' account to store the campaign information.

```rust
pub fn campaign_view(ctx: Context<CampaignView>) -> Result<state::Campaign>
```

--------------------------------

### Compile Sablier Legacy Contracts with Yarn and Truffle

Source: https://docs.sablier.com/guides/legacy/codebase

This bash script demonstrates how to clone the Sablier Legacy repository, bootstrap dependencies, and compile the smart contracts using Yarn and Truffle. The resulting ABI artifact, Sablier.json, will be located in the build/contracts folder.

```bash
git clone git@github.com/sablier-labs/legacy.git sablier-legacy
cd ./sablier-legacy
yarn bootstrap
cd ./packages/protocol
truffle compile
```
Tokens:
Raw