Mezo

https://mezo.org/docs/developers/
Admin
Mezo is a Bitcoin-enabled EVM-compatible blockchain that combines Bitcoin security with smart...
Tokens:27,661
Snippets:278
Trust Score:8.9
Update:7 months ago
Show doc for...
Tokens:
Raw
### Cosmos SDK Client Integration Example

Source: https://mezo.org/docs/developers/getting-started/mezod

A Go code snippet demonstrating the basic setup for interacting with the Cosmos SDK client. It shows how to create a client context and a transaction builder for sending transactions.

```go
package main


import (
    "context"
    "github.com/cosmos/cosmos-sdk/client"
    "github.com/cosmos/cosmos-sdk/client/tx"
)


func main() {
    // Create client context
    clientCtx := client.Context{}


    // Create transaction builder
    txBuilder := clientCtx.TxConfig.NewTxBuilder()


    // Build and send transaction
    // ... transaction logic
}
```

--------------------------------

### Install MUSD Development Dependencies

Source: https://mezo.org/docs/developers/getting-started

Commands to initialize the MUSD project environment. This installs necessary dependencies for both the root project and the solidity smart contract directory.

```bash
pnpm install --frozen-lockfile
cd solidity
pnpm install --frozen-lockfile
```

--------------------------------

### Install Mezo Passport and Dependencies

Source: https://mezo.org/docs/developers/getting-started

Installs the necessary packages for Mezo Passport integration, including RainbowKit, wagmi, viem, and react-query. Ensure you are using viem version 2.x.

```bash
npm install @mezo-org/passport @rainbow-me/rainbowkit wagmi viem@2.x @tanstack/react-query
```

--------------------------------

### Start Mezo Earn Frontend Development Server

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Starts the development server for the Mezo Earn frontend application. This command should be run from the `dapp/` directory.

```bash
# Navigate to dapp directory
cd dapp


# Start development server
pnpm dev
```

--------------------------------

### Install Project Dependencies

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Installs all necessary project dependencies using the pnpm package manager. This command should be run after cloning the repository.

```bash
pnpm install
```

--------------------------------

### Set Up Pre-commit Hooks

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Installs the pre-commit tool and sets up the repository's pre-commit hooks. This helps maintain code quality and consistency before commits.

```bash
# Install pre-commit tool
brew install pre-commit

# Install hooks in the repository
pre-commit install
```

--------------------------------

### Start Light Client (Mezod CLI)

Source: https://mezo.org/docs/developers/getting-started/mezod

Command to start a light client for the Mezod chain. Light clients are suitable for resource-constrained environments as they do not store the full blockchain.

```bash
# Start light client
mezod start --mode light
```

--------------------------------

### Connect Wallets using Wagmi and RainbowKit

Source: https://mezo.org/docs/developers/getting-started/configure-mezo-passport

Demonstrates how to implement wallet connection functionality in a React application. The Wagmi example uses hooks for manual connector management, while the RainbowKit example utilizes the pre-built ConnectButton component.

```javascript
import { useChainId, useConnect } from "wagmi";

export const YourApp = () => {
  const chainId = useChainId();
  const { connectors, connect } = useConnect();

  return (
    <div>
      {connectors.map((connector) => (
        <button
          type="button"
          onClick={() => {
            connect({ connector, chainId });
          }}
          key={connector.id}
        >
          {connector.name}
        </button>
      ))}
    </div>
  );
};
```

```javascript
import { ConnectButton } from "@rainbow-me/rainbowkit"

export const YourApp = () => {
  return <ConnectButton label="Connect wallet"/>;
};
```

--------------------------------

### Install Go Dependencies

Source: https://mezo.org/docs/developers/getting-started/mezod

Downloads all the necessary Go dependencies for the Mezod project as defined in the go.mod file. This ensures the project has all required external libraries.

```bash
go mod download
```

--------------------------------

### Set Up Environment Variables

Source: https://mezo.org/docs/developers/musd

This snippet demonstrates how to set up the environment variables for the MUSD project by copying an example configuration file and instructing the user to edit it with their specific settings.

