Forem: Shain Dholakiya | shain.find

What is the Hyperverse from a Developer POV?

Shain Dholakiya | shain.find — Tue, 31 May 2022 04:48:55 +0000

You might be wondering exactly how are we onboarding these new Web Developers? We’re making this possible by implementing our “Smart Modules.” All Smart Modules on the Hyperverse have already had their smart contracts developed, so Web Developers do not need to know how they were written to interact with them. You can think of it as a similar environment to the npm modules we use for everyday Web2 development, but an ecosystem of modules for building decentralized applications tied to different blockchains.

The Hyperverse community contains a number of roles focused on providing the most secure and accessible experience for all Hyperverse Smart Modules.

**Smart Contract Developers: **Build Smart Modules single-purpose on-chain contracts with a per-transaction revenue model.
Hyperverse Registrars: Validate Smart Module packages and discovery metadata, then approve for publishing.
Hyperverse Auditors: Auditors in the community verify the code and stake their tokens, indicating their confidence in the model. The stake acts as an insurance layer for Smart Modules.
JavaScript Developers: Use JavaScript to build Web3 apps just by connecting Smart Modules

This blog post will primarily focus on the first and last roles.

Three-tier Model

For JavaScript Developers, the Hyperverse can be broken up into a three-tier model comprised of a top, middle, and bottom layer. Let’s dive in to get a better understanding.

1/ The topmost layer is simply the Hyperverse module that initializes the entire environment in a single command and is also our composability feature. Web Developers can easily wire up different APIs to create decentralized applications.

2/ After setting up the development environment, you will then be able to choose which blockchain you’d like to use your Smart Modules on and build with.

The Hyperverse currently supports the Algorand, Ethereum, Flow, and Metis blockchains.

3/ Lastly is the bottom layer, where developers choose which Smart Modules they would like to implement using their blockchain of choice. The Hyperverse consists of a few modules like Tribes, Token, ERC-721, and Random Pick. These are great project examples for developers to use for Ethereum that will help get them familiar with the environment. The Hyperverse Monorepo contains code packages and applications for the Hyperverse.

packages: Blockchain implementations and smart modules.
apps: Example applications organized by blockchain.

You can hook up your application to the Hyperverse to start building your Dapp and importing Smart Modules to use in just three steps.

After selecting your Smart Module of choice, you can then use your knowledge of React to build decentralized applications with all the functionalities of that module. This makes development much more accessible because your development process has eliminated the frustrations of understanding smart contract code.

It is also at the bottom layer where the multi-tenancy component of the Hyperverse becomes important. Every Web Developer has a unique Tenant ID generated for them. The tenant ID is tied to the blockchain of your choice (different blockchains generate tenant IDs differently), which is then utilized in your module(s). The ID is your record in the database that will separate your module’s data from another web developer’s.

Here is an excellent HyperBites video that explains this concept with an example using the Tribes Smart Module.

Smart Module

Smart Contract Developers would be building Smart Modules on the Hyperverse using the Builder Kit (a composable starter kit for Smart Contract Developers to build Smart Modules).

A Smart Module is a package containing a smart contract, metadata, unit tests, and documentation at a minimum. It can optionally include a user interface test harness and sample code. The smart contract will typically implement a blockchain application primitive — one feature that provides discrete functionality. For example, a Subscription Smart Module makes it simple for an application to check if the calling account is an active subscriber for a specific feature.

An important characteristic of Smart Modules is their multi-tenancy, as mentioned previously. This structure models SaaS applications in Web2 that are typically single applications serving many different users. Smart Modules do this by separating the smart contract logic (which resides on-chain in the Hyperverse-deployed smart contract) from the associated data (which also resides on-chain but in the account of the calling smart contract). This is a unique feature of Hyperverse Smart Modules and is designed to address many scenarios where it is necessary for calling applications to use composable smart contract rules but store data in their own account space.

Below is an example of the TribesFactory smart contract used for the Tribes Smart Module. This contract shows the power of composability and the multi-tenancy architecture. You can find the Tribes Smart Module code here.

Here is a great tutorial on building your Smart Module on the Hyperverse.

Revenue Model

While using pre-developed Smart Modules is a huge aspect of the Hyperverse, it is also a space for you to develop your own. Since our tool operates as a marketplace, the approved modules for public usage can generate income for whoever created them when other web developers utilize them.

As the Hyperverse grows and more Smart Modules are developed, the possibilities of what you can implement in your decentralized applications will expand.

In short, for Web2 Developers, the Hyperverse allows you to

Build blockchain applications without writing smart contracts
Access well-written, reviewed, and audited smart contract code
Get support from a growing community of enthusiastic developers

