DEV Community: Gajesh Naik

Hello World AVS: Dev Entrypoint

Gajesh Naik — Sat, 01 Jun 2024 21:45:22 +0000

Welcome to the second post in our series on EigenLayer. Today, we'll dive into a practical example with the "Hello World" AVS (Actively Validated Service). This guide will help you understand the basic components and get started with your own AVS on EigenLayer.

What is the Hello World AVS?

The "Hello World" AVS is a simple implementation designed to demonstrate the core mechanics of how AVSs work within the EigenLayer framework. This example walks you through the process of requesting, generating, and validating a simple "Hello World" message.

Key Components of Hello World AVS

AVS Consumer: Requests a "Hello, {name}" message to be generated and signed.
AVS: Takes the request and emits an event for operators to handle.
Operators: Picks up the request, generates the message, signs it, and submits it back to the AVS.
Validation: Ensures the operator is registered and has the necessary stake, then accepts the submission.

Setting Up Your Environment

Before you start, ensure you have the following dependencies installed:

npm: Node package manager
Foundry: Ethereum development toolchain
Docker: Containerization platform

Quick Start Guide

Start Docker:
Ensure Docker is running on your system.
Deploy Contracts:
Open a terminal and run:

   make start-chain-with-contracts-deployed

This command builds the contracts, starts an Anvil chain, deploys the contracts, and keeps the chain running.

Start the Operator: Open a new terminal tab and run:

   make start-operator

This will compile the AVS software and start monitoring for new tasks.

(Optional) Spam Tasks: To test the AVS with random names, open another terminal tab and run:

   make spam-tasks

Hello World AVS: Code Walkthrough

In this section, we'll break down the code behind the "Hello World" Actively Validated Service (AVS) to understand its functionality and how it leverages EigenLayer.

Smart Contract: `HelloWorldServiceManager`

The HelloWorldServiceManager contract is the primary entry point for procuring services from the HelloWorld AVS. Here's a step-by-step explanation:

Imports and Contract Declaration:

   import "@eigenlayer/contracts/libraries/BytesLib.sol";
   import "@eigenlayer/contracts/core/DelegationManager.sol";
   import "@eigenlayer-middleware/src/unaudited/ECDSAServiceManagerBase.sol";
   import "@eigenlayer-middleware/src/unaudited/ECDSAStakeRegistry.sol";
   import "@openzeppelin-upgrades/contracts/utils/cryptography/ECDSAUpgradeable.sol";
   import "@eigenlayer/contracts/permissions/Pausable.sol";
   import {IRegistryCoordinator} from "@eigenlayer-middleware/src/interfaces/IRegistryCoordinator.sol";
   import "./IHelloWorldServiceManager.sol";

   contract HelloWorldServiceManager is 
       ECDSAServiceManagerBase,
       IHelloWorldServiceManager,
       Pausable
   {
       // ...
   }

This section imports necessary libraries and defines the contract, inheriting from ECDSAServiceManagerBase, IHelloWorldServiceManager, and Pausable.

Storage Variables:

   uint32 public latestTaskNum;
   mapping(uint32 => bytes32) public allTaskHashes;
   mapping(address => mapping(uint32 => bytes)) public allTaskResponses;

latestTaskNum: Keeps track of the latest task index.
allTaskHashes: Maps task indices to task hashes.
allTaskResponses: Maps operator addresses and task indices to responses.

Constructor:

   constructor(
       address _avsDirectory,
       address _stakeRegistry,
       address _delegationManager
   )
       ECDSAServiceManagerBase(
           _avsDirectory,
           _stakeRegistry,
           address(0),
           _delegationManager
       )
   {}

Initializes the contract with the necessary addresses.

Creating a New Task:

   function createNewTask(
       string memory name
   ) external {
       Task memory newTask;
       newTask.name = name;
       newTask.taskCreatedBlock = uint32(block.number);

       allTaskHashes[latestTaskNum] = keccak256(abi.encode(newTask));
       emit NewTaskCreated(latestTaskNum, newTask);
       latestTaskNum = latestTaskNum + 1;
   }

This function creates a new task, assigns it a unique index, and stores its hash on-chain.

