Interacting with HyperVMs with a Javascript SDK

[kpachhai]

We recently launched our devnet for Nuklai - a Layer 1 blockchain network built using HyperSDK. You can check out our documentation to learn more about it and how you can start interacting with the devnet via RPC endpoints or a CLI or Javascript SDK. For info regarding the devnet specifically, you can refer to https://docs.nukl.ai/nuklai-network/nuklai-testnet

We started to research HyperSDK about 6 months ago and before we knew it, we fell into a deep rabbit hole full of new ideas, new capabilities and very developer friendly way of building a layer 1 blockchain within a matter of days. I wrote an article talking about my own journey into the world of HyperSDK that was recently featured on Hackernoon.

Suffice to say, the entirety of the Nuklai team was hooked in to what HyperSDK had to offer and we wanted to do more. We wanted to spread awareness of our own journey and wanted to share a lot of the tools and resources that we use internally which led to the development of the Nuklai Javascript SDK.

While we were building our wallet for Nuklai, we stumbled upon an issue because there was no javascript SDK to interact with HyperVMs. We started to work on it for our own use but I believe something similar could be done that's more generic and could work with any hypervm(not just NuklaiVM).

We were able to get the most basic version of the SDK working. You can check it out at https://github.com/Nuklai/nuklai-js-sdk/tree/v0.1.0

The README should contain all the information you need to get started but we have also provided with some examples code that you can just run on your machine(all you need to do is change the RPC node URL and blockchain ID in these example files and just run like any other node.js file).
Anyways, this is what the SDK can do currently:

• Interact with the RPC node of Nuklai. Works for both local and official testnet. This means you are able to call any of the existing RPC API endpoints that Nuklai exposes such as getting network info, genesis info, asset info, balance, transaction info, emission info, validators and delegators info, etc
• The SDK currently supports BLS and ED25519 so you're able to generate key pairs for any of these key types, import your private key, and do a lot of other things related to the auth. Will put in support for SECP256R1 on the next version
• The SDK currently supports creating and submitting a transaction to the network using your private key. It only supports a basic transfer of NAI or any other user created assets however, next version will support other action types such as creating asset, minting asset, delegating NAI to validators, claiming rewards, undelegating, etc.

This is a good starting point as majority of the legwork has been done. Tricky part was supporting the key generation and dealing with low level packaging of bytes before submitting the transactions to the network.

What's next?
It would be amazing if we make this SDK a bit more generic that works with any type of hypervm out there(not just NuklaiVM) so other developers in the HyperSDK community could also use the SDK to interact with their own blockchain. And then, Nuklai SDK would be updated to use this generic hypervm sdk so most stuff would be abstracted away for us.

Feel free to try out the SDK with Nuklai testnet or maybe in your own custom subnet you've been building using hypersdk. Would love to hear feedback from others so we can improve it and work towards a common sdk that could be utilized by everyone.

To get started with Nuklai testnet, feel free to check out https://docs.nukl.ai/nuklai-network/nuklai-testnet/interact-with-testnet

[kpachhai]

Gave a major update to our SDK.

We split our original SDK into two repos:

1. Hyperchain JS SDK: This repo contains most of the code a hypersdk dev would need to interact with their own hypervm. This is a very generic SDK that doesn't have a lot of things other than the common libraries for auth, actions, codec, etc. This is of course the first version and will be changing but here's the first version: https://github.com/Nuklai/hyperchain-js-sdk It's also published to npmjs under @nuklai/hyperchain-sdk.
2. Nuklai JS SDK: This repo uses Hyperchain JS SDK and is very much custom built for NuklaiVM. We have also published it to npmjs under @nuklai/nuklai-sdk. You could likely fork this repo and customize it to your own Hypervm. https://github.com/Nuklai/nuklai-js-sdk

Also updated both the SDKs to make it compatible with both node and browser environments so it should work everywhere.

I also created a simple React app that integrates the SDK to do some very basic things such as get health status, import private keys, transfer assets to other users, create asset, mint asset, etc. Check it out at https://github.com/kpachhai/nuklai-sdk-demo. This of course uses both Nuklai JS SDK and Hyperchain JS SDK. Very early demo of a working version of the React app that integrates with the SDK.

Having this separation will make it easier for the hypersdk devs to contribute to the generic SDK(Hyperchain JS SDK) as this could be used by anyone to build their own SDK for their own custom VM.

