Comparar texto

Encontre a diferença entre dois arquivos de texto

Editor live

Recolher inalteradas

Sem quebra de linha

Layout

Nível de detalhe

Realce de sintaxe

Diffchecker Desktop A maneira mais segura de usar o Diffchecker. Obtenha o aplicativo Diffchecker Desktop: seus diffs nunca saem do seu computador!Obter Desktop

Lockup vs Flow docs

Criado ano passadoO diff nunca expira

45 remoções

Linhas
Total
Removido

Caracteres
Total
Removido

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

177 linhas

41 adições

Linhas
Total
Adicionado

Caracteres
Total
Adicionado

Para continuar usando este recurso, atualize para Diffchecker Pro Ver preços

175 linhas

---

id: "local-environment"

sidebar_position: 1

title: "Configure Your Local Environment"

---

In this guide, we will go through the steps to set up a local development environment for building onchain integrations

with Lockup. We will use Foundry to install Lockup as a dependency, and run a few simple tests.

with Flow. We will use Foundry to install Flow as a dependency, and run a few simple tests.

At the end, you’ll have a development environment set up that you can use to build the rest of the examples under

"Guides", or start your own integration project.

## Pre-requisites

You will need the following software on your machine:

- [Git](https://git-scm.com/downloads)

- [Foundry](https://github.com/foundry-rs/foundry)

- [Node.js](https://nodejs.org/en/download)

- [Bun](https://bun.sh)

In addition, familiarity with [Ethereum](https://ethereum.org/) and [Solidity](https://soliditylang.org/) is requisite.

## Set up using Lockup integration template

## Set up using Flow integration template

We put together a template repository that you can use to get started quickly. This repository features a basic project

structure, pre-configured Lockup imports, and a selection of sample contracts and tests.

structure, pre-configured Flow imports, and a selection of sample contracts and tests.

:::tip

Make sure you are using the latest version of Foundry by running `foundryup`.

:::

To install the template, simply execute the following commands:

```shell

$ mkdir lockup-integration-template

$ mkdir flow-integration-template

$ cd lockup-integration-template

$ cd flow-integration-template

$ forge init --template sablier-labs/lockup-integration-template

$ forge init --template sablier-labs/flow-integration-template

$ bun install

```

Then, hop to the [Run a Fork Test](/guides/lockup/examples/local-environment#run-a-fork-test) section to complete your

Then, hop to the [Run a Fork Test](/guides/flow/examples/local-environment#run-a-fork-test) section to complete your set

set up and start developing.

up and start developing.

## Set up using Foundry template

Foundry is a popular development toolkit for Ethereum projects, which we have used to build the Sablier Protocols. For

the purposes of this guide, Foundry will provide us with the tooling needed to compile and test our contracts.

Let's use this command to spin up a new Foundry project:

```shell

$ forge init my-project

$ cd my-project

```

:::note

You might notice that the CLI is `forge` rather than `foundry`. This is because Foundry is a toolkit, and `forge` is

just one of the tools that comes with it.

:::

Once the initialization completes, take a look around at what got set up:

```tree

├── foundry.toml

├── script

├── src

└── test

```

The folder structure should be intuitive:

- `src` is where you'll write Solidity contracts

- `test` is where you'll write tests (also in Solidity)

- `script` is where you'll write scripts to perform actions like deploying contracts (you guessed it, in Solidity)

- `foundry.toml` is where you can configure your Foundry settings, which we will leave as is in this guide

## Install Lockup npm packages

## Install Flow npm package

Let's install the Lockup Node.js packages using Bun:

Let's install the Flow Node.js packages using Bun:

```shell

$ bun add @sablier/v2-core @sablier/v2-periphery

$ bun add @sablier/flow

```

Bun will download the Lockup contracts, along with their dependencies, and put them in the `node_modules` directory.

Bun will download the Flow contracts, along with their dependencies, and put them in the `node_modules` directory.

Let's remap the package names to point to the installed contracts. This step is required so that the Solidity compiler

can find the Lockup contracts when you import them:

can find the Flow contracts when you import them:

```shell

$ echo "@sablier/v2-core=node_modules/@sablier/v2-core/" >> remappings.txt

$ echo "@sablier/flow=node_modules/@sablier/flow/" >> remappings.txt

$ echo "@sablier/v2-periphery=node_modules/@sablier/v2-periphery/" >> remappings.txt

$ echo "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/" >> remappings.txt

$ echo "@prb/math/=node_modules/@prb/math/" >> remappings.txt

```

That's it! You should now have a functional development environment to start building onchain Lockup integrations. Let's

That's it! You should now have a functional development environment to start building onchain Flow integrations. Let's

run a quick test to confirm everything is set up properly.

## Write your first contract

Delete the `src/Counter.sol` and `test/Counter.t.sol` files generated by Forge, and create two new files:

Delete the `src/Counter.sol` and `test/Counter.t.sol` files generated by Forge, and create a new file:

`src/StreamCreator.sol` and `test/StreamCreator.t.sol`.

`src/FlowStreamCreator.sol`.

Paste the following code into `src/StreamCreator.sol` (a detailed explanation of this contract can be found

Paste the following code into `src/FlowStreamCreator.sol`.

[here](/guides/lockup/examples/create-stream/lockup-linear)):

```solidity reference title="Lockup Linear Stream Creator"

```solidity reference title="Flow Stream Creator"

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

https://github.com/sablier-labs/flow-integration-template/blob/main/src/FlowStreamCreator.sol

```

Let's use Forge to compile this contract:

```shell

$ forge build

```

If the contract was compiled correctly, you should see this message:

```text

[⠢] Compiling...

[⠰] Compiling { number } files with { compiler }

[⠒] Solc { compiler } finished in { time }

Compiler run successful

```

:::info

The minimum Solidity version supported by the Lockup contracts is v0.8.13.

The minimum Solidity version supported by the Flow contracts is v0.8.22.

:::

## Run a fork test

Foundry offers native support for running tests against a fork of Ethereum Mainnet, testnets and L2s, which is useful

when building and testing integrations with onchain protocols like Sablier. In practice, this enables you to access all

Sablier contracts deployed on Ethereum, and use them for testing your integration.

As a prerequisite, you will need an RPC that supports forking. A good solution for this is

[Alchemy](https://alchemy.com/), as it includes forking in its free tier plan.

Once you have obtained your RPC, you can proceed to run the following test:

```solidity reference title="Stream Creator Test"

https://github.com/sablier-labs/examples/blob/main/lockup/core/LockupStreamCreator.t.sol

https://github.com/sablier-labs/flow-integration-template/blob/main/test/FlowStreamCreator.t.sol

```

You can run the test using Forge:

```shell

$ forge test

```

If the test passed, you should see a message like this:

```text

Ran 2 tests for lockup/core/LockupStreamCreator.t.sol:LockupStreamCreatorTest

Ran 2 tests for test/FlowStreamCreator.t.sol:FlowStreamCreatorTest

[PASS] test_LockupDynamicStreamCreator() (gas: 273719)

[PASS] test_CreateFlowStream() (gas: 147915)

[PASS] test_LockupLinearStreamCreator() (gas: 186388)

[PASS] test_CreateFlowStreamAndDeposit() (gas: 224823)

Suite result: ok. 2 passed; 0 failed; 0 skipped; finished in 6.34s (5.80s CPU time)

Suite result: ok. 2 passed; 0 failed; 0 skipped; finished in 986.20ms (4.16ms CPU time)

```

## Next steps

Congratulations! Your environment is now configured, and you are prepared to start building. Explore the guides section

to discover various Lockup features available for integration. Remember to include all contracts (`.sol` files) in the

to discover various Flow features available for integration. Remember to include all contracts (`.sol` files) in

`src` folder and their corresponding tests in the `test` folder.

the`src` folder and their corresponding tests in the `test` folder.

As far as Foundry is concerned, there is much more to uncover. If you want to learn more about it, check out the

[Foundry Book](https://book.getfoundry.sh/), which contains numerous examples and tutorials. A deep understanding of

Foundry will enable you to create more sophisticated integrations with Lockup.

Foundry will enable you to create more sophisticated integrations with Flow.

Diferenças salvas

Texto original

Abrir arquivo

---
id: "local-environment"
sidebar_position: 1
title: "Configure Your Local Environment"
---

In this guide, we will go through the steps to set up a local development environment for building onchain integrations
with Lockup. We will use Foundry to install Lockup as a dependency, and run a few simple tests.

At the end, you’ll have a development environment set up that you can use to build the rest of the examples under
"Guides", or start your own integration project.

## Pre-requisites

You will need the following software on your machine:

- [Git](https://git-scm.com/downloads)
- [Foundry](https://github.com/foundry-rs/foundry)
- [Node.js](https://nodejs.org/en/download)
- [Bun](https://bun.sh)

In addition, familiarity with [Ethereum](https://ethereum.org/) and [Solidity](https://soliditylang.org/) is requisite.

## Set up using Lockup integration template

We put together a template repository that you can use to get started quickly. This repository features a basic project
structure, pre-configured Lockup imports, and a selection of sample contracts and tests.

:::tip

Make sure you are using the latest version of Foundry by running `foundryup`.

:::

To install the template, simply execute the following commands:

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

Then, hop to the [Run a Fork Test](/guides/lockup/examples/local-environment#run-a-fork-test) section to complete your
set up and start developing.

## Set up using Foundry template

Foundry is a popular development toolkit for Ethereum projects, which we have used to build the Sablier Protocols. For
the purposes of this guide, Foundry will provide us with the tooling needed to compile and test our contracts.

Let's use this command to spin up a new Foundry project:

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

:::note

You might notice that the CLI is `forge` rather than `foundry`. This is because Foundry is a toolkit, and `forge` is
just one of the tools that comes with it.

:::

Once the initialization completes, take a look around at what got set up:

```tree
├── foundry.toml
├── script
├── src
└── test
```

The folder structure should be intuitive:

- `src` is where you'll write Solidity contracts
- `test` is where you'll write tests (also in Solidity)
- `script` is where you'll write scripts to perform actions like deploying contracts (you guessed it, in Solidity)
- `foundry.toml` is where you can configure your Foundry settings, which we will leave as is in this guide

## Install Lockup npm packages

Let's install the Lockup Node.js packages using Bun:

```shell
$ bun add @sablier/v2-core @sablier/v2-periphery
```

Bun will download the Lockup contracts, along with their dependencies, and put them in the `node_modules` directory.

Let's remap the package names to point to the installed contracts. This step is required so that the Solidity compiler
can find the Lockup contracts when you import them:

```shell
$ echo "@sablier/v2-core=node_modules/@sablier/v2-core/" >> remappings.txt
$ echo "@sablier/v2-periphery=node_modules/@sablier/v2-periphery/" >> remappings.txt
$ echo "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/" >> remappings.txt
$ echo "@prb/math/=node_modules/@prb/math/" >> remappings.txt
```

That's it! You should now have a functional development environment to start building onchain Lockup integrations. Let's
run a quick test to confirm everything is set up properly.

## Write your first contract

Delete the `src/Counter.sol` and `test/Counter.t.sol` files generated by Forge, and create two new files:
`src/StreamCreator.sol` and `test/StreamCreator.t.sol`.

Paste the following code into `src/StreamCreator.sol` (a detailed explanation of this contract can be found
[here](/guides/lockup/examples/create-stream/lockup-linear)):

```solidity reference title="Lockup Linear Stream Creator"
https://github.com/sablier-labs/examples/blob/main/lockup/core/LockupLinearStreamCreator.sol
```

Let's use Forge to compile this contract:

```shell
$ forge build
```

If the contract was compiled correctly, you should see this message:

```text
[⠢] Compiling...
[⠰] Compiling { number } files with { compiler }
[⠒] Solc { compiler } finished in { time }
Compiler run successful
```

:::info

The minimum Solidity version supported by the Lockup contracts is v0.8.13.

:::

## Run a fork test

Foundry offers native support for running tests against a fork of Ethereum Mainnet, testnets and L2s, which is useful
when building and testing integrations with onchain protocols like Sablier. In practice, this enables you to access all
Sablier contracts deployed on Ethereum, and use them for testing your integration.

As a prerequisite, you will need an RPC that supports forking. A good solution for this is
[Alchemy](https://alchemy.com/), as it includes forking in its free tier plan.

Once you have obtained your RPC, you can proceed to run the following test:

```solidity reference title="Stream Creator Test"
https://github.com/sablier-labs/examples/blob/main/lockup/core/LockupStreamCreator.t.sol
```

You can run the test using Forge:

```shell
$ forge test
```

If the test passed, you should see a message like this:

```text
Ran 2 tests for lockup/core/LockupStreamCreator.t.sol:LockupStreamCreatorTest
[PASS] test_LockupDynamicStreamCreator() (gas: 273719)
[PASS] test_LockupLinearStreamCreator() (gas: 186388)
Suite result: ok. 2 passed; 0 failed; 0 skipped; finished in 6.34s (5.80s CPU time)
```

## Next steps

Congratulations! Your environment is now configured, and you are prepared to start building. Explore the guides section
to discover various Lockup features available for integration. Remember to include all contracts (`.sol` files) in the
`src` folder and their corresponding tests in the `test` folder.

As far as Foundry is concerned, there is much more to uncover. If you want to learn more about it, check out the
[Foundry Book](https://book.getfoundry.sh/), which contains numerous examples and tutorials. A deep understanding of
Foundry will enable you to create more sophisticated integrations with Lockup.

Texto alterado

Abrir arquivo

---
id: "local-environment"
sidebar_position: 1
title: "Configure Your Local Environment"
---

In this guide, we will go through the steps to set up a local development environment for building onchain integrations
with Flow. We will use Foundry to install Flow as a dependency, and run a few simple tests.

At the end, you’ll have a development environment set up that you can use to build the rest of the examples under
"Guides", or start your own integration project.

## Pre-requisites

You will need the following software on your machine:

- [Git](https://git-scm.com/downloads)
- [Foundry](https://github.com/foundry-rs/foundry)
- [Node.js](https://nodejs.org/en/download)
- [Bun](https://bun.sh)

In addition, familiarity with [Ethereum](https://ethereum.org/) and [Solidity](https://soliditylang.org/) is requisite.

## Set up using Flow integration template

We put together a template repository that you can use to get started quickly. This repository features a basic project
structure, pre-configured Flow imports, and a selection of sample contracts and tests.

:::tip

Make sure you are using the latest version of Foundry by running `foundryup`.

:::

To install the template, simply execute the following commands:

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

Then, hop to the [Run a Fork Test](/guides/flow/examples/local-environment#run-a-fork-test) section to complete your set
up and start developing.

## Set up using Foundry template

Let's use this command to spin up a new Foundry project:

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

:::note

You might notice that the CLI is `forge` rather than `foundry`. This is because Foundry is a toolkit, and `forge` is
just one of the tools that comes with it.

:::

Once the initialization completes, take a look around at what got set up:

```tree
├── foundry.toml
├── script
├── src
└── test
```

The folder structure should be intuitive:

## Install Flow npm package

Let's install the Flow Node.js packages using Bun:

```shell
$ bun add @sablier/flow
```

Bun will download the Flow contracts, along with their dependencies, and put them in the `node_modules` directory.

Let's remap the package names to point to the installed contracts. This step is required so that the Solidity compiler
can find the Flow contracts when you import them:

```shell
$ echo "@sablier/flow=node_modules/@sablier/flow/" >> remappings.txt
$ echo "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/" >> remappings.txt
$ echo "@prb/math/=node_modules/@prb/math/" >> remappings.txt
```

That's it! You should now have a functional development environment to start building onchain Flow integrations. Let's
run a quick test to confirm everything is set up properly.

## Write your first contract

Delete the `src/Counter.sol` and `test/Counter.t.sol` files generated by Forge, and create a new file:
`src/FlowStreamCreator.sol`.

Paste the following code into `src/FlowStreamCreator.sol`.

```solidity reference title="Flow Stream Creator"
https://github.com/sablier-labs/flow-integration-template/blob/main/src/FlowStreamCreator.sol
```

Let's use Forge to compile this contract:

```shell
$ forge build
```

If the contract was compiled correctly, you should see this message:

```text
[⠢] Compiling...
[⠰] Compiling { number } files with { compiler }
[⠒] Solc { compiler } finished in { time }
Compiler run successful
```

:::info

The minimum Solidity version supported by the Flow contracts is v0.8.22.

:::

## Run a fork test

As a prerequisite, you will need an RPC that supports forking. A good solution for this is
[Alchemy](https://alchemy.com/), as it includes forking in its free tier plan.

Once you have obtained your RPC, you can proceed to run the following test:

```solidity reference title="Stream Creator Test"
https://github.com/sablier-labs/flow-integration-template/blob/main/test/FlowStreamCreator.t.sol
```

You can run the test using Forge:

```shell
$ forge test
```

If the test passed, you should see a message like this:

```text
Ran 2 tests for test/FlowStreamCreator.t.sol:FlowStreamCreatorTest
[PASS] test_CreateFlowStream() (gas: 147915)
[PASS] test_CreateFlowStreamAndDeposit() (gas: 224823)
Suite result: ok. 2 passed; 0 failed; 0 skipped; finished in 986.20ms (4.16ms CPU time)
```

## Next steps

Congratulations! Your environment is now configured, and you are prepared to start building. Explore the guides section
to discover various Flow features available for integration. Remember to include all contracts (`.sol` files) in
the`src` folder and their corresponding tests in the `test` folder.