Unified Margin
Unified Margin Examples
Real-world DeFi execution plans you can run with Tetrics SDK for unified margin management across chains. Copy, customize, and deploy!
Basic Operations
1. Stake ETH on Lido
Simple ETH staking to receive stETH - building your unified margin position.
import { TetricsClient, type ActionStep } from '@tetrics/sdk'
const client = TetricsClient.fromApiKey(keyId, secret)
const actions: ActionStep[] = [{
chain: 'ethereum',
protocol: 'lido',
method: 'deposit',
params: { amount: '1000000000000000000' }, // 1 ETH
value: '1000000000000000000'
}]
const receipt = await client.executePlanDirect({
name: 'Stake ETH on Lido',
steps: actions,
executionMode: 'atomic'
})
console.log(`stETH received! Tx: ${receipt.action_results?.[0]?.tx_hash}`)Use Case: Earn staking rewards on your ETH without running a validator.
Expected Returns: ~4% APY
2. Wrap stETH to wstETH
Convert stETH to wstETH for DeFi composability.
const actions: ActionStep[] = [{
chain: 'ethereum',
protocol: 'wsteth',
method: 'wrap',
params: { stETHAmount: '1000000000000000000' } // 1 stETH
}]
const receipt = await client.executePlanDirect({
name: 'Wrap stETH to wstETH',
steps: actions,
executionMode: 'atomic'
})Use Case: wstETH is composable with other DeFi protocols (Morpho, Aave, etc).
3. Supply Collateral to Morpho
Supply wstETH as collateral on Morpho Blue.
const actions: ActionStep[] = [{
chain: 'ethereum',
protocol: 'morpho',
method: 'supply',
params: {
amount: '1000000000000000000', // 1 wstETH
marketId: '0x...' // wstETH/USDC market
}
}]Use Case: Earn supply APY while maintaining ability to borrow.
Intermediate Workflows
4. Stake and Wrap (2-Step)
Stake ETH and automatically wrap to wstETH.
const stakeAndWrap: ActionStep[] = [
// Step 1: Stake ETH
{
chain: 'ethereum',
protocol: 'lido',
method: 'deposit',
params: { amount: '1000000000000000000' },
value: '1000000000000000000'
},
// Step 2: Wrap stETH
{
chain: 'ethereum',
protocol: 'wsteth',
method: 'wrap',
params: { stETHAmount: '1000000000000000000' }
}
]
const receipt = await client.executePlanDirect({
name: 'Stake and Wrap',
steps: stakeAndWrap,
executionMode: 'atomic'
})Benefits:
✅ Atomic execution (all-or-nothing)
✅ Gas savings (~30% vs separate txs)
✅ wstETH ready for DeFi
5. Collateralized Borrowing
Supply collateral and borrow USDC in one transaction.
const collateralBorrow: ActionStep[] = [
// Step 1: Supply wstETH
{
chain: 'ethereum',
protocol: 'morpho',
method: 'supply',
params: {
amount: '2000000000000000000', // 2 wstETH (~$7000)
marketId: '0x...'
}
},
// Step 2: Borrow USDC (70% LTV)
{
chain: 'ethereum',
protocol: 'morpho',
method: 'borrow',
params: {
amount: '4900000000', // $4,900 USDC
marketId: '0x...'
}
}
]
const receipt = await client.executePlanDirect({
name: 'Collateral + Borrow',
steps: collateralBorrow,
executionMode: 'atomic'
})Risk Parameters:
Collateral: 2 wstETH (~$7,000)
Borrow: $4,900 USDC
LTV: 70%
Liquidation threshold: ~83%
6. Leverage Staking
Recursive staking for amplified returns.
const leverageStaking: ActionStep[] = [
// 1. Stake 1 ETH
{
chain: 'ethereum',
protocol: 'lido',
method: 'deposit',
params: { amount: '1000000000000000000' },
value: '1000000000000000000'
},
// 2. Wrap stETH
{
chain: 'ethereum',
protocol: 'wsteth',
method: 'wrap',
params: { stETHAmount: '1000000000000000000' }
},
// 3. Supply as collateral
{
chain: 'ethereum',
protocol: 'morpho',
method: 'supply',
params: {
amount: '1000000000000000000',
marketId: '0x...'
}
},
// 4. Borrow ETH (70% LTV)
{
chain: 'ethereum',
protocol: 'morpho',
method: 'borrow',
params: {
amount: '700000000000000000', // 0.7 ETH
marketId: '0x...'
}
},
// 5. Stake borrowed ETH
{
chain: 'ethereum',
protocol: 'lido',
method: 'deposit',
params: { amount: '700000000000000000' },
value: '700000000000000000'
}
]
const receipt = await client.executePlanDirect({
name: 'Leveraged Staking 1.7x',
steps: leverageStaking,
executionMode: 'atomic'
})Effective Exposure: 1.7 ETH staked with 1 ETH capital
⚠️ Risks: Liquidation risk if ETH price drops significantly
Advanced Cross-Chain Unified Margin
7. Ethereum to Hyperliquid Yield
Bridge ETH to Hyperliquid and supply to HyperLend.
const crossChainYield: ActionStep[] = [
// Step 1: Bridge ETH to Hyperliquid
{
chain: 'ethereum',
protocol: 'across',
method: 'deposit',
params: {
destinationChainId: '999',
amount: '1000000000000000000',
recipient: '0xYourAddress'
},
value: '1000000000000000000'
},
// Step 2: Supply to HyperLend
{
chain: 'hyperliquid',
protocol: 'hyperlend',
method: 'supply',
params: {
asset: '0x...', // ETH address on Hyperliquid
amount: '1000000000000000000'
}
}
]
const receipt = await client.executePlanDirect({
name: 'Cross-Chain Yield',
steps: crossChainYield,
executionMode: 'sequential' // Cross-chain requires sequential
})Expected Returns: ~5-8% APY on HyperLend
8. HYPE Staking and Lending
Stake HYPE for beHYPE, then use as collateral for unified margin.
const hypePlan: ActionStep[] = [
// 1. Stake HYPE
{
chain: 'hyperliquid',
protocol: 'hype-staking',
method: 'stake',
params: { amount: '1000000000000000000' } // 1 HYPE
},
// 2. Supply beHYPE to HyperLend
{
chain: 'hyperliquid',
protocol: 'hyperlend',
method: 'supply',
params: {
asset: '0x...', // beHYPE address
amount: '1000000000000000000'
}
},
// 3. Borrow USDC
{
chain: 'hyperliquid',
protocol: 'hyperlend',
method: 'borrow',
params: {
asset: '0x...', // USDC
amount: '500000000' // $500 USDC
}
}
]Benefits:
Earn staking rewards on HYPE
Earn supply APY on beHYPE
Access to borrowed capital
9. Felix CDP
Create a CDP, deposit collateral, mint fUSDC for unified margin positions.
const felixCDP: ActionStep[] = [
// 1. Open CDP
{
chain: 'hyperliquid',
protocol: 'felix',
method: 'openCdp',
params: {
collateral: 'ETH',
amount: '1000000000000000000' // 1 ETH
}
},
// 2. Borrow fUSDC (assuming CDP ID = 1)
{
chain: 'hyperliquid',
protocol: 'felix',
method: 'borrow',
params: {
cdpId: '1',
amount: '1500000000' // $1,500 fUSDC
}
}
]Collateralization Ratio: ~66% (safe from liquidation)
Production Workflows
10. Full Yield Optimization with Unified Margin
Complete multi-chain execution plan for maximum yield using unified margin.
const fullYieldPlan: ActionStep[] = [
// 1. Stake ETH on Lido
{
chain: 'ethereum',
protocol: 'lido',
method: 'deposit',
params: { amount: '5000000000000000000' }, // 5 ETH
value: '5000000000000000000'
},
// 2. Wrap all stETH to wstETH
{
chain: 'ethereum',
protocol: 'wsteth',
method: 'wrap',
params: { stETHAmount: '5000000000000000000' }
},
// 3. Supply to Morpho
{
chain: 'ethereum',
protocol: 'morpho',
method: 'supply',
params: {
amount: '5000000000000000000',
marketId: '0x...'
}
},
// 4. Borrow USDC (60% LTV for safety)
{
chain: 'ethereum',
protocol: 'morpho',
method: 'borrow',
params: {
amount: '10500000000', // $10,500 USDC
marketId: '0x...'
}
},
// 5. Bridge USDC to Hyperliquid
{
chain: 'ethereum',
protocol: 'across',
method: 'deposit',
params: {
destinationChainId: '999',
amount: '10500000000',
recipient: '0x...'
}
},
// 6. Supply USDC to HyperLend
{
chain: 'hyperliquid',
protocol: 'hyperlend',
method: 'supply',
params: {
asset: '0x...', // USDC
amount: '10500000000'
}
}
]
const receipt = await client.executePlanDirect({
name: 'Full Yield Optimization',
steps: fullYieldPlan,
executionMode: 'sequential'
})Expected Returns:
Lido staking: 4% APY
Morpho supply: 2% APY
HyperLend supply: 6% APY
Effective APY: ~8-12% (on 5 ETH capital)
Risks:
⚠️ Liquidation risk if ETH drops >30%
⚠️ Bridge risk during transfers
⚠️ Smart contract risk across 4+ protocols
Execution Plan Templates
Reusable Plan Builder
class PlanBuilder {
private actions: ActionStep[] = []
stakeETH(amount: string) {
this.actions.push({
chain: 'ethereum',
protocol: 'lido',
method: 'deposit',
params: { amount },
value: amount
})
return this
}
wrapToWstETH(amount: string) {
this.actions.push({
chain: 'ethereum',
protocol: 'wsteth',
method: 'wrap',
params: { stETHAmount: amount }
})
return this
}
supplyToMorpho(amount: string, marketId: string) {
this.actions.push({
chain: 'ethereum',
protocol: 'morpho',
method: 'supply',
params: { amount, marketId }
})
return this
}
async execute(client: TetricsClient, name: string) {
return client.executePlanDirect({
name,
steps: this.actions,
executionMode: 'atomic'
})
}
}
// Usage
const plan = new PlanBuilder()
.stakeETH('1000000000000000000')
.wrapToWstETH('1000000000000000000')
.supplyToMorpho('1000000000000000000', '0x...')
const receipt = await plan.execute(client, 'My Unified Margin Plan')Best Practices
✅ DO
// Validate before execute
const validation = await client.validatePlan(actions)
if (!validation.valid) {
console.error('Invalid plan:', validation.errors)
return
}
// Use atomic mode for same-chain execution
const receipt = await client.executePlanDirect({
name: 'My Plan',
steps: actions,
executionMode: 'atomic' // All-or-nothing
})
// Check receipt
if (receipt.success) {
console.log('Success!', receipt.execution_id)
} else {
console.error('Failed:', receipt.error)
}❌ DON'T
// Don't skip validation
await client.executePlanDirect({...}) // ❌ No validation
// Don't use atomic for cross-chain
executionMode: 'atomic' // ❌ Will fail on cross-chain
// Don't ignore errors
const receipt = await client.executePlanDirect({...})
// No error checking ❌Testing Workflows
Always test with small amounts first:
// Test with 0.01 ETH first
const testAmount = '10000000000000000' // 0.01 ETH
const testActions = actions.map(action => ({
...action,
params: {
...action.params,
amount: testAmount
},
value: action.value ? testAmount : undefined
}))
const testReceipt = await client.executePlanDirect({
name: 'Test Run',
steps: testActions,
executionMode: 'atomic'
})
if (testReceipt.success) {
console.log('Test successful! Proceeding with full amount...')
// Now run with real amounts
}Last updated