Detailed Instructions

Begin by conducting a comprehensive portfolio audit to determine your current asset allocation percentages. This involves calculating the total value of your portfolio and the individual value of each asset (e.g., ETH, stablecoins, governance tokens). Simultaneously, establish your strategic asset allocation (SAA), which are your long-term target percentages for each asset class based on your risk tolerance and investment thesis.

• Sub-step 1: Gather Data: Use a portfolio tracker like DeBank or Zapper to aggregate holdings across all your wallets (e.g., 0x742d35Cc6634C0532925a3b844Bc9e...). Note the current market price of each asset.
• Sub-step 2: Calculate Current Weights: For each asset, compute: (Asset Value / Total Portfolio Value) * 100. Your portfolio might currently be 60% ETH, 30% USDC, and 10% AAVE.
• Sub-step 3: Define Target Weights: Set your SAA. A common conservative DeFi target might be 50% ETH, 40% Stablecoins (e.g., USDC, DAI), and 10% Altcoins/DeFi tokens.

Tip: Use a spreadsheet to automate these calculations. Re-evaluate your SAA quarterly, as market conditions and your goals evolve.

Detailed Instructions

This step involves deviation analysis to identify which assets are overweight (exceed their target allocation) and which are underweight. The goal is to calculate the exact monetary value that needs to be bought or sold for each asset to bring the portfolio back to its target weights. This is a purely mathematical exercise before any transaction is executed.

• Sub-step 1: Calculate Deviation: For each asset, find the difference: Current Value - (Target % * Total Portfolio Value). A positive result means it's overweight and should be sold; a negative means it's underweight and should be bought.
• Sub-step 2: Determine Trade Size: The amount to trade is the absolute value of the deviation. For example, if your USDC is $500 underweight, you need to buy $500 worth of USDC by selling an equivalent value of overweight assets.
• Sub-step 3: Plan the Trades: Create a trade matrix. If ETH is $1000 overweight and AAVE is $1000 underweight, your action is to sell $1000 of ETH and buy $1000 of AAVE.

Tip: Factor in slippage tolerance and gas fees when planning trades, especially for illiquid assets. Setting a 0.5% slippage limit is common.

Detailed Instructions

With a clear trade plan, proceed to execute the swaps on Decentralized Exchanges (DEXs) like Uniswap V3, Curve, or Balancer. The key here is execution optimization to minimize costs and maximize the value received. Always verify token addresses to avoid scams.

• Sub-step 1: Choose DEX & Pool: Select the DEX with the deepest liquidity and lowest fees for your specific trading pair. For ETH/USDC, you might use the 0.05% fee pool on Uniswap V3.
• Sub-step 2: Configure the Swap: Enter the exact token amount from your plan. For selling overweight ETH:

javascriptCopy
// Example swap parameters for selling 1 ETH for USDC on Uniswap
const params = {
  tokenIn: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2', // WETH
  tokenOut: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
  fee: 500, // 0.05%
  recipient: '0xYourAddress',
  amountIn: '1000000000000000000', // 1 ETH in wei
  slippageTolerance: 0.005 // 0.5%
};

• Sub-step 3: Execute & Confirm: Sign the transaction in your wallet (e.g., MetaMask). Always wait for on-chain confirmation before proceeding to the next trade.

Tip: Consider using DEX aggregators like 1inch or ParaSwap to automatically route your trade through the most efficient path across multiple liquidity sources.

Detailed Instructions

After all trades are complete, you must verify the new portfolio state and maintain meticulous transaction records. This step closes the loop and provides data for future decisions and tax reporting.

• Sub-step 1: Recalculate Allocation: Refresh your portfolio tracker or spreadsheet. Perform the same calculation from Step 1 to confirm your holdings now align with your target weights (e.g., 50.1% ETH, 39.8% USDC, 10.1% AAVE). Accept minor deviations due to fees and price movements.
• Sub-step 2: Log Transaction Details: Record every trade in a ledger. For each, note: Date/Time, Token Pair (e.g., ETH/USDC), Amounts In/Out, Transaction Hash (e.g., 0xabc123...), Gas Fee Paid (in ETH and USD equivalent), and Price per Token at execution.
• Sub-step 3: Update Rebalance Calendar: Note the date of this rebalance. Decide on your next trigger—this could be a specific date (calendar-based, e.g., quarterly) or a threshold (e.g., when any asset deviates by >5% from its target).

Tip: Use a dedicated crypto tax software (like Koinly or CoinTracker) from the start. Inputting every transaction hash ensures accurate capital gains/losses calculation, which is crucial for regulatory compliance.