```bash
cp .env.example .env
# Edit .env with your configuration
```

--------------------------------

### Example TOML Configuration

Source: https://mezo.org/docs/developers/getting-started/mezod

Illustrates a sample TOML configuration file for Mezo node settings, including consensus timeouts, P2P network addresses, and API enablement. This provides a template for customizing node behavior.

```toml
[consensus]
timeout_commit = "1s"
timeout_propose = "3s"

[p2p]
laddr = "tcp://0.0.0.0:26656"
external_address = "YOUR_EXTERNAL_IP:26656"
persistent_peers = "peer1@ip1:26656,peer2@ip2:26656"

[api]
enable = true
address = "tcp://0.0.0.0:1317"
```

--------------------------------

### Install Dependencies for Native Installation (Bash)

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Installs necessary system dependencies for a native Mezo node installation on Ubuntu/Debian systems, including curl, git, make, and build-essential. It also downloads and installs Go version 1.21.0.

```bash
# Ubuntu/Debian
sudo apt update
sudo apt install -y curl git make build-essential


# Install Go
curl -fsSL https://go.dev/dl/go1.21.0.linux-amd64.tar.gz | sudo tar -xzC /usr/local
```

--------------------------------

### Mainnet Genesis Configuration Example

Source: https://mezo.org/docs/developers/chains

Provides a JSON object representing the genesis configuration for the Mezo mainnet, including chain ID, genesis time, and consensus parameters.

```json
{
  "chain_id": "mezo-mainnet",
  "genesis_time": "2024-01-01T00:00:00Z",
  "consensus_params": {
    "block": {
      "max_bytes": "22020096",
      "max_gas": "-1"
    },
    "evidence": {
      "max_age_num_blocks": "100000",
      "max_age_duration": "172800000000000"
    }
  }
}

```

--------------------------------

### Install Helm (Bash)

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Downloads and installs the Helm package manager, version 3. Helm is used for deploying applications on Kubernetes.

```bash
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
```

--------------------------------

### Configure WagmiProvider with Mezo Passport (React/TypeScript)

Source: https://mezo.org/docs/developers/getting-started

Configures the WagmiProvider using the `getConfig` method from `@mezo-org/passport`. This setup integrates RainbowKit for wallet connections and uses the `mezoTestnet` chain.

```typescript
import React from "react";
import ReactDOM from "react-dom/client";
import { RainbowKitProvider } from "@rainbow-me/rainbowkit";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { WagmiProvider } from "wagmi";
// Note: We use the consistent 'mezoTestnet' chain name for clarity.
import { getConfig, mezoTestnet } from "@mezo-org/passport";


const queryClient = new QueryClient();


ReactDOM.createRoot(document.getElementById("root")!).render(
  <React.StrictMode>
    <WagmiProvider config={getConfig({ appName: "Your Mezo dApp" })}>
      <QueryClientProvider client={queryClient}>
        <RainbowKitProvider initialChain={mezoTestnet}>
          {/* Your App component */}
        </RainbowKitProvider>
      </QueryClientProvider>
    </WagmiProvider>
  </React.StrictMode>,
);

```

--------------------------------

### Development Integration

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Commands and code snippets for starting local development environments and connecting dApps.

```bash
docker-compose -f docker-compose.dev.yml up
./mezod init testnode --chain-id mezo-testnet
npm test
```

```javascript
const provider = new ethers.JsonRpcProvider('http://localhost:8545');
```

--------------------------------

### Setup Prometheus Monitoring

Source: https://mezo.org/docs/developers/chains

Configuration for Prometheus to scrape metrics from Mezo mainnet and testnet nodes.

```yaml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'mezod-mainnet'
    static_configs:
      - targets: ['rpc.mezo.org:26660']
    metrics_path: /metrics
  - job_name: 'mezod-testnet'
    static_configs:
      - targets: ['testnet-rpc.mezo.org:26660']
    metrics_path: /metrics
```

--------------------------------

### Repository Structure Overview

Source: https://mezo.org/docs/developers/chains

