rubix/src/components/ArticleInternalOne/ArticleInternalOne.jsx

/* eslint-disable no-unused-vars */
import React, { useEffect } from "react";
import { Box, Text, Image } from "@chakra-ui/react";
import { Avatar, AvatarBadge, AvatarGroup } from "@chakra-ui/react";
import banner from "../../assets/images/articleInternalbanner.png";
import Chip from "../Chip/Chip";
import Footer from "../Footer/Footer";
import x from "../../assets/images/x.png";
import linked from "../../assets/images/linked.png";
import github from "../../assets/images/github.png";
import tele from "../../assets/images/tele.png";
import reddit from "../../assets/images/reddit.png";
import fb from "../../assets/images/fb.png";

import profile from "../../assets/images/profile.png";

const ArticleInternalOne = () => {
  useEffect(() => {
    window.scrollTo(0, 0);
  }, []);
  return (
    <>
      <Box
        bg="#000000"
        height={"auto"}
        display={"flex"}
        gap={7}
        justifyContent={"center"}
        alignItems={"center"}
        flexDirection={"column"}
        color="white"
      >
        <Box
          bg="#000000"
          minHeight={"60vh"}
          width={"50vw"}
          display={"flex"}
          gap={5}
          justifyContent={"end"}
          alignItems={"center"}
          flexDirection={"column"}
          color="white"
        >
          <Text
            textAlign={"center"}
            className="rubix-text-heading-2 rubix-fw-600"
          >
            Bring your own BlockSpace
          </Text>

          <Text textAlign={"center"} className="rubix-text-xsmall rubix-fw-500">
            Business Growth January 5, 2023
          </Text>

          <Box display={"flex"} gap={3} textAlign={"center"}>
            <Avatar size="lg" name="Dan Abrahmov" src={profile} />

            <Box
              textAlign={"start"}
              display={"flex"}
              flexDirection={"column"}
              alignItems={"start"}
              justifyContent={"center"}
              className="rubix-text-xsmall rubix-fw-500"
            >
              <Text>Gokul P S</Text>
              <Text>Core Blockchain Developer</Text>
            </Box>
          </Box>
        </Box>
        {/* ========[ Banner ]======= */}
        <Box
          height={"70vh"}
          width={"85vw"}
          backgroundImage={`url(${banner})`}
          backgroundRepeat={"no-repeat"}
          backgroundSize={"cover"}
          position="relative"
        >
          <Box
            position="absolute"
            top={0}
            left={0}
            width="100%"
            height="100%"
            backgroundColor="rgba(0, 0, 0, 0.5)"
          />
        </Box>

        <Box
          bg="#000000"
          width={"85vw"}
          height={"auto"}
          display={"flex"}
          pb={"60px"}
          gap={5}
          justifyContent={"center"}
          alignItems={"center"}
          flexDirection={"column"}
          color="white"
          position={"relative"}
        >
          <Box
            position={"absolute"}
            top={0}
            left={0}
            display={"flex"}
            flexDirection={"column"}
            alignItems={"center"}
            gap={2}
          >
            <Text className="rubix-text-xsmall">Share</Text>

            <Image cursor={"pointer"} mb={4} w={6} h={6} src={tele} />
            <Image cursor={"pointer"} mb={4} w={6} h={6} src={x} />
            <Image cursor={"pointer"} mb={4} w={6} h={6} src={fb} />
            <Image cursor={"pointer"} mb={4} w={6} h={6} src={linked} />
          </Box>
          <Box
            bg="#000000"
            width={"68vw"}
            height={"auto"}
            display={"flex"}
            flexDirection={"column"}
            gap={5}
            justifyContent={"start"}
            color="white"
          >
            <Box display={"flex"} gap={5} justifyContent={"start"}>
              <Chip title="INSIGHT" />
              <Chip title="BLOCKSPACE" />
            </Box>

            <Box pt={5} pb={5}>
              <Text pb={5} fontSize="xl">
                BlockSpace is the number of transactions which the blockchain
                will order before appending to the chain of previous
                transactions. For example, if max block space is 200KB and
                average transactions take only 1Kb, then the chain may have a
                room for ~190 transactions in one block. BlockSpace is a measure
                of how busy is the blockchain. Low BlockSpace may mean
                transactions remain unattended in the Mempool for very long.
                Transactions that compete with each to pay higher fees are
                likely to be validated faster.
              </Text>
              <Text fontSize="xl">
                The BlockSpace limit is intended to protect the decentralized
                nature of monolithic blockchains from centralization via large
                blocks. It protects small miners from being outcompeted by large
                blocks by requiring higher minimum fees with larger block size,
                which regulates the number of transactions that can be included
                in each block. It does not mean that there will be this many
                transactions in any given period, but rather gives an idea of
                how many transactions the network can process in a certain
                period when under stress.
              </Text>
            </Box>

            <Box pt={5}>
              <Text
                style={{ marginBottom: 6 }}
                className="rubix-fw-700"
                fontSize="3xl"
              >
                BTC vs BCH
              </Text>
              <Text fontSize="xl">
                Bitcoin has a BlockSpace of 2000 to 2500 transactions per block
                (block size of 1mb) created every 10 minutes. Bitcoin Cash (fork
                of Bitcoin) on the other hand has a BlockSpace of up to 70,000
                transactions (block size of 32mb). BTC’s transaction processing
                speed is close to 7 transactions per second, while BCH’s
                transaction processing speed is close to 200 transactions per
                second as the BlockSpace in BCH is much higher.
              </Text>
              <Text fontSize="xl">
                Since Bitcoin is designed for homogeneous transactions (ledger
                for BTC transfers, not applications of heterogenous
                transactions), gas fee caused by limited BlockSpace is less of
                concern to BTC community. Bitcoin Cash (BCH) is designed to
                enable scalable applications due to lower costs & higher speed,
                but the increased block size coupled with faster transaction
                speeds increased the risk of 51% attack (weakened security). It
                could be because of this that BCH has not seen many applications
                built on it.
              </Text>
            </Box>
            <Box pt={5}>
              <Text
                style={{ marginBottom: 6 }}
                className="rubix-fw-700"
                fontSize="3xl"
              >
                ETH vs SOL
              </Text>
              <Text pb={5} fontSize="xl">
                Ethereum has borrowed most of the monolithic design concepts of
                Bitcoin, but with blocks being added in less time compared to
                Bitcoin. However, unlike Bitcoin, Ethereum intends to power
                multiple applications across verticals. As Ethereum processes
                heterogeneous transactions across verticals (unlike Bitcoin),
                the monolithic sequential block architecture has resulted in
                network congestion, high gas fees & smart contract complexity.
                Imagine supply chain applications, real estate applications &
                NFT applications, all around the world, compete for the limited
                BlockSpace on the Ethereum chain. This in our opinion is neither
                computationally efficient or desired. This design has meant that
                Ethereum full nodes are now running TBs of ledger state, making
                them computationally inefficient. If all the global applications
                are processed on Ethereum, state storage could be 10,000s of
                thousands of TB, meaning only few nodes can run full nodes,
                running against the thesis of decentralization.
              </Text>
              <Text pb={5} fontSize="xl">
                Further, most of the activity on Ethereum chain is miners
                extracting value from users using a technique called MEV (Miner
                Extractable Value). Most of the MEV extracted in arbitrage
                actions between popular automated market makers such as Uniswap,
                Sushiswap, Curve and Balancer. MEV is akin to front running,
                back running & sandwich trading, all activities otherwise
                illegal in regular capital markets. MEV affects most other
                monolithic chains as well, not just Ethereum. The monolithic
                BlockSpace architecture also raises key issues of privacy &
                security, hindering wider adoption of Web3 by Web2 apps or
                enterprises.
              </Text>
              <Text pb={5} fontSize="xl">
                While Ethereum community aims to reduce congestion issues by
                promoting Layer 2 solutions (L2), L2’s tend to be less
                decentralized. Even with some good Zero Knowledge solutions
                currently being deployed, issues remain, particularly around the
                dependency on the limited nodes where L2 data is deployed.
                Further, L2s require own tokenomics to be successful,
                potentially undermining the L1 token itself, which in turn
                compromises security of the underlying L1 chain.
              </Text>
              <Text pb={5} fontSize="xl">
                SOL allows for more flexibility in the BlockSpace. To increase
                TPS, Solana overcame the requirement for validators to order
                transactions in the block before being validated by using a
                Variable Delay Function (VDF). The VDF is intended to help in
                avoid delays in block propagation & speed up throughput. But
                this comes at the cost of high memory requirement (512 GB) and
                increased CPU usage, thus making it more difficult for miners to
                mine on the network. This high barrier to entry also makes it
                more difficult for users to become a part of the network. Apps
                built on SOL depends largely on small number of nodes to run
                smoothly. Recently, SOL has faced multiple stoppages which could
                be linked to inefficiency of the network to handle traffic even
                before the network is mainstream.
              </Text>
              <Text fontSize="xl">
                Monolithic chains like SOL, while trying to solve the scale
                constraints of Ethereum, usually end up attracting bots to clog
                the enhanced BlockSpace. Bots have caused significant issues to
                the Solana network, leading to multiple stoppages. When costs of
                transaction is lowered in networks like Solana, bots tend to
                spam the network aggressively. So efforts to scale monolithic L1
                chains could cause network security & reliability issues.
              </Text>
            </Box>
            <Text pb={10} pt={5}>
              <img
                width={"100%"}
                src="https://www.rubix.net/wp-content/uploads/ethereum-with-limited-blockspace.webp   "
              />
            </Text>
            <Box pt={5} pb={5}>
              <Text mb={4} className="rubix-fw-500" fontSize="4xl">
                Rubix with unlimited BlockSpace
              </Text>
              <Text pb={5} fontSize="xl">
                Rubix is designed for subnets and app chains to enjoy the
                benefits of being in the same network without having to share
                data or resources among them. People or Apps can bring their own
                validators with minimal computational requirement. This is a
                great way to build a network of decentralized apps without
                hashpower concentration by a specific subnet at any point in the
                network. Each RBT in circulation carry history of transactions
                appended to the its token chain validated by the subnets the
                token was transacted on. With this infinite BlockSpace approach
                followed by Rubix from its inception, the network can be
                extended without having wait for the transaction to be added to
                the chain or pay high gas fee (or any) for the transaction. The
                key innovation in Rubix design is that BlockSpace should not be
                artificially constrained by design, but by the amount of
                computing resources brought into the network by applications &
                users. The Bring Your Own BlockSpace (BYOB) innovation means
                that applications & enterprises can now build secure blockchain
                networks with privacy, while always on one scalable public
                chain, bound by common utility token, RBT; common identity;
                common provenance & ability to merge or demerge BlockSpaces.
                There are billions of existing computing nodes in the world that
                can join Rubix BlockSpace without any additional cost. Rubix
                Blockspace is divided into many Subspaces (subnets). The
                Subspaces will revolutionize the way Web will transform, right
                from how social media is organized, how ecommerce is conducted,
                how financial services are rendered, how metaverse of metaverses
                is created & how data storage is structured. Rubix Subspace is
                perhaps the single biggest thought change in the web is owned &
                used.
              </Text>
              <Text pb={5} fontSize="xl">
                To learn more about Rubix Subspaces, please DM us at @rubixchain
              </Text>
              <Text pb={5} fontSize="xl">
                Co-authored with K.C Reddy and Gokul P S
              </Text>
            </Box>
          </Box>
        </Box>
      </Box>
      <Footer />
    </>
  );
};

export default ArticleInternalOne;