Any feedback is appreciated as always.

[Developerayo]

Nuklai Wallet [DEVNET] is live

We've made significant progress on the Nuklai Wallet, which is live here. This implementation shows the practical application of our NuklaiVM built on Avalanche's HyperSDK

The Nuklai Wallet itself is built with our Hyperchain JS SDK and Nuklai SDK, which we discussed in the last update from @kpachhai. It's been a journey getting here, and I wanted to share a little more detail on how our wallet works:.

First off, the wallet supports all the basic operations you'd expect — sending and receiving our native NAI tokens, viewing transactions history, etc. But where it gets really interesting is with custom assets. You can also create and mint your own tokens right from the wallet:

The current version of the wallet supports the following features:

• Explorer for previewing newly produced blocks on the NuklaiVM, and the number of transactions in embedded in each block.
• Requesting Faucet for NAI Test Tokens.
• Transferring Tokens (Native & Custom Tokens).
• Creation of Custom Assets/Tokens.
• Importation of Sent Assets/Tokens.

These are achieved from the methods we implemented in the @nuklai/nuklai-sdk namely:

export declare class RpcService extends common.Api {
    protected configNuklai: config.NodeConfig;
    constructor(configNuklai: config.NodeConfig);
    getTransactionInfo(getTransactionInfoParams: GetTransactionInfoParams): Promise<GetTransactionInfoResponse>;
    getBalance(getBalanceParams: GetBalanceParams): Promise<GetBalanceResponse>;
    getAssetInfo(getAssetInfoParams: GetAssetInfoParams): Promise<GetAssetInfoResponse>;
    sendTransferTransaction(to: string, asset: string, amount: number, memo: string, authFactory: auth.AuthFactory, hyperApiService: services.RpcService, actionRegistry: chain.ActionRegistry, authRegistry: chain.AuthRegistry): Promise<string>;
    sendCreateAssetTransaction(symbol: string, decimals: number, metadata: string, authFactory: auth.AuthFactory, hyperApiService: services.RpcService, actionRegistry: chain.ActionRegistry, authRegistry: chain.AuthRegistry): Promise<{
        txID: string;
        assetID: string;
    }>;
    sendMintAssetTransaction(to: string, asset: string, amount: number, authFactory: auth.AuthFactory, hyperApiService: services.RpcService, actionRegistry: chain.ActionRegistry, authRegistry: chain.AuthRegistry): Promise<string>;
}

These methods are built into the Nuklai SDK to cater for the listed features in the wallet. Let's explore them more closely.

Using the Explorer

When you visit Nuklai Wallet for the first time, you will see a popup informing you that the wallet is currently in the Alpha stage, and feedback is welcomed. Click on "Don't show this again" to continue. The first page is the Explorer page. On it, you will find recent activities ongoing on the Nuklai blockchain — newly produced blocks and their individual elements.

Click Don't show this again

The number of active accounts on the Nuklai network, as well as the TPS and unit prices will be available in due time.

Creating new assets

As mentioned, the Nuklai Wallet supports the creation and minting of new, custom assets/tokens directly from the wallet. For token creation or minting to work, you must have enough gas fee in your wallet. You can get test NAI tokens in the Faucet page as explained later below.

How it works:

The handleCreateAsset function sets up the asset creation process, and uses the sdk.rpcServiceNuklai.sendCreateAssetTransaction method from the @nuklai/nuklai-js-sdk library to create the asset. We wait for confirmation to be sure that the new asset has been fully processed, and is now available on the Nuklai blockchain before proceeding to store it locally by the assetID. Once confirmed, the new asset is added to storage and displayed in the wallet.

const handleCreateAsset = useCallback(async (values) => {
 setModalType("");
 // Creating asset
 const authFactory = auth.getAuthFactory(keyType, privateKey);
 const { txID, assetID } = await sdk.rpcServiceNuklai.sendCreateAssetTransaction(
     values.symbol,
     values.decimals,
     values.metadata || "{}",
     authFactory,
     sdk.rpcService,
     sdk.actionRegistry,
     sdk.authRegistry
 );
 setmyTokens(prev => [...prev, assetID]);
 await waitForAssetConfirmation(assetID);
 addAssetIDToStorage(assetID, txID, values.symbol);
 addTransactionIDToStorage(txID);
 createForm.resetFields();
 getAllAssetsAndBalances();
}, [keyType, privateKey, addAssetIDToStorage, addTransactionIDToStorage, getAllAssetsAndBalances, createForm]);


