Spinning up Eigenlayer avs using othentic on holešky

Yo frens !!

Just cooked up a quick AVS using the

@0xOthentic

framework — it’s a GitHub Star Checker that grabs the star count of any repo & verifies it. Dead simple and kinda cool tbh.

So what’s an AVS anyway?

AVS = Autonomous Verifiable Services. Basically a decentralized setup where you run tasks and verify ’em using a bunch of operators. Othentic makes spinning one up feel like cheating.

The Vibe:

We’re building a 2-part setup:

-> Execution — Pulls star count from GitHub

• \> Validation — Checks if that count is real or cap

Execution Flow

Here’s what the execution side does:

Takes in the GitHub repo as input

Calls GitHub API to get star count

Wraps it all in a “proof” w/ timestamp

Sends it off for validation

Literally just fetch & wrap.

Validation Flow

Validation does its own digging:

Takes the proof from exec

Hits GitHub API again, independently

Compares the result

If the stars match & the timestamp’s fresh — boom, verified

Set up yo’ gear

Before we do anything, we need to get our system 💯 ready.

Node Version Check

Othentic is real picky — you must use Node v22.6.0 (no versions above or below).

nvm install 22.6.0
nvm use 22.6.0

Install Yarn & Docker

Basic dev hygiene, bruh.

npm i -g yarn

# and install Docker from here:

https://docs.docker.com/get-docker/

Othentic CLI — the magic wand

Install the CLI globally:

npm i -g @othentic/othentic-cli
othentic-cli -v # just to check it's vibing

Clone and prep the repo like a G

git clone https://github.com/KaushikKC/git-star-fetch-avs
cd git-star-fetch-avs
rm -rf .git
cp .env.example .env

Boom. Local setup ready.

(Optional But Super Useful) — Create Operator Accounts Automatically

Don’t have wallets for validators yet? Run this slick little script and it’ll spit out 3 random operator accounts and fund them with Holesky ETH.

Create a file called createOperators.sh and paste this bad boi in:

source .env
RPC=https://rpc.ankr.com/eth_holesky/80921f6657bf5ad15fb4577b369c28c4f84a652625322575f085fceaa7e47653
OPERATOR_ACCOUNT1=$(openssl rand -hex 32)
OPERATOR_ADDRESS1=$(cast wallet address - private-key $OPERATOR_ACCOUNT1)
OPERATOR_ACCOUNT2=$(openssl rand -hex 32)
OPERATOR_ADDRESS2=$(cast wallet address - private-key $OPERATOR_ACCOUNT2)
OPERATOR_ACCOUNT3=$(openssl rand -hex 32)
OPERATOR_ADDRESS3=$(cast wallet address - private-key $OPERATOR_ACCOUNT3)
echo "Transferring 0.02 ETH on Holesky to all accounts…"
cast send - rpc-url $RPC - private-key $PRIVATE_KEY_DEPLOYER - value 0.02ether $OPERATOR_ADDRESS1
cast send - rpc-url $RPC - private-key $PRIVATE_KEY_DEPLOYER - value 0.02ether $OPERATOR_ADDRESS2
cast send - rpc-url $RPC - private-key $PRIVATE_KEY_DEPLOYER - value 0.02ether $OPERATOR_ADDRESS3
echo "✅ Done. Here's your crew:"
echo "👤 OP1 PK: $OPERATOR_ACCOUNT1 | Addr: $OPERATOR_ADDRESS1"
echo "👤 OP2 PK: $OPERATOR_ACCOUNT2 | Addr: $OPERATOR_ADDRESS2"
echo "👤 OP3 PK: $OPERATOR_ACCOUNT3 | Addr: $OPERATOR_ADDRESS3"

Run it using:

sh createOperators.sh

Or make it executable and run:

chmod a+x createOperators.sh && ./createOperators.sh

Wallets n Funding

You need 4 hot wallets (MetaMask/Foundry — your call):

Role UseMin Funds Required

Pro-tip: Use the key-gen script in the repo to create these wallets fast af

Plug your privates in (to .env)

Open up .env and drop all your private keys like this:

PRIVATE_KEY_DEPLOYER=<yo_key>
PRIVATE_KEY_PERFORMER=<yo_key>
PRIVATE_KEY_AGGREGATOR=<yo_key>
PRIVATE_KEY_ATTESTER1=<yo_key>
PRIVATE_KEY_ATTESTER2=<yo_key>
PRIVATE_KEY_ATTESTER3=<yo_key>

Then add some network juice:

L1_CHAIN=17000
L2_CHAIN=80002
L1_RPC=https://ethereum-holesky-rpc.publicnode.com
L2_RPC=https://rpc-amoy.polygon.technology

Time to Deploy This Beast

Make sure your deployer wallet has enough holETH + POL. Then run:

othentic-cli network deploy \
 - l1-chain holesky \
 - l2-chain amoy \
 - rewards-token 0x94373a4919B3240D86eA41593D5eBa789FEF3848 \
 - l1-initial-deposit 1000000000000000000 \
 - l2-initial-deposit 2000000000000000000 \
 - name github-avs

It’ll ask for the deployer’s private key — paste it in when asked (don’t fumble this step).

Register Your Ops (a.k.a. The Squad)

-> Join the Eigenlayer Club

Run this for each operator (3 times):

othentic-cli operator register-eigenlayer

Fill in the form with name, Twitter, etc. Style it up

- > Stack some stETH (restake yo ETH)

Run this for all 3:

othentic-cli operator deposit

Choose stETH and throw in 0.012 or more.

- > Sign up to your own AVS

Last one:

othentic-cli operator register

Paste the operator’s key → enter AVS governance contract address → press enter to keep default rewards receiver.

Boot the AVS Network

Time to light this AVS engine up

docker-compose up - build

This command spins up:

- Execute service

- Validation service

- Attesters

- Aggregator

- IPFS via Pinata

If you gotta tweak chain IDs or RPCs, just hop into docker-compose.yml and edit.

Hit That Task Trigger

In a separate terminal (yeah, open another one), run this bad boi:

curl -X POST http://localhost:4003/task/execute

Watch Docker logs like it’s Matrix. You’ll see:

- task getting executed

- attested

- validated

- then aggregated to an on-chain tx hash

That’s it. You just deployed your own AVS like an absolute unit

Now go flex on-chain.

Catch the full guide if you’re the read-the-docs type: https://docs.othentic.xyz/main/avs-framework/quick-start