Illustrates the directory structure of the Mezo Chains repository, categorizing configuration files, genesis data, scripts, monitoring setups, documentation, and utility tools.

```tree
chains/
├── configs/           # Network configuration files
├── genesis/           # Genesis files for different networks
├── scripts/           # Deployment and management scripts
├── monitoring/        # Monitoring and observability configs
├── docs/             # Documentation and guides
└── tools/            # Utility tools and helpers

```

--------------------------------

### CL Pool Swap Flow Example (Solidity)

Source: https://mezo.org/docs/developers/features/mezo-pools

Demonstrates how to perform a swap using Mezo's Concentrated Liquidity (CL) pools. This involves approving tokens to the CL swap router and calling either `exactInputSingle` or `exactInput` with specific pool parameters. The example highlights the use of pool keys and swap parameters.

```Solidity
pragma solidity ^0.8.0;

interface IMezoCLSwapRouter {
    struct PoolKey {
        address token0;
        address token1;
        uint24 tickSpacing;
        address feeCollector;
    }

    struct SwapParams {
        PoolKey poolKey;
        int8 sqrtPriceLimitX96;
        uint256 amountSpecified;
        uint256 value;
    }

    function exactInputSingle(SwapParams calldata params) external payable returns (uint amountOut);
    function exactInput(bytes calldata commands, bytes calldata data) external payable returns (uint amountOut);
}

contract CLSwapExample {
    IMezoCLSwapRouter public immutable clRouter;

    constructor(address _clRouterAddress) {
        clRouter = IMezoCLSwapRouter(_clRouterAddress);
    }

    function swapExactInputSingle(address token0, address token1, uint24 tickSpacing, address feeCollector, uint256 amountIn, uint256 amountOutMin, address to) external payable {
        IMezoCLSwapRouter.PoolKey memory poolKey = IMezoCLSwapRouter.PoolKey({
            token0: token0,
            token1: token1,
            tickSpacing: tickSpacing,
            feeCollector: feeCollector
        });

        IMezoCLSwapRouter.SwapParams memory params = IMezoCLSwapRouter.SwapParams({
            poolKey: poolKey,
            sqrtPriceLimitX96: 0, // Set to 0 for unbounded price range or specific limit
            amountSpecified: amountIn,
            value: msg.value // For ETH swaps
        });

        // User must approve clRouter to spend tokenIn before calling this function
        clRouter.exactInputSingle(params);
    }
}
```

--------------------------------

### Clone MUSD Repository and Install Dependencies

Source: https://mezo.org/docs/developers/musd

This snippet shows how to clone the MUSD repository from GitHub and install its dependencies using pnpm. It's the first step in setting up the development environment.

```bash
git clone https://github.com/mezo-org/musd.git
cd musd
pnpm install
```

--------------------------------

### Run MUSD Contract Tests

Source: https://mezo.org/docs/developers/getting-started

Executes the test suite for MUSD smart contracts using the pnpm package manager within the solidity directory.

```bash
cd solidity
pnpm test
```

--------------------------------

### Start Full Node (Mezod CLI)

Source: https://mezo.org/docs/developers/getting-started/mezod

Command to start a full node for the Mezod chain. A full node stores the entire blockchain history and participates actively in network consensus.

```bash
# Start full node
mezod start
```

--------------------------------

### Troubleshoot Node Issues

Source: https://mezo.org/docs/developers/chains

Common CLI commands for validating configurations, testing connectivity, and managing genesis files.

```bash
mezod config validate
mezod start --dry-run
curl -s http://localhost:26657/status | jq
mezod tendermint show-peers
mezod validate-genesis
mezod tendermint unsafe-reset-all
```

--------------------------------

### Basic Pool Swap Flow Example (Solidity)

Source: https://mezo.org/docs/developers/features/mezo-pools

Illustrates the basic swap flow for Mezo's basic pools. It involves approving tokens to the router and calling the `swapExactTokensForTokens` function with a path array. This example assumes the existence of ERC-20 token contracts and the Mezo router contract.

