Welcome to R33

Disclaimer: R33 is my personal project for crypto portfolio management. It's experimental and not for public use. I'm not liable for any losses or glitches. I may change or stop R33 anytime.

What R33 Does

R33 trades up to 33 pairs using the PEPE-LP pool on swap.ogpepe.io. It's about stabilizing R33 and boosting the portfolio's value.

Fees Explained

There's a 1% pool fee for liquidity providers, plus a 3% token transfer fee

Arbitrage 101

R33 goes into various pools, creating arbitrage opportunities. Bots play the price differences, I profit:

- 3% transfer fee on each transfer on R33 for me aka "feeCollector".

- 1% pool fee on each hop performed on R33 Pepe LP pairs.

Pool Types

Three pool types: Stablecoins, volatile coins, and my personal picks (aka the meme coins).

- Stablecoins: USDC, WBTC, ETH. Goal 100 R33 liquidity each, 30% supply

- Volatile coins, but stable and underperforming for testing strategies: Something like UNI, 1INCH, DEXT...

- Meme coins, the name says it all, this is next level risky

WARNING: My Strategy

- The goal is to accumulate WBTC, ETH and USDC. To achieve that, I will craft a combination of R33 pairs which might help me achieve that goal, or might make me loose everything

- To accomplish the goal, once I have added enough pairs and liquidity, I will start selling and adding more liquidity in the R33 WBTC, ETH and USDC pairs

- You can expect a downward pressure on the price of R33 because that's the initial goal to build liquidity

- You can be losing 6-10% per trade due to fees, so don't trade this token, this is targeted at automated market maker bots.

- No expectations can be had from me, only I am expected to profit from R33 through rebalancing my portfolio

Read Update R33 - 10-1-24

I leave the code below. I encourage you to deploy your own token and build your own portfolio, try different fees and portfolio combinations.

        // SPDX-License-Identifier: MIT
        pragma solidity ^0.8.20;
        
        import "@openzeppelin/contracts@5.0.1/token/ERC20/ERC20.sol";
        
        /*
         ____ ____ ____                               
        ||R |||3 |||3 ||                              
        ||__|||__|||__||                              
        |/__\|/__\|/__\|                              
         ____ ____ ____ ____ ____ ____ ____ ____ ____ 
        ||R |||3 |||B |||A |||L |||A |||N |||C |||3 ||
        ||__|||__|||__|||__|||__|||__|||__|||__|||__||
        |/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
                                                      
        Disclaimer:
        R33 is a personal project I've developed for managing my own portfolio. It's not intended for public use and is an experimental tool, not a professional financial instrument. I cannot provide support or take responsibility for issues such as lost digital coins or technical glitches. Furthermore, I reserve the right to modify or discontinue R33 at any time without prior notice.
        For insights into how R33 functions for portfolio rebalancing, feel free to visit https://r3balanc3.com / https://github.com/R3BALANC3
        System Features:
        R33 engages in trading with up to 33 different pairs using the 1% liquidity pool of PEPE-LP (uni-v2) on swap.ogpepe.io
        Fee Structure:
        1% pool fee: Long-term liquidity and auto-compounding within the pool.
        3% feeCollector: primary method for extracting value from the system.
        This strategy not only contributes to the stability of R33 but also aids in the liquidity and stability of other projects. Ultimately, this approach is designed to potentially increase the overall value of the portfolio and contribute to multiple projects simultaneously.
                                                    
        */
        contract R3BALANC3 is ERC20 {
            address public feeCollector;
            uint256 public feePercent = 3;
        
            constructor() ERC20("R3BALANC3", "R33") {
                _mint(msg.sender, 1000 * 10**decimals());
                feeCollector = msg.sender;
            }
        
            function transfer(address recipient, uint256 amount)
                public
                override
                returns (bool)
            {
                uint256 fee = (amount * feePercent) / 100;
                uint256 amountAfterFee = amount - fee;
        
                _transfer(_msgSender(), feeCollector, fee);
                _transfer(_msgSender(), recipient, amountAfterFee);
        
                return true;
            }
        
            function transferFrom(
                address sender,
                address recipient,
                uint256 amount
            ) public override returns (bool) {
                uint256 fee = (amount * feePercent) / 100;
                uint256 amountAfterFee = amount - fee;
        
                _transfer(sender, feeCollector, fee);
                _transfer(sender, recipient, amountAfterFee);
        
                _approve(
                    sender,
                    _msgSender(),
                    allowance(sender, _msgSender()) - amount
                );
        
                return true;
            }
        
            function setFeeCollector(address newCollector) public {
                require(
                    msg.sender == feeCollector,
                    "Only the fee collector can change this"
                );
                feeCollector = newCollector;
            }
        }