Responding to a Task:

   function respondToTask(
       Task calldata task,
       uint32 referenceTaskIndex,
       bytes calldata signature
   ) external onlyOperator {
       require(
           operatorHasMinimumWeight(msg.sender),
           "Operator does not have match the weight requirements"
       );
       require(
           keccak256(abi.encode(task)) ==
               allTaskHashes[referenceTaskIndex],
           "supplied task does not match the one recorded in the contract"
       );
       require(
           allTaskResponses[msg.sender][referenceTaskIndex].length == 0,
           "Operator has already responded to the task"
       );

       bytes32 messageHash = keccak256(abi.encodePacked("Hello, ", task.name));
       bytes32 ethSignedMessageHash = messageHash.toEthSignedMessageHash();

       address signer = ethSignedMessageHash.recover(signature);

       require(signer == msg.sender, "Message signer is not operator");

       allTaskResponses[msg.sender][referenceTaskIndex] = signature;

       emit TaskResponded(referenceTaskIndex, task, msg.sender);
   }

This function allows operators to respond to tasks, verifying their identity and the integrity of their response.

Helper Function:

   function operatorHasMinimumWeight(address operator) public view returns (bool) {
       return ECDSAStakeRegistry(stakeRegistry).getOperatorWeight(operator) >= ECDSAStakeRegistry(stakeRegistry).minimumWeight();
   }

Checks if an operator meets the minimum weight requirement.

Operator Client Code

The operator client code interacts with the smart contract to register operators, monitor tasks, and respond to them.

Setup:

   import { ethers } from "ethers";
   import * as dotenv from "dotenv";
   import { delegationABI, contractABI, registryABI, avsDirectoryABI } from "./abis";
   dotenv.config();

   const provider = new ethers.providers.JsonRpcProvider(process.env.RPC_URL);
   const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

Configures the provider and wallet using environment variables.

Registering an Operator:

   const registerOperator = async () => {
       const tx1 = await delegationManager.registerAsOperator({ ... });
       await tx1.wait();
       console.log("Operator registered on EL successfully");

       const salt = ethers.utils.hexlify(ethers.utils.randomBytes(32));
       const expiry = Math.floor(Date.now() / 1000) + 3600;

       const digestHash = await avsDirectory.calculateOperatorAVSRegistrationDigestHash(wallet.address, contract.address, salt, expiry);
       const signingKey = new ethers.utils.SigningKey(process.env.PRIVATE_KEY);
       const signature = signingKey.signDigest(digestHash);

       const operatorSignature = { expiry, salt, signature: ethers.utils.joinSignature(signature) };

       const tx2 = await registryContract.registerOperatorWithSignature(wallet.address, operatorSignature);
       await tx2.wait();
       console.log("Operator registered on AVS successfully");
   };

Registers the operator with both the delegation manager and the AVS.

Monitoring and Responding to Tasks:

   const signAndRespondToTask = async (taskIndex, taskCreatedBlock, taskName) => {
       const message = `Hello, ${taskName}`;
       const messageHash = ethers.utils.solidityKeccak256(["string"], [message]);
       const messageBytes = ethers.utils.arrayify(messageHash);
       const signature = await wallet.signMessage(messageBytes);

       const tx = await contract.respondToTask({ name: taskName, taskCreatedBlock }, taskIndex, signature);
       await tx.wait();
       console.log(`Responded to task.`);
   };

   const monitorNewTasks = async () => {
       await contract.createNewTask("EigenWorld");

       contract.on("NewTaskCreated", async (taskIndex, task) => {
           console.log(`New task detected: Hello, ${task.name}`);
           await signAndRespondToTask(taskIndex, task.taskCreatedBlock, task.name);
       });

       console.log("Monitoring for new tasks...");
   };

Monitors for new tasks and responds with a signed message.

Main Function:

   const main = async () => {
       await registerOperator();
       monitorNewTasks().catch(console.error);
   };

   main().catch(console.error);

Initializes the process by registering the operator and starting task monitoring.

Task Spammer

A simple script to create tasks at regular intervals for testing purposes.

Setup:

   import { ethers } from 'ethers';

   const provider = new ethers.providers.JsonRpcProvider(`http://127.0.0.1:8545`);
   const wallet = new ethers.Wallet('your-private-key', provider);
   const contractAddress = 'your-contract-address';
   const contractABI = [ ... ];
   const contract = new ethers.Contract(contractAddress, contractABI, wallet);