```Solidity
pragma solidity ^0.8.0;

interface IMezoRouter {
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
}

contract BasicSwapExample {
    IMezoRouter public immutable router;

    constructor(address _routerAddress) {
        router = IMezoRouter(_routerAddress);
    }

    function swapTokens(address tokenIn, address tokenOut, uint amountIn, uint amountOutMin, address to) external {
        address[] memory path = new address[](2);
        path[0] = tokenIn;
        path[1] = tokenOut;

        // User must approve router to spend tokenIn before calling this function
        router.swapExactTokensForTokens(amountIn, amountOutMin, path, to, block.timestamp);
    }
}
```

--------------------------------

### Backup Configuration and Keys

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Commands to create backups of the node configuration and sensitive validator keys.

```bash
# Backup configuration
tar -czf config-backup.tar.gz ~/.mezod/config/

# Backup validator keys
cp ~/.mezod/config/priv_validator_key.json /secure/backup/
```

--------------------------------

### Manage Network Configurations

Source: https://mezo.org/docs/developers/chains

Commands and formats for creating new network directories, defining network-specific TOML configs, and setting up genesis files.

```bash
mkdir -p configs/new-network
```

```toml
[consensus]
timeout_commit = "1s"

[p2p]
laddr = "tcp://0.0.0.0:26656"
```

```json
{
  "chain_id": "new-network",
  "genesis_time": "2024-01-01T00:00:00Z"
}
```

--------------------------------

### Automated Chain Deployment Script (Bash)

Source: https://mezo.org/docs/developers/chains

A bash script for automating the deployment of a Mezo node. It clones the chains repository, copies configuration files, initializes the node, and starts it.

```bash
#!/bin/bash
set -e


CHAIN_ID=${1:-"mezo-testnet"}
NODE_TYPE=${2:-"validator"}


echo "Deploying $NODE_TYPE node for chain $CHAIN_ID"


# Clone chains repository
git clone https://github.com/mezo-org/chains.git
cd chains


# Copy configuration
cp configs/$CHAIN_ID/config.toml ~/.mezod/config/
cp configs/$CHAIN_ID/app.toml ~/.mezod/config/


# Initialize node
mezod init $NODE_TYPE --chain-id $CHAIN_ID


# Start node
mezod start

```

--------------------------------

### Install Graph CLI (npm)

Source: https://mezo.org/docs/developers/subgraphs

Installs the Graph CLI globally using npm. The Graph CLI is essential for building, testing, and deploying subgraphs.

```bash
npm install -g @graphprotocol/graph-cli
```

--------------------------------

### Start Mezo Node with Docker Compose (Bash)

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Starts the Mezo node services defined in the docker-compose.yml file in detached mode. This command is used after configuring the .env file for Docker deployments.

```bash
docker-compose up -d
```

--------------------------------

### Start Archive Node (Mezod CLI)

Source: https://mezo.org/docs/developers/getting-started/mezod

Command to start an archive node for the Mezod chain. Archive nodes store all historical state data, enabling detailed historical queries.

```bash
# Start archive node
mezod start --mode archive
```

--------------------------------

### Install Dependencies (npm/yarn)

Source: https://mezo.org/docs/developers/subgraphs

Installs project dependencies using either npm or yarn package manager. This step is crucial after cloning the repository to ensure all necessary libraries are available.

```bash
npm install
# or
yarn install
```

--------------------------------

### Run Local Development Commands

Source: https://mezo.org/docs/developers/getting-started/mezod

Executes common commands for local development, including starting a development node, running tests, and linting the code. These commands facilitate the development workflow.

```bash
# Start local development node
make dev

# Run tests
make test

# Lint code
make lint
```

--------------------------------

### Interact with Mezo Earn Contracts using Ethers.js

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Example of connecting to the Mezo network using Ethers.js, loading a contract's ABI and address, and interacting with its functions. Requires contract address and ABI.

```javascript
import { ethers } from 'ethers';


// Connect to Mezo network
const provider = new ethers.JsonRpcProvider('https://rpc.mezo.org');


// Load contract ABI and address
const contract = new ethers.Contract(
  'CONTRACT_ADDRESS',
  CONTRACT_ABI,
  provider
);


// Interact with contract
const result = await contract.someFunction();
```