Detailed Instructions

First, you must define the strategy logic and thresholds that will trigger rebalancing. This includes setting your target asset allocation percentages, the acceptable deviation (e.g., 5%) before a rebalance is triggered, and the frequency of checks. You'll also need to select the specific DeFi protocols (like Uniswap V3, Aave, or Compound) and the tokens involved (e.g., 60% ETH, 40% USDC).

• Sub-step 1: Configure Parameters: In your strategy script, set variables like targetAllocation = {'ETH': 0.6, 'USDC': 0.4} and deviationThreshold = 0.05.
• Sub-step 2: Wallet Connection: Use a library like Ethers.js or Web3.js to connect your automated script to a non-custodial wallet (e.g., a private key or mnemonic stored securely). The script must be able to sign transactions.
• Sub-step 3: Fund the Controller Address: Ensure the Ethereum address controlling the bot has sufficient ETH for gas fees. For mainnet, you might use address 0x742d35Cc6634C0532925a3b844Bc9e... (your bot's address).

Tip: Use environment variables (.env file) to store sensitive keys and parameters securely, never hardcode them.

Detailed Instructions

Your bot must periodically fetch real-time portfolio valuations and compute the deviation from target. This involves querying on-chain data or price oracles to get the current USD value of each asset in your portfolio. Calculate the current percentage of each asset and determine if any asset's weight has drifted beyond your set threshold.

• Sub-step 1: Fetch Balances & Prices: Use multicall contracts or protocol-specific APIs. For example, to get a wallet's USDC balance on Ethereum: await usdcContract.balanceOf(walletAddress). Fetch prices from an oracle like Chainlink.
• Sub-step 2: Compute Current Allocation: If your portfolio holds 1.5 ETH ($3000) and 2000 USDC ($2000), the current allocation is ETH: 60%, USDC: 40%. currentEthAllocation = ethValue / totalPortfolioValue.
• Sub-step 3: Check Deviation: Calculate deviation = abs(currentAllocation - targetAllocation). If deviation > 0.05 for any asset, flag the portfolio for rebalancing.

Tip: Implement efficient polling intervals (e.g., every 10 blocks) to balance responsiveness with gas costs. Consider using events or subgraphs for more efficient monitoring.

Detailed Instructions

When a deviation is detected, the bot must execute trades to buy underweight assets and sell overweight ones. This typically involves interacting with Automated Market Makers (AMMs) like Uniswap or using aggregators like 1inch for optimal routing. The bot must calculate the exact trade sizes needed to restore balance.

• Sub-step 1: Calculate Trade Amounts: Determine the USD value to rebalance. If ETH is overweight, calculate sellAmountUSD = (currentEthAllocation - targetEthAllocation) * totalPortfolioValue.
• Sub-step 2: Route the Trade: Use a DEX aggregator SDK to find the best price. For example, with the 1inch API: https://api.1inch.io/v5.0/1/swap?fromTokenAddress=0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2&toTokenAddress=0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48&amount=1000000000000000000.
• Sub-step 3: Execute Swap: Build and send the transaction. Using Ethers.js:

javascriptCopy
const tx = await routerContract.swap(tradeData, { gasLimit: 300000 });
await tx.wait();

Tip: Always factor in slippage tolerance (e.g., 0.5%) and gas costs when calculating trade viability. Use flash loans for capital-efficient rebalancing if your strategy allows.

Detailed Instructions

Gas optimization and security protocols are critical for long-term, profitable operation. Implement strategies to minimize costs and protect your funds from exploits or failed transactions. Maintain detailed logs for monitoring and debugging.

• Sub-step 1: Gas Strategy: Use gas price oracles (e.g., ETH Gas Station) to submit transactions when network fees are low. Implement EIP-1559 transaction types with maxFeePerGas and maxPriorityFeePerGas. Consider using Layer 2 solutions like Arbitrum for lower costs.
• Sub-step 2: Security Checks: Before any transaction, simulate it using eth_call or Tenderly to check for failures. Implement circuit breakers—pause the bot if portfolio value drops by a certain percentage (e.g., 20%) unexpectedly.
• Sub-step 3: Logging & Alerting: Log all actions (checks, deviations, trades, gas used) to a file or service like The Graph. Set up alerts (e.g., via Discord webhook) for critical events like failed transactions or large deviations.

Tip: Regularly review and update the bot's smart contract approvals. Use a multi-sig wallet for the controller address for enhanced security, requiring multiple signatures for critical changes.