Generating Random Names:

   function generateRandomName() {
       const adjectives = ['Quick', 'Lazy', 'Sleepy', 'Noisy', 'Hungry'];
       const nouns = ['Fox', 'Dog', 'Cat', 'Mouse', 'Bear'];
       return `${adjectives[Math.floor(Math.random() * adjectives.length)]}${nouns[Math.floor(Math.random() * nouns.length)]}${Math.floor(Math.random() * 1000)}`;
   }

Creating New Tasks:

   async function createNewTask(taskName) {
       try {
           const tx = await contract.createNewTask(taskName);
           const receipt = await tx.wait();
           console.log(`Transaction successful with hash: ${receipt.transactionHash}`);
       } catch (error) {
           console.error('Error sending transaction:', error);
       }
   }

   function startCreatingTasks() {
       setInterval(() => {
           const randomName = generateRandomName();
           console.log(`Creating new task with name: ${randomName}`);
           createNewTask(randomName);
       }, 15000);
   }

   startCreatingTasks();

Conclusion

This post delved into the "Hello World" AVS example, exploring the smart contract and operator client code in detail. This foundational understanding sets the stage for more advanced applications and custom AVS development.

Stay tuned as we continue this series, where we will cover more AVS examples and provide comprehensive guides to building with AVSs on EigenLayer. Exciting innovations await as we leverage the full potential of this powerful protocol!

Introduction to EigenLayer

Gajesh Naik — Sat, 01 Jun 2024 21:32:13 +0000

Welcome to the first post in our series on EigenLayer! In this series, we'll explore how EigenLayer is transforming the Ethereum ecosystem by enabling the creation of Actively Validated Services (AVSs). Whether you're a seasoned developer or new to the world of blockchain, this guide will help you understand and leverage the potential of EigenLayer.

What is EigenLayer?

EigenLayer is a decentralized protocol built on the Ethereum blockchain. It introduces a novel concept: the ability to "restake" ETH that is already staked for securing the Ethereum network to provide additional security and validation for new decentralized applications (dApps) and services. This process enhances the utility of staked ETH, allowing it to be used for multiple purposes simultaneously.

Key Concepts

Restaking: This is the cornerstone of EigenLayer. It allows Ethereum stakers to opt-in their staked ETH to secure various AVSs. By doing so, the staked ETH can serve multiple roles without the need for additional capital.
Actively Validated Services (AVSs): These are the services and applications that utilize the security provided by restaked ETH. Examples include oracles, bridges, Layer 2 solutions, and more. AVSs benefit from the robust security model of the Ethereum network while adding their own unique functionalities.
Cryptoeconomic Security: EigenLayer ensures that the restaked ETH is used responsibly. If an operator (like Joe in our previous example) misbehaves or acts maliciously, they get slashed. This means they lose a portion of their staked ETH, which provides a strong incentive to act honestly.

How Does EigenLayer Work?

Let’s break down the process using a simple example:

Building an AVS: Imagine James is a developer who wants to build an oracle service. An oracle provides trusted data feeds, which are crucial for many blockchain applications, like Julien’s lending protocol.
Running the AVS: Joe, who has significant compute power, decides to run James's oracle service. However, to ensure that Joe behaves correctly, he needs to be economically incentivized.
Providing Security: Jake, an Ethereum staker, delegates his staked ETH to Joe’s service via EigenLayer. This delegation provides cryptoeconomic security to the oracle service.
Ensuring Integrity: If Joe reports incorrect data (goes rogue), the protocol slashes his staked ETH. This slashing means Jake loses his staked ETH, covering any potential losses for users like Julien.

Why is EigenLayer Important?

EigenLayer brings several key benefits to the Ethereum ecosystem:

Enhanced Utility of Staked ETH: It maximizes the utility of staked ETH by allowing it to secure multiple services.
Robust Security: The cryptoeconomic security model ensures that services are reliable and operators are incentivized to act honestly.
Flexible and Composable: Developers can create a wide range of services, from oracles to Layer 2 solutions, all benefiting from the security provided by EigenLayer.

Getting Started with EigenLayer

In the upcoming posts, we’ll dive deeper into how you can start building on EigenLayer. We’ll cover topics like setting up your development environment, creating and deploying AVSs, and best practices for ensuring security and reliability.

Stay tuned as we embark on this journey to explore the limitless possibilities enabled by EigenLayer. Whether you’re looking to enhance existing applications or build new innovative services, EigenLayer provides the foundation to do so securely and efficiently.

Welcome to the future of decentralized services with EigenLayer!