--------------------------------

### Clone Mezo Validator Kit Repository (Bash)

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Clones the official Mezo Validator Kit repository from GitHub and navigates into the directory. This is the first step for Docker and native installations.

```bash
git clone https://github.com/mezo-org/validator-kit.git
cd validator-kit
```

--------------------------------

### Connect to Mezo Network via Web3 (JavaScript)

Source: https://mezo.org/docs/developers/getting-started/mezod

Demonstrates how to connect to the Mezo network using the ethers.js library in JavaScript. It shows how to instantiate a provider, get network information, and prepare for contract deployment.

```javascript
import { ethers } from 'ethers';


// Connect to Mezo network
const provider = new ethers.JsonRpcProvider('https://rpc.mezo.org');


// Get network info
const network = await provider.getNetwork();
console.log('Network:', network);


// Deploy contract
const factory = new ethers.ContractFactory(abi, bytecode, signer);
const contract = await factory.deploy();
await contract.waitForDeployment();
```

--------------------------------

### Build Mezod Client

Source: https://mezo.org/docs/developers/getting-started/mezod

Compiles the Mezod client binary. This command builds the executable for the Mezo chain client, making it ready for execution.

```bash
make build
```

--------------------------------

### CL Position Management Example (Solidity)

Source: https://mezo.org/docs/developers/features/mezo-pools

Provides a Solidity example for managing positions in Mezo's Concentrated Liquidity (CL) pools using the `NonfungiblePositionManager`. It demonstrates key operations like minting a new position, increasing liquidity, decreasing liquidity, and collecting fees. This requires interaction with ERC-721 tokens representing positions.

```Solidity
pragma solidity ^0.8.0;

interface INonfungiblePositionManager {
    struct MintParams {
        address token0;
        address token1;
        uint24 tickLower;
        uint24 tickUpper;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        address to;
        uint deadline;
    }

    struct IncreaseLiquidityParams {
        uint liquidity;
        uint amount0Min;
        uint amount1Min;
        uint deadline;
    }

    struct DecreaseLiquidityParams {
        uint liquidity;
        uint amount0Min;
        uint amount1Min;
        uint deadline;
    }

    struct CollectParams {
        uint256 tokenId;
        address recipient;
        uint128 amount0Max;
        uint128 amount1Max;
    }

    function mint(MintParams calldata params) external payable returns (uint tokenId, uint amount0, uint amount1);
    function increaseLiquidity(IncreaseLiquidityParams calldata params) external payable returns (uint amount0, uint amount1);
    function decreaseLiquidity(DecreaseLiquidityParams calldata params) external returns (uint amount0, uint amount1);
    function collect(CollectParams calldata params) external returns (uint amount0, uint amount1);
}

contract PositionManagementExample {
    INonfungiblePositionManager public immutable positionManager;

    constructor(address _positionManagerAddress) {
        positionManager = INonfungiblePositionManager(_positionManagerAddress);
    }

    function createPosition(
        address token0, address token1, uint24 tickLower, uint24 tickUpper,
        uint256 amount0Desired, uint256 amount1Desired,
        uint256 amount0Min, uint256 amount1Min,
        address to
    ) external payable {
        INonfungiblePositionManager.MintParams memory params = INonfungiblePositionManager.MintParams({
            token0: token0,
            token1: token1,
            tickLower: tickLower,
            tickUpper: tickUpper,
            amount0Desired: amount0Desired,
            amount1Desired: amount1Desired,
            amount0Min: amount0Min,
            amount1Min: amount1Min,
            to: to,
            deadline: block.timestamp
        });
        // User must approve positionManager to spend token0 and token1 before calling this function
        positionManager.mint(params);
    }

    // Add functions for increaseLiquidity, decreaseLiquidity, and collect similarly
}
```

--------------------------------

### Install Goldsky CLI (npm)

Source: https://mezo.org/docs/developers/subgraphs

Installs the Goldsky CLI globally using npm. This CLI tool is used for deploying and managing subgraphs on the Goldsky platform.

```bash
npm install -g @goldsky/cli
```

