In-Depth: Implementing A Delta Neutral Long PT Trade
Yield Dev
In this series, I will do an in-depth walkthrough demonstrating how to implement foundry scripts for opening and managing a delta neutral yield farming position with Euler's evc. The specific trade, illustrated here, was described conceptually in this previous post
We will simplify and generalize our scripts, in order that they may be used to create delta neutral yield positions across any PT asset on Euler.
To begin Let's create a new directory called AdvancedYieldFarming and initialize a foundry project inside of it.
forge init
We are also going to install ethereum-vault-connector and evk/periphery libraries from Euler in order to build our scripts
forge install euler-xyz/ethereum-vault-connector
forge install euler-xyz/evk-periphery
To start out, we will create a subdirectory in our script folder called common. Inside of which, we will create a new script file called EScript.s.sol this file will act as the base for any scripts we write and will hold utility logic, so that our main scripts can be focused strictly on building the transaction logic.
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;
// EScript.s.sol
import {Script, console} from "forge-std/Script.sol";
import "evc/interfaces/IEthereumVaultConnector.sol";
import { EVault } from "evk/EVault/EVault.sol";
contract EScript is Script {
IEVC evc;
address borrower; // eoa
address e_account; // subaccount
}
Here, we have imported the basics and setup our contract as a Script with a couple of global variables that will be universal to any transaction we build. Namely, the EVC, the borrower which will be our msg.sender and the e_account, which we can set to our Euler compliant sub account. This sub account will be the global account that holds our position.
From here, we can implement two utility functions that will be necessary for our script. First, we need a way of deriving our sub account based on our index. We also need a way to read in json file data, this will be necessary to utilize the swap routing payloads which we are going to fetch from the euler-orderflow-router. We can define these functions in our EScript contract.
function getSubaccount(address _account, uint256 _index) public returns (address) {
return address(uint160(uint160(_account)^_index));
}
function getJsonFile(string memory _filePath) internal view returns (string memory) {
return vm.readFile(_filePath);
}
In the context of the evc, one general operation we will often need to execute will be the enabling/disabling of the vaults as collateral or controllers. The operations indicate to the evc which vaults to use as collateral and allow us to take loans from the controllers. Thus, we can create two utility functions which return the BatchItem payload necessary for a given vault.
function enableCollateral(address _vault) public view returns (IEVC.BatchItem memory) {
return IEVC.BatchItem({
onBehalfOfAccount: address(0),
targetContract: address(evc),
value: 0,
data: abi.encodeWithSelector(
IEVC.enableCollateral.selector,
e_account,
_vault
)
});
}
function enableController(address _vault) public view returns (IEVC.BatchItem memory) {
return IEVC.BatchItem({
onBehalfOfAccount: address(0),
targetContract: address(evc),
value: 0,
data: abi.encodeWithSelector(
IEVC.enableController.selector,
e_account,
_vault
)
});
}
These functions will deliver the batch data for enabling a specific vault for the Euler sub account which we globally set in our main scripts run logic.
Another frequent operation we will need to make use of is executing a swap's routing payload. The swap data we retrieve will give us a target contract along with all the data needed, this makes executing it within a batch simple enough to allow us to create a general function to batch this operation and execute it on behalf of our current sub account.
function batchPayload(address _target, bytes memory _data) public view returns (IEVC.BatchItem memory) {
return IEVC.BatchItem({
onBehalfOfAccount: e_account,
targetContract: _target,
value: 0,
data: _data
});
}
In order that we may open a leveraged long position, we are going to need an operation to borrow funds and have them delivered to the swapper for trading. So we can create a general borrow function to retrieve the BatchItem which accomplishes this transaction on a given vault to a given address in a specified amount.
function batchBorrowTo(address _vault, uint256 _amount, address _to) public view returns (IEVC.BatchItem memory) {
return IEVC.BatchItem({
onBehalfOfAccount: e_account,
targetContract: _vault,
value: 0,
data: abi.encodeWithSelector(EVault.borrow.selector, _amount, _to)
});
}
Now that we have implemented all of the necessary batch operations to open our position, we will add a few general getters to check our balances on the vaults.
function sharesBalance(address _vault) public view returns (uint256) {
return EVault(_vault).balanceOf(e_account);
}
function assetsBalance(address _vault) public view returns (uint256) {
return EVault(_vault).convertToAssets(EVault(_vault).balanceOf(e_account));
}
function debtBalance(address _vault) public view returns (uint256) {
return EVault(_vault).debtOf(e_account);
}
Now since we will be opening this trade on Sonic. We will create a library to hold all of the relevant constant sonic contract addresses. This will be in our common directory.
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;
library SonicLib {
address public constant EVC = 0x4860C903f6Ad709c3eDA46D3D502943f184D4315;
address public constant EULER_USDC_VAULT = 0x196F3C7443E940911EE2Bb88e019Fd71400349D9;
address public constant EULER_PT_STS_VAULT = 0xdBc46ff39Cae7f37c39363B0CA474497dAD1d3cf;
address public constant EULER_WS_VAULT = 0x9144C0F0614dD0acE859C61CC37e5386d2Ada43A;
address public constant USDC = 0x29219dd400f2Bf60E5a23d13Be72B486D4038894;
address public constant PT_STS = 0x420df605D062F8611EFb3F203BF258159b8FfFdE;
address public constant WS = 0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38;
}
Since we have all of our utilities completed, we can move on to writing the scripts run logic. We can create a file called script/open.s.sol and import our EScript base contract and the SonicLib. We also set our global variables to be used in the script. This is where we will define which of our Euler subaccounts will hold our position.
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;
// script/open.s.sol
import "./common/EScript.s.sol";
import {SonicLib} from "./common/SonicLib.sol";
contract OpenScript is EScript {
function run() public {
borrower = msg.sender;
e_account = getSubaccount(borrower, 0);
evc = IEVC(SonicLib.EVC);
}
}
Note, we have also imported a library called SonicLib from the common directory. This file will hold specific, constant addresses for our trade.
First, let's define each asset we will use in our trade.
For this trade, we are going to have a hedged asset earning fixed yield in the form of a PT, specifically PT-stS. The purchase of this asset will be funded by borrowing wS, our liability asset. Since The PT resolves to $S staked in beets at maturity, this liability neutralizes our exposure from the PT. We will collateralize this wS loan with our initial capital in USDC.e in it's vault, this will be our collateral.
So we need to set these variables in the code, defining both the token and vault for each asset.
// script/open.s.sol
address LIABILITY_VAULT = SonicLib.EULER_WS_VAULT;
address HEDGED_VAULT = SonicLib.EULER_PT_STS_VAULT;
address COLLATERAL_VAULT = SonicLib.EULER_USDC_VAULT;
address LIABILITY_TOKEN = SonicLib.WS;
address HEDGED_TOKEN = SonicLib.PT_STS;
address COLLATERAL_TOKEN = SonicLib.USDC;
Now that we understand each asset's purpose in our trade, we can set the specific addresses in our SonicLib corresponding to the Sonic address of the asset.
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;
library SonicLib {
address public constant EVC = 0x4860C903f6Ad709c3eDA46D3D502943f184D4315;
address public constant EULER_USDC_VAULT = 0x196F3C7443E940911EE2Bb88e019Fd71400349D9;
address public constant EULER_PT_STS_VAULT = 0xdBc46ff39Cae7f37c39363B0CA474497dAD1d3cf;
address public constant EULER_WS_VAULT = 0x9144C0F0614dD0acE859C61CC37e5386d2Ada43A;
address public constant USDC = 0x29219dd400f2Bf60E5a23d13Be72B486D4038894;
address public constant PT_STS = 0x420df605D062F8611EFb3F203BF258159b8FfFdE;
address public constant WS = 0x039e2fB66102314Ce7b64Ce5Ce3E5183bc94aD38;
}
Fetching The Swap Routing Payload
To fetch the euler-orderflow-router we will need to setup a typescript script to call the api and write the data to a json file for use in our script. This was covered in our previous post on using euler-orderflow-router . Here we will modify the implementation to be more generalizable.
first we init a typescript project. Install our dependencies and create a new directory called api
npm init -y
npm install --save-dev typescript ts-node @types/node && npm install ethers@^6.0.0 dotenv
npm install yargs @types/yargs
mkdir -p api
Now we create a new file called common.ts to hold our api get logic. We define a function for structuring a query to get a payload for an exactIn swap data, where all of our inputToken amountIn will be consumed and swapped for the outputToken
import axios from "axios";
import * as fs from "fs";
const SWAP_API_URL = "https://swap.euler.finance";
// Get params for an exact in swap to close a position
// funds are delivered to the liability Vault
export function getParamsExactIn(
account: string,
inputVaultAddress: string,
outputVaultAddress: string,
inputToken: string,
outputToken: string,
amountIn: string,
) {
const queryParams = {
chainId: "146", // sonic chain
tokenIn: inputToken,
tokenOut: outputToken,
amount: amountIn, // the amount to swap
targetDebt: "0", // irrelevant in this exactIn flow
currentDebt: amountIn, // irrelevant in this exactIn flow
receiver: outputVaultAddress,
vaultIn: inputVaultAddress, // left over tokenIn goes here, irrelevent for exactIn flow
origin: account, // account executing the tx
accountIn: account, // account holding the collateral
accountOut: account, // account to swap to, the account that skim will deliver to
slippage: "0.15", // 0.15% slippage
deadline: String(Math.floor(Date.now() / 1000) + 10 * 60), // 10 minutes from now
swapperMode: "0", // exact input mode = 0
isRepay: "false", // we will manually add a call to repay the debt
};
return queryParams;
}
// Get payload for an exact in swap to close a position
export async function getPayload(queryParams: any) {
const { data: response } = await axios.get(
`${SWAP_API_URL}/swap`,
{
params: queryParams
}
);
return response.data
}
export async function writeToJsonFile(data: any, filename: string) {
fs.writeFileSync(filename, JSON.stringify(data, null, 2));
}
We have also defined a function to send the query request to the API in a get request. As well as a function to write payload data to a json file.
We can, at this point, write the driver script to execute on our payload. We will create a file called ExactInputSwap.ts for this purpose
import { getParamsExactIn, getPayload, writeToJsonFile } from "./common";
import yargs from 'yargs';
import { hideBin } from 'yargs/helpers';
async function main() {
// Parse command line arguments
const argv = await yargs(hideBin(process.argv))
.options({
'address': {
type: 'string',
description: 'The wallet address',
demandOption: true
},
'amount': {
type: 'string',
description: 'Amount to swap in ether',
demandOption: true
},
'input-vault': {
type: 'string',
description: 'Input vault address',
demandOption: true
},
'output-vault': {
type: 'string',
description: 'Output vault address',
demandOption: true
},
'input-token': {
type: 'string',
description: 'Input token address',
demandOption: true
},
'output-token': {
type: 'string',
description: 'Output token address',
demandOption: true
},
// 'output-dir': {
// type: 'string',
// description: 'Output directory for payload files',
// default: "./script/payloads"
// }
})
.help()
.argv;
const swapParams = getParamsExactIn(
argv.address,
argv["input-vault"],
argv["output-vault"],
argv["input-token"],
argv["output-token"],
BigInt(argv.amount).toString()
);
const swapPayload = await getPayload(swapParams);
const outputDir = argv["output-dir"];
await writeToJsonFile(swapPayload.swap, `script/payloads/swapData.json`);
await writeToJsonFile(swapPayload.verify, `script/payloads/verifyData.json`);
console.log("Payloads written to files in:", `script/payloads`);
}
main().catch((error) => {
console.error(error);
process.exitCode = 1;
});
Here, we have outlined the command line args necessary for our swap, we than construct our query based on these args and make the request.
Once we have received the payload, they will be written to two separate json files in our script/payload directory. The euler-orderflow-router pattern was previously discussed in this post
Back To Solidity
Now that we have our API call script complete, we can jump back to our EScript.s.sol file and add a utility function which will allow us to call this script and write fresh payload data from inside our solidity execution script.
For this function, we will make use of the vm.ffi() cheatcode. Allowing us to execute arbitrary code on our machine.
// Escript.s.sol
function requestPayload(
address _inputVault,
address _outputVault,
address _inputToken,
address _outputToken,
uint256 _amount
) public {
string[] memory inputs = new string[](14);
inputs[0] = "ts-node";
inputs[1] = "api/ExactInputSwap.ts";
inputs[2] = "--address";
inputs[3] = vm.toString(e_account);
inputs[4] = "--input-vault";
inputs[5] = vm.toString(_inputVault);
inputs[6] = "--output-vault";
inputs[7] = vm.toString(_outputVault);
inputs[8] = "--input-token";
inputs[9] = vm.toString(_inputToken);
inputs[10] = "--output-token";
inputs[11] = vm.toString(_outputToken);
inputs[12] = "--amount";
inputs[13] = vm.toString(_amount);
vm.ffi(inputs);
}
Here we can pass through all of our trade's parameters to the scripts arguments and execute the request for a swap payload in the context of our current trades execution.
In order that we are able to read the payload file, we must update our foundry configs in foundry.toml
fs_permissions = [{ access = "read", path = "./script/payloads"}]
Now that our utilities are updated, we can jump back to the execution script and finish implementing this trades logic.
After defining all of our assets and vaults, we are going to get the balance of our COLLATERAL_TOKEN (USDC) for deposit. We are also going to get our maximum borrow amount of LIABILITY_TOKEN based on our USDC balance.
Since, at the time of writing, wS is worth 0.5 USDC and we have determined to go 7x long our initial capital, as outlined in the post describing this trade we can calculate our maxDebt at 2 wS per dollar.
// script/open.s.sol
uint256 collateral_balance = IERC20(COLLATERAL_TOKEN).balanceOf(borrower);
uint256 maxDebt = collateral_balance * 2e12 * 7;
Now that we have all of our amounts, we can call the euler-orderflow-router to write our payload via the previously made utility function. We also parse the resulting files in order that we may have the data ready to go.
requestPayload(
LIABILITY_VAULT,
HEDGED_VAULT,
LIABILITY_TOKEN,
HEDGED_TOKEN,
maxDebt
);
string memory swapJson = getJsonFile("./script/payloads/swapData.json");
string memory verifyJson = getJsonFile("./script/payloads/verifyData.json");
Next, we can construct our EVC Batch of operations, we will need 7 items, starting with enabling all of the necessary vaults.
IEVC.BatchItem[] memory batchItems = new IEVC.BatchItem[](7);
batchItems[0] = enableCollateral(COLLATERAL_VAULT);
batchItems[1] = enableCollateral(HEDGED_VAULT);
batchItems[2] = enableController(LIABILITY_VAULT);
We can, then, deposit our initial capital as collateral and borrow our full amount of leverage from the liability vault into the swapper contract.
batchItems[3] = batchDeposit(COLLATERAL_VAULT, collateral_balance);
batchItems[4] = batchBorrowTo(LIABILITY_VAULT, maxDebt, vm.parseJsonAddress(swapJson, ".swapperAddress"));
Once that is batched, we batch the payloads for swapping and verifying(which also deposits our outputToken into it's collateral vault).
batchItems[5] = batchPayload(vm.parseJsonAddress(swapJson, ".swapperAddress"), vm.parseJsonBytes(swapJson, ".swapperData"));
batchItems[6] = batchPayload(vm.parseJsonAddress(verifyJson, ".verifierAddress"), vm.parseJsonBytes(verifyJson, ".verifierData"));
And with that, our batch is ready to cook! The only other execution we need, inside of our broadcast section, is the approve the COLLATERAL_VAULT an allowance to transfer our COLLATERAL_TOKEN since our batch does contain a deposit transaction.
vm.startBroadcast();
IERC20(COLLATERAL_TOKEN).approve(COLLATERAL_VAULT, collateral_balance);
evc.batch(batchItems);
vm.stopBroadcast();
Once our broadcast is complete, we can fetch our vault balances to make sure the result is as expected.
console.log("LIABILITY TOKEN DEBT: ", debtBalance(LIABILITY_VAULT));
console.log("HEDGED TOKEN BALANCE: ", assetsBalance(HEDGED_VAULT));
console.log("COLLATERAL TOKEN BALANCE: ", assetsBalance(COLLATERAL_VAULT));
This is script can be run with
forge script --fork-url https://rpc.soniclabs.com --sender $SENDER script/Hedged/close.s.sol --ffi
Here, we can see how utilizing programmatic, scripted execution allows capital allocators and yield farmers to easily create more complex positions available with the EVC's modular design. Integrating multiple assets and protocols. Further scripts written in this series, for managing positions like this, will demonstrate the speed and flexibility in positioning that are available to traders who take advantage of expert defi development.
High yield defi engineering is available on demand at YieldDev Studio
Feel free to reach out on —> x for anything, technical or otherwise
Full code described above can be found on github
Full script code:
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;
import "./common/EScript.s.sol";
import {SonicLib} from "./common/SonicLib.sol";
import { IERC20 } from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
contract OpenScript is EScript {
function run() public {
borrower = msg.sender;
e_account = getSubaccount(borrower, 0);
evc = IEVC(SonicLib.EVC);
address LIABILITY_VAULT = SonicLib.EULER_WS_VAULT;
address HEDGED_VAULT = SonicLib.EULER_PT_STS_VAULT;
address COLLATERAL_VAULT = SonicLib.EULER_USDC_VAULT;
address LIABILITY_TOKEN = SonicLib.WS;
address HEDGED_TOKEN = SonicLib.PT_STS;
address COLLATERAL_TOKEN = SonicLib.USDC;
uint256 collateral_balance = IERC20(COLLATERAL_TOKEN).balanceOf(borrower);
uint256 maxDebt = collateral_balance * 2e12 * 7;
requestPayload(
LIABILITY_VAULT,
HEDGED_VAULT,
LIABILITY_TOKEN,
HEDGED_TOKEN,
maxDebt
);
string memory swapJson = getJsonFile("./script/payloads/swapData.json");
string memory verifyJson = getJsonFile("./script/payloads/verifyData.json");
vm.label(vm.parseJsonAddress(swapJson, ".swapperAddress"), "swapperAddress");
vm.label(vm.parseJsonAddress(verifyJson, ".verifierAddress"), "verifierAddress");
IEVC.BatchItem[] memory batchItems = new IEVC.BatchItem[](7);
batchItems[0] = enableCollateral(COLLATERAL_VAULT);
batchItems[1] = enableCollateral(HEDGED_VAULT);
batchItems[2] = enableController(LIABILITY_VAULT);
batchItems[3] = batchDeposit(COLLATERAL_VAULT, collateral_balance);
batchItems[4] = batchBorrowTo(LIABILITY_VAULT, maxDebt, vm.parseJsonAddress(swapJson, ".swapperAddress"));
batchItems[5] = batchPayload(vm.parseJsonAddress(swapJson, ".swapperAddress"), vm.parseJsonBytes(swapJson, ".swapperData"));
batchItems[6] = batchPayload(vm.parseJsonAddress(verifyJson, ".verifierAddress"), vm.parseJsonBytes(verifyJson, ".verifierData"));
vm.startBroadcast();
IERC20(COLLATERAL_TOKEN).approve(COLLATERAL_VAULT, collateral_balance);
evc.batch(batchItems);
vm.stopBroadcast();
console.log("LIABILITY TOKEN DEBT: ", debtBalance(LIABILITY_VAULT));
console.log("HEDGED TOKEN BALANCE: ", assetsBalance(HEDGED_VAULT));
console.log("COLLATERAL TOKEN BALANCE: ", assetsBalance(COLLATERAL_VAULT));
}
}
Subscribe to my newsletter
Read articles from Yield Dev directly inside your inbox. Subscribe to the newsletter, and don't miss out.
Written by