Deploy Smart Contract on Binance Smart Chain

Gajesh Naik — Wed, 03 Feb 2021 14:27:35 +0000

Ethereum Gas fees are getting expensive day-by-day. So, Binance launched a solution "Binance Smart Chain" with gas fees less than 5 cents ($0.05) but developers face one issue. That is how to deploy their smart contract on BSC.

If you are a video learner, here's the link: Click here. It will redirect you to detailed YouTube Video

Requirements:
Metamask Wallet

Steps:
1) Connect your metamask to Binance Smart Chain
2) Open remix.ethereum.org
3) Create smart contract
4) Write Smart Contract
5) Select RPC to Smart Chain
6) Deploy

It will cost $0.05 for deploying your smart contract on Binance smart chain
BSC

GPT-3 Explained

Gajesh Naik — Sun, 04 Oct 2020 11:28:03 +0000

Hello, Readers… California based AI research foundation named OpenAI, started by Elon Musk, Sam Altman, Greg Brockman, and a few other leaders in ML, recently released an API and website that allows people to access a new language model called GPT-3.

For comparison, the previous version, GPT-2, was made up of 1.5 billion parameters. The largest Transformer-based language model was released by Microsoft earlier this month and is made up of 17 billion parameters.

“GPT-3 achieves strong performance on many NLP datasets, including translation, question-answering, and cloze tasks, as well as several tasks that require on-the-fly reasoning or domain adaptation, such as unscrambling words, using a novel word in a sentence, or performing 3-digit arithmetic,” the researchers stated in their paper. “We find that GPT-3 can generate samples of news articles which human evaluators have difficulty distinguishing from articles written by humans,” they add.

Natural language processing tasks range from generating news articles, to language translation, to answering standardized test questions.

OpenAI trains all of their AI models on the cuDNN-accelerated PyTorch deep learning framework.

Let me also recollect for your perusal that earlier this month Microsoft and OpenAI announced a new GPU-accelerated supercomputer built exclusively for the organization.

The original GPT, and GPT-2, are both adaptations of what’s known as a Transformer, an invention pioneered at Google in 2017. The Transformer uses a function called attention to calculate the probability that a word will appear given surrounding words. OpenAI caused controversy a year ago when it said it would not release the source code to the biggest version of GPT-2, because, it said, that code could fall into the wrong hands and be abused to mislead people with things such as fake news.

GPT-3 is essentially a context-based generative AI. This means that when the AI is given some sort of context, it then tries to fill in the rest. If you give it the first half of an essay, it will generate the rest of the essay.

“The supercomputer developed for OpenAI is a single system with more than 285,000 CPU cores, 10,000 GPUs and 400 gigabits per second of network connectivity for each GPU server.,” the companies stated in a blog.

Table of Contents

Let’s see the Key Takeaways of GPT-3
GPT-3 FAQ:
What is GPT-3?
Who created GPT-3?
What is the capacity of GPT-3
When was GPT-3 introduced?
Who founded OpenAI?
Let’s see the Key Takeaways of GPT-3
GPT-3 shows that language model performance scales as a power-law of model size, dataset size, and the amount of computation.

GPT-3 demonstrates that a language model trained on enough data can solve NLP tasks that it has never encountered. That is GPT-3 studies the model as a general solution for many downstream jobs without fine-tuning.

The cost of AI is increasing exponentially. Training GPT 3 would cost over $4.6M using a Tesla V100 cloud instance.

The size of state-of-the-art (SOTA) language models is growing by at least a factor of 10 every year. This outpaces the growth of GPU memory. For NLP, the days of “embarrassingly parallel” is coming to the end; model parallelization will become indispensable.

Although there is a clear performance gain from increasing the model capacity, it is not clear what is really going on under the hood. Especially, it remains a question of whether the model has learned to do reasoning, or simply memorizes training examples in a more intelligent way.

In terms of performance, the new GPT 3 model achieves near SOTA results on the SuperGLUE benchmark, introduced last year to test reasoning and other advanced NLP tasks. In other benchmarks, including COPA and ReCoRD, the model falls short with word-in-context analysis (WIC) and RACE, a set of middle and high school exam questions.

“Despite many limitations and weaknesses, these results suggest that very large language models may be an important ingredient in the development of adaptable, general language systems,” the organization said.