--------------------------------

### Configure Network Security and Firewall

Source: https://mezo.org/docs/developers/chains

Rules for ufw and iptables to secure node ports and restrict RPC access to trusted IPs.

```bash
ufw allow 26656/tcp
ufw allow 26657/tcp
ufw allow 1317/tcp
ufw allow 8545/tcp
iptables -A INPUT -p tcp --dport 26657 -s TRUSTED_IP -j ACCEPT
iptables -A INPUT -p tcp --dport 26657 -j DROP
```

--------------------------------

### Troubleshoot and Debug Node

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Commands for checking sync status, peer connections, resource usage, and viewing logs.

```bash
# Check sync status
./mezod status

# Check peer connections
./mezod tendermint show-node-id

# Monitor resources
htop
iotop
netstat -tulpn

# View logs and status
journalctl -u mezod -f
curl http://localhost:26657/status
```

--------------------------------

### Clone Mezod Repository

Source: https://mezo.org/docs/developers/getting-started/mezod

Clones the Mezod repository from GitHub and navigates into the project directory. This is the first step in setting up the development environment.

```bash
git clone https://github.com/mezo-org/mezod.git
cd mezod
```

--------------------------------

### Docker Compose for Mezo Node Deployment

Source: https://mezo.org/docs/developers/chains

A Docker Compose file to set up and run a Mezo node within a container. It defines the service, image, ports, volumes, environment variables, and the command to start the node.

```yaml
version: '3.8'


services:
  mezod:
    image: mezod:latest
    container_name: mezod-node
    ports:
      - "26656:26656"
      - "26657:26657"
      - "1317:1317"
      - "8545:8545"
    volumes:
      - ./config:/root/.mezod/config
      - ./data:/root/.mezod/data
    environment:
      - CHAIN_ID=mezo-testnet
      - NODE_TYPE=validator
    command: mezod start

```

--------------------------------

### Configure SSL/TLS for API

Source: https://mezo.org/docs/developers/chains

TOML configuration snippet to enable TLS for the Mezo API.

```toml
[api]
tls_cert_file = "/path/to/cert.pem"
tls_key_file = "/path/to/key.pem"
```

--------------------------------

### Configure Network Security

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Commands to harden node security using UFW for port management and iptables for RPC access control.

```bash
# Allow only necessary ports
ufw allow 26656/tcp
ufw allow 26657/tcp
ufw allow 1317/tcp
ufw allow 8545/tcp

# Restrict RPC access
iptables -A INPUT -p tcp --dport 26657 -s TRUSTED_IP -j ACCEPT
iptables -A INPUT -p tcp --dport 26657 -j DROP
```

--------------------------------

### Validate Configuration Files

Source: https://mezo.org/docs/developers/chains

Bash script to validate TOML syntax using Python, ensuring configuration integrity before deployment.

```bash
#!/bin/bash
CONFIG_FILE=$1
if [ -z "$CONFIG_FILE" ]; then
    echo "Usage: $0 <config-file>"
    exit 1
fi
if ! python3 -c "import toml; toml.load('$CONFIG_FILE')"; then
    echo "Invalid TOML syntax"
    exit 1
fi
echo "Configuration is valid"
```

--------------------------------

### Build Mezo Earn Frontend for Production

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Builds the Mezo Earn frontend application for production deployment. This command optimizes the application for performance.

```bash
# Navigate to dapp directory
cd dapp


# Build for production
pnpm build
```

--------------------------------

### Define Mezo Configuration Templates

Source: https://mezo.org/docs/developers/chains

TOML configuration template for Mezo nodes, defining consensus, P2P, and API settings using placeholders.

```toml
[consensus]
timeout_commit = "{{ .ConsensusTimeoutCommit }}"
timeout_propose = "{{ .ConsensusTimeoutPropose }}"

[p2p]
laddr = "{{ .P2PAddress }}"
external_address = "{{ .ExternalAddress }}"
persistent_peers = "{{ .PersistentPeers }}"

[api]
enable = {{ .APIEnabled }}
address = "{{ .APIAddress }}"
```

