Awesome

Yearn v2 Strategy Foundry Mix

For v3 foundry strategy mix see here

What you'll find here

Basic Solidity Smart Contract for creating your own Yearn Strategy (Strategy.sol)
Configured github template with Foundry framework for starting your yearn strategy project.
Sample test suite. (tests)

How does it work for the User

Let's say Alice holds 100 DAI and wants to start earning yield % on them.

For this Alice needs to DAI.approve(vault.address, 100).

Then Alice will call Vault.deposit(100).

Vault will then transfer 100 DAI from Alice to itself, and mint Alice the corresponding shares.

Alice can then redeem those shares using Vault.withdrawAll() for the corresponding DAI balance (exchanged at Vault.pricePerShare()).

Installation and Setup

To install with Foundry.
Fork this repository (easier) or create a new repository using it as template. Create from template
Clone your newly created repository recursively to include modules.

git clone --recursive https://github.com/myuser/foundry-yearn-strategy

cd foundry-yearn-strategy

NOTE: if you create from template you may need to run the following command to fetch the git submodules (.gitmodules for exact releases) git submodule init && git submodule update

Build the project.

make build

Sign up for Infura and generate an API key and copy your RPC url. Store it in the ETH_RPC_URL environment variable. NOTE: you can use other services.
Use .env file
Make a copy of .env.example
Add the values for ETH_RPC_URL, ETHERSCAN_API_KEY and other example vars NOTE: If you set up a global environment variable, that will take precedence.
Run tests

make test

Basic Use

To deploy the demo Yearn Strategy in a development environment:

TODO

Implementing Strategy Logic

src/Strategy.sol is where you implement your own logic for your strategy. In particular:

Create a descriptive name for your strategy via Strategy.name().
Invest your want tokens via Strategy.adjustPosition().
Take profits and report losses via Strategy.prepareReturn().
Unwind enough of your position to payback withdrawals via Strategy.liquidatePosition().
Unwind all of your positions via Strategy.exitPosition().
Fill in a way to estimate the total want tokens managed by the strategy via Strategy.estimatedTotalAssets().
Migrate all the positions managed by your strategy via Strategy.prepareMigration().
Make a list of all position tokens that should be protected against movements via Strategy.protectedTokens().

Testing

Tests run in fork environment, you need to complete Installation and Setup step 6 to be able to run these commands.

make test

Run tests with traces (very useful)

make trace

Run specific test contract (e.g. test/StrategyOperation.t.sol)

make test-contract contract=StrategyOperationsTest

Run specific test contract with traces (e.g. test/StrategyOperation.t.sol)

make trace-contract contract=StrategyOperationsTest

See here for some tips on testing Testing Tips

Deploying Contracts

You can Deploy and verify your strategies if PRIV_KEY and ETHERSCAN_API_KEY are both set in the .env by using the command

make deploy

Before deploying, update the constructor-args variable within the Makefile to include any parameters applicable. Make sure to seperate each argument only by a space, no commas.

The deploy script is coded to deploy the "Strategy" contract within the Strategy.sol file. This can be updated by simply updating to src/YourContract.sol:YourContract.

GitHub Actions

This template comes with GitHub Actions pre-configured. Your contracts will be linted and tested on every push to master and develop branch.

Note though that to make this work, you must set your INFURA_API_KEY and your ETHERSCAN_API_KEY as GitHub secrets.