The simplest way to explain how it works is that it analyzes a massive sample of text on the internet, and learns to predict what words come next in a sentence given prior context. Based on the context you give, it responds to you with what it believes is the statistically most likely thing based on learning from all this text data. We have now steadily built up to where they are today, where a model like GPT 3 can complete several paragraphs or more.

Like GPT-2 and other Transformer-based programs, GPT 3 is trained on the Common Crawl data set, a corpus of almost a trillion words of texts scraped from the Web. “The dataset and model size is about two orders of magnitude larger than those used for GPT-2,” the authors write.

GPT 3 with 175 billion parameters is able to achieve what the authors describe as “meta-learning.” Meta-learning means that the GPT neural net is not re-trained to perform a task such as a sentence completion. Given an example of a task, such as an incomplete sentence, and then the completed sentence, GPT 3 will proceed to complete any incomplete sentence it’s given.

GPT 3 comes in eight sizes, ranging from 125M to 175B parameters. The largest GPT 3 model is an order of magnitude larger than the previous record-holder, T5-11B. The smallest GPT 3 model is roughly the size of BERT-Base and RoBERTa-Base.

All GPT 3 models use the same attention-based architecture as their GPT-2 predecessor. The smallest GPT 3 model (125M) has 12 attention layers, each with 12x 64-dimension heads. The largest GPT 3 model (175B) uses 96 attention layers, each with 96x 128-dimension heads.

GPT 3 expanded the capacity of its GPT-2 by three orders of magnitudes without significant modification of the model architecture — just more layers, wider layers, and more data to train it on.

Since Neural Networks are compressed and compiled version of the training data, the size of the dataset has to scale accordingly with the size of the model. GPT 3 175B is trained with 499 Billion tokens.

wait for OpenAI to reveal more details about the training infrastructure and model implementation. But to put things into perspective, the GPT 3 175B model required 3.14E23 FLOPS of computing for training. Even at theoretical 28 TFLOPS for V100 and lowest 3 years reserved cloud pricing we could find, this will take 355 GPU-years and cost $4.6M for a single training run. Similarly, a single RTX 8000, assuming 15 TFLOPS, would take 665 years to run.

Time is not the only constrain,. The 175 Billion parameters need 700GB memory to store in FP32. This is one order of magnitude larger than the maximum memory in a single GPU. To train the larger models without running out of memory, the OpenAI team uses a mixture of model parallelism within each matrix multiply and model parallelism across the layers of the network. All models were trained on V100 GPU’s on the part of a high-bandwidth cluster provided by Microsoft.

GPT 3 is able to learn how to do a task with a single prompt, better, in some cases, than versions of Transformer that have been fine-tuned, as it were, to specifically perform only that task. Hence, GPT-3 is the triumph of an over-arching generality. Just feed it an enormous amount of text till its weights are ideal, and it can go on to perform pretty well on a number of specific tasks with no further development.

That’s where the story comes to a striking denouement in the new paper. After listing off the impressive results of GPT-3 on language tasks ranging from completing sentences to inferring the logical entailment of statements to translating between languages, the authors note the shortcomings.

“Despite the strong quantitative and qualitative improvements of GPT-3, particularly compared to its direct predecessor GPT-2, it still has notable weaknesses.” Say the Authors.

Those weaknesses include an inability to achieve significant accuracy on what’s called Adversarial NLI. NLI, or natural language inference, is a test where the program must determine the relationship between two sentences. Researchers from Facebook and the University of North Carolina have introduced an adversarial version, where humans create sentence pairs that are hard for the computer to solve.

GPT-3 does “little better than chance” on things like Adversarial NLI, the authors write. Worse, has amped up the processing power of their system to 175 billion weights, the authors are not exactly sure why they’ve come up short in some tasks.

That’s when they come to the conclusion, cited above, that perhaps simply feeding an enormous corpus of text to a gigantic machine is not the ultimate answer.

Even more startling is the next observation. The whole practice of trying to predict what’s going to happen with language may be the wrong approach, the authors write. They may be aiming in the wrong place.

“With self-supervised objectives, task specification relies on forcing the desired task into a prediction problem,” they write, “whereas ultimately, useful language systems for example virtual assistants might be better thought of as taking goal-directed actions rather than just making predictions.”

The authors leave it for another time to specify how they’ll take on this rather fascinating potential new direction.

Thanks, Readers for reading this article on GPT-3. Do check out the demos of GPT-3 on YouTube & Also check out my other blogs on Tech With Gajesh.