--------------------------------

### Update Network Parameters via Governance

Source: https://mezo.org/docs/developers/chains

Commands to submit and vote on parameter change proposals using the mezod CLI.

```bash
mezod tx gov submit-proposal param-change proposal.json
mezod tx gov vote 1 yes --from validator
```

--------------------------------

### Clone Mezo Earn Repository

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Clones the Mezo Earn repository from GitHub and navigates into the project directory. This is the first step in setting up the development environment.

```bash
git clone https://github.com/mezo-org/tigris.git
cd tigris
```

--------------------------------

### Preview Mezo Earn Production Build

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Previews the production build of the Mezo Earn frontend application. This allows you to test the optimized build locally before deployment.

```bash
# Navigate to dapp directory
cd dapp


# Preview production build
pnpm preview
```

--------------------------------

### Submit Validator Application via mezod CLI

Source: https://mezo.org/docs/developers/getting-started

Submits a Proof of Authority (PoA) application for a Mezo Validator using the `mezod` command-line interface. Requires the home path for mezod, RPC URL, and a key name.

```bash
mezod --home=<mezod_home_path> --rpc-url <rpc_url> poa submit-application <key_name>
```

--------------------------------

### Run Tests with Make and Go

Source: https://mezo.org/docs/developers/getting-started/mezod

Commands to execute unit and integration tests using the 'make' utility and Go's testing framework. These commands are essential for verifying code correctness at different levels.

```shell
# Run unit tests
make test

# Run integration tests
make test-integration

# Run specific test package
go test ./x/evm/...
```

--------------------------------

### Initialize and Create Validator (Bash)

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Commands to initialize a validator node, add a validator key using the file keyring backend, and submit a transaction to create a validator with specified staking amount, public key, moniker, and chain ID.

```bash
# Initialize validator
./mezod init validator --chain-id mezo-mainnet


# Create validator key
./mezod keys add validator --keyring-backend file


# Create validator transaction
./mezod tx staking create-validator \
  --amount=1000000umezo \
  --pubkey=$(./mezod tendermint show-validator) \
  --moniker="My Validator" \
  --chain-id=mezo-mainnet \
  --from=validator
```

--------------------------------

### Build and Run Docker Image

Source: https://mezo.org/docs/developers/getting-started/mezod

Builds a Docker image for the Mezod client and runs it as a container. This is useful for containerized development and deployment, exposing necessary ports.

```bash
# Build Docker image
docker build -t mezod .

# Run containerized node
docker run -p 26657:26657 -p 8545:8545 mezod
```

--------------------------------

### Build Mezod Binary (Bash)

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Clones the mezod repository, navigates into the directory, and compiles the mezod binary. This is a crucial step for setting up a Mezo node natively.

```bash
git clone https://github.com/mezo-org/mezod.git
cd mezod
make build
```

--------------------------------

### Define Prometheus Alerting Rules

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Configures alerting rules for Prometheus to notify when the Mezo node is down.

```yaml
groups:
  - name: mezod
    rules:
      - alert: NodeDown
        expr: up{job="mezod"} == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Mezod node is down"
```

--------------------------------

### Define Grafana Dashboard Panels

Source: https://mezo.org/docs/developers/chains

JSON structure for a Grafana dashboard panel tracking block height metrics.

```json
{
  "dashboard": {
    "title": "Mezo Chain Monitoring",
    "panels": [
      {
        "title": "Block Height",
        "type": "graph",
        "targets": [
          {
            "expr": "mezod_block_height",
            "legendFormat": "{{chain_id}}"
          }
        ]
      }
    ]
  }
}
```

--------------------------------

### Fetch Price Data with Pyth Oracle in Solidity

Source: https://mezo.org/docs/developers/architecture/oracles/read-oracle

Demonstrates how to interact with the Pyth Network's IPyth interface to retrieve price data with built-in staleness checks. It uses the getPriceNoOlderThan function to ensure data freshness for specific asset price IDs.