The wallet the supports the minting of the supply of created assets through the `handleMintAsset`  function, utilizing the `sdk.rpcServiceNuklai.sendMintAssetTransaction` method in `@nuklai/nuklai-js-sdk` to mint new tokens to the user's address. Once the additional supply has been minted, the new token supply balance is updated and reflected in the wallet.

const handleMintAsset = useCallback(async (values) => {
 setModalType('');
 // Minting asset
 const authFactory = auth.getAuthFactory(keyType, privateKey);
 const txID = await sdk.rpcServiceNuklai.sendMintAssetTransaction(
     address,
     selectedAsset.id,
     values.amount,
     authFactory,
     sdk.rpcService,
     sdk.actionRegistry,
     sdk.authRegistry
 );
 addTransactionIDToStorage(txID);
 await updateAssetBalance(selectedAsset.id, values.amount);
 mintForm.resetFields();
 setTimeout(() => getAllAssetsAndBalances(), 5000);
}, [keyType, privateKey, selectedAsset, addTransactionIDToStorage, updateAssetBalance, getAllAssetsAndBalances, mintForm]);

Transferring tokens

The Nuklai wallet facilitates the transfer of tokens between two users by leveraging our @nuklai/nuklai-sdk and @nuklai/hyperchain-sdk.

In order to allow users securely transfer tokens, we constructed an AuthFactory builder using the sender's private key and use that instance to authorize the sdk.rpcServiceNuklai.sendTransferTransaction method. Doing so makes sure that the transaction is authorized and signed correctly by the sender.

The AuthFactory interface

The AuthFactory is an interface in the @nuklai/hyperchain-sdk used to generate and manage cryptographic keys and signatures. It generates cryptographic key pairs (private and public keys) and has a primary function of signing messages (transactions) with the private key. It also provides methods to verify the authenticity of the signed messages, to make sure that they have not been tampered with.

The transaction status is tracked, and the appropriate user success/failure feedback is provided, as seen below:

const handleTransfer = async (values) => {
  // Processing transaction
  const authFactory = auth.getAuthFactory(keyType, privateKey);
  const txID = await sdk.rpcServiceNuklai.sendTransferTransaction(
    values.Address,
    values.Asset,
    values.Amount,
    values.Memo,
    authFactory,
    sdk.rpcService,
    sdk.actionRegistry,
    sdk.authRegistry
  );
  await waitForTransactionConfirmation(txID);
  addTransactionIDToStorage(txID);
  transferForm.resetFields();
};

Importation of Sent Assets/Tokens.

The Nuklai Wallet also supports importing assets/tokens if not already listed on your wallet. Technically, we import tokens into the Nuklai Wallet using the @nuklai/nuklai-js-sdk. It checks the validity of the asset ID, ensures the token is not already in the wallet, and then uses the sdk.rpcServiceNuklai.getAssetInfo method to fetch the asset information. After fetching the asset information, it stores the asset ID and symbol in the users's local storage using the addAssetIDToStorage function.

const handleImportToken = useCallback(async () => {
  if (newAsset.includes(' ') || newAsset.length < 32 || assetIDs.some(asset => asset.id === newAsset)) {
    return;
  }
  const assetInfo = await sdk.rpcServiceNuklai.getAssetInfo({ asset: newAsset });
  addAssetIDToStorage(newAsset, '', assetInfo.symbol);
  setNewAsset('');
}, [addAssetIDToStorage, assetIDs, newAsset]);

Configurations

Under the wallet drawer, there is a "Configuration" card that shows the Base API URL, Blockchain ID, and Key Type. These configuration settings are initially set during the wallet setup and are not editable through the UI.

We've put a lot of effort into making the wallet DevNet ready, but we're always making improvements, so a couple of things could break sometime. If any of you HyperSDK devs out there give it a try, we'd love to hear your thoughts. What actions would you like to see implemented on the NuklaiVM and on the Wallet? And if there are any pain points we should address.

Lastly, for those of you building your own HyperVMs, feel free to take a look at our implementation of the NuklaiVM here. We've tried to keep things modular, so you should be able to adapt much of the code for your own projects.

Looking forward to your feedback and seeing what amazing things you all build with HyperSDK!