It’s time to find your place to settle as an aspiring Web3 Developer. We want to help make your dreams of building decentralized applications a reality and join our mission to onboard 10 million Web Developers to Web3.

Check out our docs for more information, join our community on Discord, and start building right away. LFG! 🚀

How to Get Hooked Up to the Hyperverse From Scratch

Shain Dholakiya | shain.find — Mon, 23 May 2022 15:17:49 +0000

What is the Hyperverse?

GM! Today, I will be guiding you through everything you need to do to get your app hooked up to the Hyperverse so you can start building killer web3 apps.

Step 1: Install Node to be able to import and use the NPM

Step 2: Install create-next-app and run npx create-next-app example-dapp --ts

This will automatically build a folder named example-dapp which is a Next.js application that uses Typescript
--ts is to create the build using Typescript which is not required, but highly encouraged

Step 3: Install packages

cd example-dapp: This simply allows us to change the directly since we are now working inside the example project’s folder
yarn - npm i -g yarn
-g is not required as all it does is give your entire machine access to using yarn instead of just this project
yarn add @decentology/hyperverse
yarn add @decentology/hyperverse-ethereum
Installing these packages simply gives the project the ability to now import and actually use these packages

You can also choose to build on other chains that we currently support by doing:

yarn add @decentology/hyperverse-flow
yarn add @decentology/hyperverse-metis

Step 4: Import packages

You should see something like this in your _app.tsx file:

import "../styles/globals.css";

import type { AppProps } from "next/app";

function MyApp({ Component, pageProps }: AppProps) {

   return <Component {...pageProps} />

}

export default MyApp;

Now, add these two lines of code above the function:

import { initialize, Provider, Network } from '@decentology/hyperverse';

import { Ethereum } from '@decentology/hyperverse-ethereum';

We are now importing these packages which gives our code access to the functionality that they provide. This will help us with wallet connection, access to view the user’s address, access to read and let users know when they need to switch networks, and access to blockchain-specific SDK features.

Step 5: Initialize the Hyperverse

Add this code inside the function before the return statement:

const hyperverse = initialize({

   blockchain: Ethereum,

  network: Network.Testnet,

   modules: [],

});

This allows us to actually initialize the Hyperverse with the given parameters. In this case, we are initializing it using the Ethereum blockchain and Rinkeby Test Network.

You can find all the available blockchains at this path

Step 6: Wrap the app in the Hyperverse Provider:

return (

 <Provider initialState={hyperverse}>

     <Component {...pageProps} />

  </Provider>

)

The Provider makes hyperverse available to any nested components that need access to it. In this case we want the entire app to have access to it which is why we do it here!

Step 7: Your app is officially hooked up to the Hyperverse and ready to buidl!

The end result should look something like this:

import '../styles/globals.css'

import type { AppProps } from 'next/app'

import { initialize, Provider, Network } from '@decentology/hyperverse';

import { Ethereum } from '@decentology/hyperverse-ethereum';

function MyApp({ Component, pageProps }: AppProps) {

   const hyperverse = initialize({

       blockchain: Ethereum,

      network: Network.Testnet,

      modules: [],

   });

   return (

     <Provider initialState={hyperverse}>

        <Component {...pageProps} />

     </Provider>

   )

}

export default MyApp

Run yarn dev to see your app running on localhost:3000!

Here is the GitHub repo that follows these steps and you can fork it if you wish!

Next steps: Join our discord to connect with the Hyperverse team and other builders building on the Hyperverse!

The Hyperverse

Shain Dholakiya | shain.find — Mon, 16 May 2022 22:42:18 +0000

Many of you probably clicked on this post because you were intrigued by the title and wondered what the heck the Hyperverse was. I am here to tell you that it will be the number one tool that developers use to start building Dapps in Web3. Let me explain.

Decentology is building the Hyperverse, a community-built, open, audited, marketplace for composable smart contracts for all major blockchains. Decentology is also creating innovative solutions for smart contract development, security, monetization, and discoverability that work cross-chain on the Hyperverse, resulting in the most comprehensive marketplace for smart contracts ever created.

In short, the Hyperverse makes it extremely simple for Web2 developers to build Dapps without writing a single line of smart contract code and only using JavaScript. The Hyperverse is the NPM for smart contracts.

Go here to learn more about Decentology and the Hyperverse.

Follow me to stay up-to-date on tutorials that will guide you step-by-step on how to build Dapps with the Hyperverse.

AMA

Shain Dholakiya | shain.find — Thu, 21 Apr 2022 17:08:53 +0000

A place for anyone to ask me questions about any topic relating to Web2, Web3, or tech in general!

I will try my best to reply to your questions with a concrete answer or point you in the right direction.

Ask away 🚀