```Solidity
import "@pythnetwork/pyth-sdk-solidity/IPyth.sol";
import "@pythnetwork/pyth-sdk-solidity/PythStructs.sol";

contract ReadPythPrice {
    IPyth public immutable pyth;

    constructor(address pythContract) {
        pyth = IPyth(pythContract);
    }

    function getPrice(bytes32 priceId, uint256 maxAgeSeconds)
        external
        view
        returns (int64 price, uint64 conf, int32 expo, uint256 publishTime)
    {
        PythStructs.Price memory priceData = pyth.getPriceNoOlderThan(priceId, maxAgeSeconds);
        return (priceData.price, priceData.conf, priceData.expo, priceData.publishTime);
    }

    function getMUSDPrice() external view returns (int64, uint256) {
        bytes32 musdPriceId = 0x0617a9b725011a126a2b9fd53563f4236501f32cf76d877644b943394606c6de;
        PythStructs.Price memory price = pyth.getPriceNoOlderThan(musdPriceId, 3600);
        return (price.price, price.publishTime);
    }
}
```

--------------------------------

### GET /connect/oracle/v2/get_price

Source: https://mezo.org/docs/developers/architecture/oracles/read-oracle

Retrieves the current BTC/USD price via the Skip Oracle Node API on the Mezo Testnet.

```APIDOC
## GET /connect/oracle/v2/get_price

### Description
Fetches the latest BTC/USD price feed from the Skip Oracle node on the Mezo Testnet.

### Method
GET

### Endpoint
http://mezo-node-0.test.mezo.org:1317/connect/oracle/v2/get_price

### Parameters
#### Query Parameters
- **currency_pair** (string) - Required - The trading pair to query (e.g., "BTC/USD")

### Response
#### Success Response (200)
- **price** (number) - The current market price of the requested pair.

#### Response Example
{
  "currency_pair": "BTC/USD",
  "price": 65000.00
}
```

--------------------------------

### Configure Prometheus Metrics Scraper

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Sets up a Prometheus scrape configuration to collect metrics from the Mezo node at the specified endpoint.

```yaml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'mezod'
    static_configs:
      - targets: ['localhost:26660']
    metrics_path: /metrics
```

--------------------------------

### Configure Mezo Environment Variables

Source: https://mezo.org/docs/developers/chains

Sets the necessary environment variables for local development, including chain ID and endpoint URLs.

```bash
export CHAIN_ID="mezo-local"
export RPC_ENDPOINT="http://localhost:26657"
export EXPLORER_URL="http://localhost:1317"
```

--------------------------------

### Query Subgraph Data

Source: https://mezo.org/docs/developers/subgraphs

Examples of GraphQL queries to retrieve transfer history, token metadata, and filtered results from a deployed subgraph.

```GraphQL
# Get recent transfers
{
  transfers(first: 10, orderBy: timestamp, orderDirection: desc) {
    id
    from
    to
    amount
    timestamp
    transactionHash
  }
}

# Get token information
{
  token(id: "1") {
    name
    symbol
    decimals
    totalSupply
  }
}

# Filter transfers by address
{
  transfers(where: { from: "0x..." }) {
    id
    to
    amount
    timestamp
  }
}
```

--------------------------------

### Deploy Testnet Contracts using PNPM

Source: https://mezo.org/docs/developers/features/mezo-earn/mezo-earn

Command to deploy contracts to a testnet environment. This involves configuring testnet parameters in a .env file and then executing the deployment script. Assumes PNPM package manager is used. No specific inputs or outputs are defined, but it's a crucial step before verifying and updating frontend configurations.

```bash
pnpm deploy:testnet
```

--------------------------------

### Perform Node Maintenance Tasks

Source: https://mezo.org/docs/developers/mezo-nodes/validator-kit

Common maintenance operations including software updates, database pruning, and log rotation configuration.

```bash
# Update mezod
git pull origin main
make build
systemctl restart mezod

# Prune old data
./mezod tendermint unsafe-reset-all

# Configure logrotate
cat > /etc/logrotate.d/mezod << EOF
/var/log/mezod/*.log {
    daily
    rotate 7
    compress
    delaycompress
    missingok
    notifempty
}
EOF
```
Tokens:
Raw