What does Reflect.Finance code do: _rTotal = (MAX - (MAX % totalSupplyOfToken));

Yoshiko · March 27, 2021, 3:45pm

In reflect code they start by making

uint256 private totalSupplyOfToken = 1 * 10**9 * 10**9;
then
uint256 private _rTotal = (MAX - (MAX % totalSupplyOfToken));

What exactly is rTotal? When calculating it, it gives an extremely large number. I can understand that it’s supposed to stand for reflection total, but why is that different than the total supply? What am I missing about the conversion? I have a feeling it has to do with the way ethereum looks at the total supply rather than a human does.

Thanks

abcoathup · March 29, 2021, 4:04am

Hi @Yoshiko,

Welcome to the community

I suggest asking the Reflect.Finance team. I am not familiar with the project nor the mechanism it uses.

I assume this is the contract:

github.com

reflectfinance/reflect-contracts/blob/main/contracts/REFLECT.sol#L26




mapping (address => uint256) private _rOwned;

mapping (address => uint256) private _tOwned;

mapping (address => mapping (address => uint256)) private _allowances;



mapping (address => bool) private _isExcluded;

address[] private _excluded;

   

uint256 private constant MAX = ~uint256(0);

uint256 private constant _tTotal = 10 * 10**6 * 10**9;

uint256 private _rTotal = (MAX - (MAX % _tTotal));

uint256 private _tFeeTotal;



string private _name = 'reflect.finance';

string private _symbol = 'RFI';

uint8 private _decimals = 9;



constructor () public {

    _rOwned[_msgSender()] = _rTotal;

    emit Transfer(address(0), _msgSender(), _tTotal);

}

Yoshiko · March 28, 2021, 4:34pm

@Skyge hey Skyge, what does rTotal actually represent in this situation. I understand that the total supply is just that, the total token supply, but what is rTotal trying to show here? Does it mean realTotal? As in the real token supply, combined with decimals?

Thanks.

Skyge · March 29, 2021, 3:11am

Hey, I am not sure, maybe you can ask the original writer.

I think this is the Maximum divisor, for example, if MAX = 123 and _tTotal = 5, so

_rTotal = (MAX - (MAX % _tTotal));
=>> _rTotal = (123 - (123 % 5)) = 120

I hope I made myself clear.

Yoshiko · March 29, 2021, 3:45am

Thanks Skyge! Yeah I’m having a hard time figuring out why exactly they did that in RFI code. I can understand the math, but why is another story haha.

I will probably end up figuring out why it’s exactly doing that after I test deploy and start messing with reflect fees and LP swaps.

Sorry to the OP for bumping this thread, but it’s relevant to figuring out what that code actually does, not just the MAX part.

abcoathup · March 29, 2021, 4:07am

Hi @Yoshiko,

I moved your replies under this topic.

Yoshiko · March 29, 2021, 6:37pm

Thanks abcoathup.

I tried to get in touch with the RFI team, but to no avail.

When reading through the code it looks like it really does stand for “total reflections”.
Later on in the code it has a requirement

function tokenFromReflection(uint256 rAmount) public view returns (uint256){
        require(rAmount <= _rTotal, "Amount must be less than total reflections");
        uint256 currentRate = getReflectRate();
        return rAmount.div(currentRate);
    }

But this begs the question of why does _rTotal start out extremely large? Does it mean the Total Possible Reflections?

abcoathup · March 30, 2021, 4:20am

Hi @Yoshiko,

Sorry I can’t help you with this. I don’t know anything about the protocol or why they use the numbers that they use.

_rTotal: 115792089237316195423570985008687907853269984665640564039457580000000000000000

_tTotal: 10000000000000000

MAX: 115792089237316195423570985008687907853269984665640564039457584007913129639935

I would see if there is a community that you can ask?

Nuttawat_Sritunyarat · April 24, 2021, 10:41pm

Do you know the answer yet? I wonder like you

Yoshiko · April 25, 2021, 1:19am

Hi there, welcome to the forums.

Nope, but it the code works, reflection tokens are split between all holders of the token. Perhaps in the future there will be a standardized way to take a tax of a transaction and split it among all holders.

Nuttawat_Sritunyarat · April 25, 2021, 5:48am

Why is reflection tokens equal to (MAX - (MAX% _tTotal)), which is very valuable?

Yoshiko · April 25, 2021, 7:16am

Not sure, if you could, could you try to ask in RFI Telegram? I tried but got no response. It would help a lot of people if you got an answer from them.

jirosaito · April 27, 2021, 5:44am

