soos3d

Introduction

In Web3 and blockchain, we get a new chain or a new RPC provider almost daily, and the ability to interact with multiple blockchain networks through RPC endpoints is crucial for developers, applications, and services. The Multi-Endpoint Shared Configuration (MESC) emerges as a pivotal standard in this ecosystem, addressing the pain points of configuring and managing RPC endpoints across diverse tools and platforms.

MESC introduces a standard for configuring RPC endpoints in DApps, emphasizing the ease of sharing configuration data and managing many endpoints. It focuses on making RPC configuration sharing across tools, languages, and environments straightforward, alongside simplifying the management of numerous RPC endpoints. This guide will teach us how to use the MESC CLI using Chainstack endpoints.

Key Components of MESC

MESC represents a significant leap toward simplifying the complexities developers face daily. Let's get into the core aspects that make MESC an indispensable tool fo

soos3d

[package]
name = "blockchain_collector"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
reqwest = { version = "0.11.23", features = ["json"] }
serde = { version = "1.0", features = ["derive"] }

soos3d

const ethers = require("ethers");
const WebSocket = require("ws");

const NODE_URL =
  "BASE_WSS";

function createWebSocket() {
  const ws = new WebSocket(NODE_URL);

  ws.on("close", () => {

soos3d

To run this code:

1. Sign up with Chainstack.
2. Deploy a node.
3. View node access and credentials.

• Install Bun
• Run the code:

soos3d

Chat with Your Code: LlamaIndex and Activeloop Deep Lake for GitHub Repositories 🦙🌊

This guide is your quickstart toolkit for integrating LlamaIndex with Activeloop Deep Lake. You'll learn how to effortlessly index GitHub repositories into Deep Lake and interact with your code through natural language queries.

What are LlamaIndex and Activeloop Deep Lake?

LlamaIndex: Your Data Framework for LLMs

LlamaIndex is a bridge between your data and Language Learning Models (LLMs). Whether your data resides in APIs, SQL databases, or PDFs, LlamaIndex ingests and structures it into a format easily consumable by LLMs. It offers features like data connectors for various data sources, indexing capabilities for quick retrieval, and natural language query engines that make your data not just accessible but also interactive.

soos3d

Introduction to Solidity Programming

For: Beginners Key Words: program, smart contracts Last update by: Constantine Fomchenkov Last updated time: February 21, 2023 5:58 AM Topic: Fundementals

💻 This is a Solidity onboarding guide designed for beginners. You'll learn all the basics of Solidity, which is the language used for writing smart contracts on the Ethereum blockchain.

soos3d

This code uses the eth_getLogs method to retrieve logs. Logs are generated when an event is emitted from a smart contract. We look at the transfer event from ERC-20 contracts in this case.

Here is how logs work:

The transfer event in the ERC-20 contract looks like this:

event Transfer(address indexed from, address indexed to, uint value);

soos3d

%lang starknet
from starkware.cairo.common.cairo_builtins import HashBuiltin

// Store a variable
// Storage vars are by default not visible through the ABI. They are similar to "private" variables in Solidity.

// This variable is a felt and is called my_value_storage
// From within a smart contract, it can be read with my_value_storage.read() or written to with my_value_storage.write()

@storage_var

soos3d

Deploy and verify a smart contract on StarkNet

On StarkNet, a smart contract can be verified programmatically directly from the terminal using StarkScan; the StarkNet contract verifier.

Table of contents

• Deploy a smart contract with Protostar
  • Cairo smart contract example
  • Deploy on StarkNet testnet with Protostar
• Deploy the contract on the StarkNet testnet

soos3d

Intro to StarkNet and Cairo

StarkNet is a permissionless decentralized ZK-Rollup operating as an L2 network over Ethereum, where any dApp can achieve unlimited scale for its computation. All this without compromising Ethereum’s composability and security.

Sources:

• Chainstack announces support for StarkNet
• A StarkNet odyssey: Overview and developer tools
• StarkNet and Cairo docs

Table of contents