diff --git a/src/components/BuildPage/BuildBanner.jsx b/src/components/BuildPage/BuildBanner.jsx index a93e6aa..c2747dc 100644 --- a/src/components/BuildPage/BuildBanner.jsx +++ b/src/components/BuildPage/BuildBanner.jsx @@ -155,6 +155,7 @@ const BuildBanner = ({ data, isLoading }) => { fontSize={"20px"} zIndex={"1"} overflow={"hidden"} + paddingInline={"4rem"} sx={{ "::before": { content: '""', diff --git a/src/components/Card/DevCards.jsx b/src/components/Card/DevCards.jsx new file mode 100644 index 0000000..980321f --- /dev/null +++ b/src/components/Card/DevCards.jsx @@ -0,0 +1,119 @@ +/* eslint-disable react/prop-types */ +/* eslint-disable no-unused-vars */ +import { Box, Container, Text, Image, Button } from "@chakra-ui/react"; +import { Link } from "react-router-dom"; + +const DevCards = ({ id, src, alt, text, href }) => { + return ( + + {/* {images.map((img) => ( + <> + ))} */} + + + + {alt} + + + + + {text} + + + + + + + + + + + ); +}; + +export default DevCards; diff --git a/src/components/Community/CommunityCard.jsx b/src/components/Community/CommunityCard.jsx index 949cf19..7f68de1 100644 --- a/src/components/Community/CommunityCard.jsx +++ b/src/components/Community/CommunityCard.jsx @@ -132,7 +132,7 @@ const individuals = [ const CommunityCard = () => { const { data, error, isLoading } = useGetCommunitiesQuery(); const [state, setState] = useState(); - const profile = data?.data?.data?.rows; + const profile = data?.data?.data; console.log(data?.data?.data); useEffect(() => {}, []); diff --git a/src/components/LearnPage/FaqStatic.jsx b/src/components/LearnPage/FaqStatic.jsx new file mode 100644 index 0000000..ebcc8e1 --- /dev/null +++ b/src/components/LearnPage/FaqStatic.jsx @@ -0,0 +1,321 @@ +// import banner from "../../assets/images/faqBg.webp"; +import { ChevronRightIcon } from "@chakra-ui/icons"; + +import { + Accordion, + AccordionButton, + // AccordionIcon, + AccordionItem, + AccordionPanel, + Box, + Container, + Text, +} from "@chakra-ui/react"; +import { AddIcon, MinusIcon } from "@chakra-ui/icons"; + +const accordion = [ + { + id: 1, + title: `What is blockchain?`, + content: [ + { + item: "Blockchain technology is an advanced database mechanism that allows transparent information sharing within a business network. A blockchain database stories data in blocks that are linked together in a chain. The data is chronologically consistent because you cannot delete or modify the chain without consensus from the network. As a result, you can use blockchain technology to create an immutable ledger, ensuring data security.", + }, + { + item: "While there are many use cases for blockchain technology, one of its most powerful uses is that it can be leveraged to create new opportunities for social impact. Rubix was founded on the idea of “blockchain for good.” Our goal is to leverage blockchain technology to solve some of the world’s biggest societal issues including climate change, income inequality and empowering marginalized groups.", + }, + ], + }, + { + id: 2, + title: `What is Proof-Of-Pledge?`, + content: [ + { + item: "Rubix is powered by a breakthrough Proof-of-Pledge consensus protocol that allows it to rapidly grow its validators without energy-intensive mining, making it the first true L1 green blockchain in the world. What makes Proof-of-Pledge unique and advanced is that each Rubix node installed on an existing system has negligible incremental energy usage, resulting in a carbon neutral impact.", + }, + { + item: "A blockchain is spread across nodes who job it is to verify transactions on the network – this is one of the central ideas behind blockchain and gives it is decentralized nature. As a result, anyone can submit information to be stored onto a blockchain and therefore it is important that there are processes in place that can ensure everyone agrees on what information to add and what to discard. These rules are known as consensus protocols; they verify transactions and help keep the network safe and secure. A consensus protocol is traditionally set before the blockchain is first created.", + }, + { + item: "Most blockchains use either Proof-of-Work (PoW) or Proof-of-Stake (PoS) as their consensus protocol, but these are very energy-intensive and result in significant storage inefficiencies because they require every node to store an entire transaction history. Recognizing the integrity of transactions PoW provided and the speed of PoS, we expanded on both protocols to create the ultimate system: Proof-of-Pledge. Years of research from top experts in crypto, cyber security, computer science, applied finance and green initiatives went into the development of Proof-of-Pledge.", + }, + ], + }, + { + id: 3, + title: `What are RBT Tokens?`, + content: [ + { + item: "Every transaction in the Rubix network is bound to one or a set of tokens. Similar to bitcoin, Rubix has a limited supply of tokens with a maximum of 51.4 million native utility tokens (called Ruix or RBT tokens) possible on the network. Despite the maximum token supply, it has enough tokens available to validate unlimited transactions.", + }, + { + item: "Unlike other monolithic blockchains, Rubix’s design prevents increase in token supply or burning of tokens, protecting it from the lack of credibility or predictability inherent in central banks. It is no secret that tokens define and retain the value in a blockchain and are the currency for transparency. Hence, the Rubix algorithm limits the generation of tokens in supply and at scale, so the value of the transparency currency is high.", + }, + { + item: "In contrast to all other blockchains, Rubix’s unique architecture ensures that even with increasing market value of tokens, gas fees remain at zero. This allows anyone using Rubix to innovate new business models at lower transaction costs to deliver higher business value. This is a key differentiator – Rubix is the only token on the market today with zero gas fees.", + }, + ], + }, + { + id: 4, + title: `What ais Nodes?`, + content: [ + { + item: "Instead of relying on a central entity to validate and store data, the governing infrastructure of a blockchain is a node – a device, such as a computer, laptop or server, that contains a full copy of the transaction history of the blockchain.", + }, + { + item: "One of the key features of the Rubix network is that it is truly decentralized; each node stores its own data and does not replicate it on the blockchain. Instead, only the hash key is stored to enable traceability of transactions. This helps the Rubix reduce storage, infrastructure and operational costs to offer zero gas fees in contrast to all other blockchains.", + }, + { + item: "Unlike energy-intensive blockchain networks of the past, a Rubix node can fit on any laptop, computer or server. Once Rubix is installed on a system, it is automatically connected to the network to start validation.", + }, + ], + }, + { + id: 5, + title: `What is DiD`, + content: [ + { + item: "Decentralized identifiers (or DIDs) are a type of globally unique identifier that enables an entity to be identified in a way that is verifiable and does not require the use of a centralized registry. DIDs enable a new model of decentralized digital identity and are an important component of decentralized web applications.", + }, + ], + }, + { + id: 6, + title: `What is dApps`, + content: [ + { + item: "Decentralized applications, or dApps, are software programs that run on a blockchain or peer-to-peer network of computers instead of on a single computer.", + }, + { + item: "The Rubix platform allows for development of a whole new generation of Web3 based dApps & DAOs for ESG, media, real estate, construction, telecom, pharma, NFT, Metaverse, DeFI, GameFI, cybersecurity, cloud and more. We have partnered with leading developers who are building dApps on the Rubix chain that support a variety of use cases. Each of them share a passion to leverage their dApps to build a better world – and each of their applications solves a crucial business and societal issue.", + }, + ], + }, + { + id: 7, + title: `What is DAOs`, + content: [ + { + item: "Decentralized Autonomous Organizations (or DAOs) are organizations managed in whole or in part by a decentralized computer program, with voting and finances handled through a blockchain. To put it simply: they are member-owned communities without centralized leadership.", + }, + ], + }, + { + id: 8, + title: `What is BYOB?`, + content: [ + { + item: "BYOB refers to Be Your Own Bank. Bitcoin and cryptocurrency were created during the height of the global financial crisis to eliminate the need for middlemen in peer-to-peer financial transactions. The crypto market has continued to evolve since then and grown into its own global financial system and with recent developments in the space, people no longer need banks – they can be their own.", + }, + ], + }, + { + id: 9, + title: `What makes Rubix green?`, + content: [ + { + item: "Rubix is the first L1 green blockchain in the world thanks to its highly secure, decentralized and peer to peer architecture. It’s revolutionary Proof-of-Pledge protocol allows each transaction to achieve finality without expensive mining so it doesn’t consume energy like other monolithic blockchains operating on Proof-of-Pledge and Proof-of-Stake. A Rubix node installed on an existing computer/system has negligible incremental energy usage, resulting in a carbon neutral impact. It also has zero gas fees.", + }, + { + item: "Thanks to its low energy and carbon footprint, Rubix is in a unique position to serve as a tool to curb climate change, rather than contribute to it. Rubix’s robust architecture helps with the digitization of climate data and decentralization of climate action. Rubix helps digitizing climate data by helping to collect, store, process and share data related to climate change and its impacts. It also helps to improve the accuracy, accessibility and usability of climate information by various stakeholders. Rubix helps with decentralization of climate action by helping the effectiveness, efficiency and equity of climate responses by taking advantage of the local knowledge, capacities and preferences of subnational actors. This fosters coordination between local governments and various stakeholders thereby increasing awareness and acceleration of climate actions including net zero, ESG and UN SDGs.", + }, + { + item: "Rubix has a number of applications within the environmental sector from decentralizing and gamifying climate action, to enabling businesses to meet net zero targets, to streamlining ESG reporting and carbon tracking while preventing greenwashing, to improving carbon markets and climate finance and beyond.", + }, + ], + }, + { + id: 10, + title: `what is subnet?`, + content: [ + { + item: "A subnet is a dynamic set of validators working together to achieve consensus on the state of a set of blockchains. Each blockchain is validated by exactly one subnet. A subnet can validate many blockchains. A node may be a member of many subnets.", + }, + { + item: "A subnet manages its own membership, and it may require that its constituent validators have certain properties.", + }, + { + item: "One of the most powerful features of the Rubix blockchain is its decentralized design and support for subnets. When a Rubix node is installed on a laptop or server, it instantly becomes part of the network. However, nodes on the network can also be grouped together to create a Rubix subnet. This subnet allows enterprises the flexibility, privacy, agility and scalability to embrace Web3 with minimal effort. Every enterprise or app can run its own subnet to benefit from Rubix’s zero gas fees, but third parties can run subnets for other users at cost.", + }, + { + item: "A Rubix subnet is always in sync with the network, avoiding the need for bridge interfaces required in other blockchains. Also in contrast to all other blockchains, Rubix subnets and nodes bring their own blockspace to the network, ensuring every transaction commits and exists in its own block. This allows for faster processing of transactions, avoids MEV attacks and facilitates roll back of any committed blocks in the future.", + }, + { + item: "In short, a Rubix subnet acts as a private blockchain connected to a public network, or as an application layer of an L1 network eliminating the need to have L2 blockchains.", + }, + ], + }, + { + id: 11, + title: `How can subnet help enterprises scale ?`, + content: [ + { + item: "The Rubix subnet allows enterprises, apps and users to create their own set of validators by choosing 21 nodes from their network. For a node to validate a transaction on the network, it needs to have sufficient credits or Rubix tokens (RBTs) to stake. The amount of credits and tokens required is based on the value of the transaction being validated. This design allows enterprises to create their own app tokens (which will be linked to Rubix tokens) to conduct transactions over the network, enabling a seamless business process flow, reducing payment costs and allowing instant settlements. For users of the subnet, the app token alone is visible, as the link to RBTs is handled in the background.", + }, + { + item: "If desired, an enterprise can list its app tokens on an exchange to help its stakeholders to trade their assets. Any enterprise can get started with a Rubix subnet by acquiring a certain amount of Rubix tokens and staking them in bulk to enable transaction flow within their subnet. As more validations are performed on the subnet, the enterprise will accumulate more credits from its proof of work efforts, increasing its staking power and the value of the transactions the subnet can validate.", + }, + { + item: "Similar to enterprises using Rubix subnets, dApps can leverage Rubix subnets to implement their use cases and tokenize assets. Rubix subnets act like an L2 blockchain but without any of their costs, deficiencies and risks. Every dApp naturally benefits from the inherent decentralized security, privacy and scalability offered by Rubix subnets. Hypothetically, if one or two subnets were to go offline, the remaining subnets and network would continue to operate without any impact – a feature that is unique to Rubix.", + }, + { + item: "An enterprise using a Rubix subnet can easily implement a tiered pricing model for its transactions, which would be impossible on any other existing blockchains,designed for linear pricing;the more transactions a blockchain processes, the higher its processing cost will be.", + }, + { + item: "Rubix subnets offer the greatest opportunity for migrating Web2 applications to Web3 and tokenizing assets without compromising user experiences. With bulk staking offered by Rubix subnets, enterprises can validate and settle their transactions instantly and independently of banks, payment processors and any other intermediaries.", + }, + ], + }, + { + id: 12, + title: `How is rubix diffrent from other blockchains?`, + content: [ + { + item: "The first green blockchain platform in the world, Rubix is a shared, decentralized and secure Web3 and Web5 platform, designed to eliminate the flaws and setbacks of traditional blockchains. The deep tech platform of tomorrow, Rubix has a number of differentiators that set it apart from others:", + bullet: + "Millions of concurrent transactions can seamlessly happen on the Rubix network.", + }, + ], + }, +]; + +const FaqStatic = () => { + return ( + + + + Frequently Asked Questions + + + + + {accordion.map((accord) => ( + <> + + {({ isExpanded }) => ( + <> +

+ + + {accord.title} + + {isExpanded ? ( + + ) : ( + + )} + +

+ + + {accord.content.map(({ item, bullet }) => ( + <> + {item} + {bullet && ( +

+ + {bullet} +

+ )} + + ))} +
+ + )} +
+ + ))} +
+
+
+
+ ); +}; + +export default FaqStatic; diff --git a/src/components/LearnPage/LearnBanner.jsx b/src/components/LearnPage/LearnBanner.jsx index 2452ef0..b30b3b3 100644 --- a/src/components/LearnPage/LearnBanner.jsx +++ b/src/components/LearnPage/LearnBanner.jsx @@ -148,6 +148,7 @@ const LearnBanner = () => { fontSize={"20px"} zIndex={"1"} overflow={"hidden"} + paddingInline={"4rem"} sx={{ "::before": { content: '""', diff --git a/src/components/LearnPage/LearnDev.jsx b/src/components/LearnPage/LearnDev.jsx index 2cdaf78..927ff33 100644 --- a/src/components/LearnPage/LearnDev.jsx +++ b/src/components/LearnPage/LearnDev.jsx @@ -8,6 +8,7 @@ import finalo from "../../assets/images/LearnCard1.png"; import jupiter from "../../assets/images/LearnCard3.png"; import { useMediaQuery } from "@chakra-ui/react"; import { useGetpartnerCardQuery } from "../../Redux/slice/learPageSlice"; +import DevCards from "../Card/DevCards"; // import { Badge } from "@chakra-ui/react"; @@ -114,7 +115,7 @@ const LearnDev = () => { }, }} > - {partnerCard?.map((item) => ( + {/* {partnerCard?.map((item) => ( { text={item.description} href={item.website_link} /> + ))} */} + {content.map((item) => ( + ))} diff --git a/src/components/LearnPage/WhyRubixStatic.jsx b/src/components/LearnPage/WhyRubixStatic.jsx new file mode 100644 index 0000000..f80cf08 --- /dev/null +++ b/src/components/LearnPage/WhyRubixStatic.jsx @@ -0,0 +1,182 @@ +import { Box, Container, Image, Text } from "@chakra-ui/react"; +import { + Accordion, + AccordionItem, + AccordionButton, + AccordionPanel, + AccordionIcon, +} from "@chakra-ui/react"; +import bg from "../../assets/images/whyRubix.webp"; +import cube from "../../assets/images/cube.png"; + +const accordion = [ + { + id: 1, + title: `Unlimited concurrent transactions`, + content: `The Rubix network supports millions of concurrent transactions + by eliminating the need to queue transactions for the + blockchain.`, + }, + { + id: 2, + title: `Scalability`, + content: `Every project has its own unique definition and requirement of infra scaling. + One Size doesn’t fit all!! The atomic & on-demand clustered object chain architecture of Rubix lets dApps control and auto scale their TPS.`, + }, + { + id: 3, + title: `Truly decentralised, secure and private`, + content: `The tamper-proof DID architecture and a quantum-resistant + NLSS algorithm enable true decentralisation without any vulnerabilities.`, + }, + { + id: 4, + title: `ROI friendly`, + content: `Whether you are migrating your architecture from Web2 to Web3, defining a brand new paradigm, + or developing your next dApp, Rubix allows you flexibility to build incrementally with ZERO gas fees.`, + }, +]; + +const WhyRubixStatic = () => { + return ( + + + + Why developers choose Rubix + + + + + {accordion.map((accord) => ( + <> + +

+ + + {accord.title} + + + +

+ + {accord.content} + +
+ + ))} +
+
+ + + +
+
+
+ ); +}; + +export default WhyRubixStatic; diff --git a/src/components/MobileMenu/MobileMenu.jsx b/src/components/MobileMenu/MobileMenu.jsx index ab9747f..dfbc03b 100644 --- a/src/components/MobileMenu/MobileMenu.jsx +++ b/src/components/MobileMenu/MobileMenu.jsx @@ -19,17 +19,12 @@ import { Button } from "@chakra-ui/react"; // import { HashLink } from "react-router-hash-link"; import logo from "../../assets/images/rubix.png"; import { useEffect, useState } from "react"; -import { useGetUseCaseQuery } from "../../Redux/slice/useCaseSlice"; export const MobileMenu = () => { const [isScrolled, setIsScrolled] = useState(false); const [menu, setMenu] = useState(false); const location = useLocation(); - const { data } = useGetUseCaseQuery(); - console.log(data); - const useCase = data?.data?.rows; - const handleClick = () => { setMenu(!menu); }; @@ -113,7 +108,7 @@ export const MobileMenu = () => { justifyContent={"space-between"} alignItems={"center"} padding={"2rem 1rem"} - marginBottom={"2rem"} + marginBottom={"1rem"} gap={"2rem"} sx={{ "@media (max-width: 1024px)": {}, @@ -252,25 +247,10 @@ export const MobileMenu = () => { - {useCase?.map((slug) => ( - - {slug.title} - - ))} - - {/* + FinTech + + { onClick={handleClick} > Telecom - */} + @@ -357,18 +337,18 @@ export const MobileMenu = () => { Wallet - Explore + Explorer diff --git a/src/components/ResourcesPage/tabInsideContent/WhitepaperDocs.jsx b/src/components/ResourcesPage/tabInsideContent/WhitepaperDocs.jsx index 0863e9a..67ccd84 100644 --- a/src/components/ResourcesPage/tabInsideContent/WhitepaperDocs.jsx +++ b/src/components/ResourcesPage/tabInsideContent/WhitepaperDocs.jsx @@ -25,7 +25,7 @@ const WhitepaperDocs = () => { } if (error) { - return
Error: {error.message}
; + return
{console.log(error)}
; } const docs = data?.data?.data; diff --git a/src/pages/LearnPage.jsx b/src/pages/LearnPage.jsx index 5f6cca5..e3916fe 100644 --- a/src/pages/LearnPage.jsx +++ b/src/pages/LearnPage.jsx @@ -7,6 +7,8 @@ import LearnBanner from "../components/LearnPage/LearnBanner"; import LearnDev from "../components/LearnPage/LearnDev"; import WhyRubix from "../components/LearnPage/WhyRubix"; import Loader from "../components/Loader/Loader"; +import FaqStatic from "../components/LearnPage/FaqStatic"; +import WhyRubixStatic from "../components/LearnPage/WhyRubixStatic"; const LearnPage = () => { useEffect(() => { @@ -18,9 +20,11 @@ const LearnPage = () => { <> - + {/* */} + - + {/* */} + ); };