So I’m not the only one who is confused as hell about this contract which turns out SafeMoon.sol also cloned. My understanding is it’s keeping a ratio between tTotal 1E24 and the difference with MAXuInt24 rTotal because of burning and redistribution.

They can’t just loop through every owned address to .add(redistributionToken) because that would go over the gas limit and pay crazy amount of gas fee.

That said, it’s super confusing and I can’t tell the exact logic what’s happening. If anyone ever figures out, please share.

jirosaito · April 27, 2021, 5:46am

Also another thing after you deploy the contract is in the constructor, the address deployed will own all of rTotal. So does that mean the Devs secretly hold a lot of tokens and not revealed in the blockchain?

Yoshiko · April 27, 2021, 2:56pm

Yes, when the contract is deployed (safemoon clones) the tokens go directly to the holder by default. Then the dev usually does dxSale or locked liquidity.

jirosaito · April 27, 2021, 5:50pm

but rTotal is not supplyTotal (tTotal). rTotal is maxuint256 with last 1E24 0. So even if dev burns half of tTotal it’s still a large amount of token left from rTotal?

github.com

safemoonprotocol/Safemoon.sol/blob/main/Safemoon.sol#L756


    uint256 tokensIntoLiqudity
);


modifier lockTheSwap {
    inSwapAndLiquify = true;
    _;
    inSwapAndLiquify = false;
}


constructor () public {
    _rOwned[_msgSender()] = _rTotal;
    
    IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x05fF2B0DB69458A0750badebc4f9e13aDd608C7F);
     // Create a uniswap pair for this new token
    uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
        .createPair(address(this), _uniswapV2Router.WETH());


    // set the rest of the contract variables
    uniswapV2Router = _uniswapV2Router;
    
    //exclude owner and this contract from fee

Yoshiko · April 28, 2021, 2:53am

tTotal is used to compute the real supply, the Reflections Owned is the way RFI protocol handles their tokenomics.

Basically _rOwned is your supply, but as the reflection amount.

The dev’s choice of what to do with the tokens is up to him. SafeMoon had 1 quadrillion which is kind of absurd to me.

dzdz2 · May 25, 2021, 1:49am

Take a look at this blog: https://wd666.medium.com/what-the-hell-is-rtotal-and-ttotal-4e2ec90466f7
hope it helps

sanar · May 30, 2021, 11:38am

hi all - this is a great post thanks for sharing I had the same questions as i was working through the contract today.

I also had another question along similar lines. in the code below the _tOwned[account]=0. If you include an account to participate in rewards - why would we be setting the owned amount to zero?

  function includeInReward(address account) external onlyOwner() {
        require(_isExcluded[account], "Account is already excluded");
        for (uint256 i = 0; i < _excluded.length; i++) {
            if (_excluded[i] == account) {
                _excluded[i] = _excluded[_excluded.length - 1];
                **_tOwned[account] = 0;**
                _isExcluded[account] = false;
                _excluded.pop();
                break;
            }
        }
    }

Yoshiko · May 31, 2021, 1:36am

Because when it is included, you are now using the variable, _rOwned[account] to track the amount they own.

Check out what happens when you excludeFromReward. The reverse happens. You are now using _tOwned when it is excluded.

    function excludeFromReward(address account) public onlyOwner() {
        // require(account != 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D, 'We can not exclude Uniswap router.');
        require(!_isExcluded[account], "Account is already excluded");
        if(_rOwned[account] > 0) {
            _tOwned[account] = tokenFromReflection(_rOwned[account]);
        }
        _isExcluded[account] = true;
        _excluded.push(account);
    }

    function includeInReward(address account) external onlyOwner() {
        require(_isExcluded[account], "Account is already excluded");
        for (uint256 i = 0; i < _excluded.length; i++) {
            if (_excluded[i] == account) {
                _excluded[i] = _excluded[_excluded.length - 1];
                _tOwned[account] = 0;
                _isExcluded[account] = false;
                _excluded.pop();
                break;
            }
        }
    }

Topic		Replies	Views
Reflect finance variables? Support	11	4166	July 15, 2021
Adding burn in reflect finance code Smart Contracts	3	898	September 21, 2021
Reflect Token Burn Function Review Wanted	3	378	May 15, 2023
What is the function of rTotal variable? Support	2	388	June 20, 2021
Reflection Contract token burn and reward Support erc20	1	2615	March 30, 2021

What does Reflect.Finance code do: _rTotal = (MAX - (MAX % totalSupplyOfToken));

Related topics