> ## Documentation Index
> Fetch the complete documentation index at: https://docs.initia.xyz/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction

> Learn how to install and get started with the minitiad command-line interface for interacting with Initia rollups

The minitiad CLI is a command-line interface for interacting with appchains
built on the Interwoven Stack. This tool provides comprehensive functionality
for developers and users to manage accounts, query blockchain data, submit
transactions, and perform various other operations.

## Overview

With minitiad, you can:

* **Account Management**: Create, import, and manage blockchain accounts
* **Transaction Operations**: Send transactions, delegate tokens, and interact
  with smart contracts
* **Data Queries**: Query blockchain state, account balances, and transaction
  history
* **Validator Operations**: Create validators, delegate stakes, and manage
  governance proposals
* **Multi-Chain Support**: Connect to different Initia rollup chains using
  configurable endpoints
* **VM-Specific Builds**: Different implementations for Move, Wasm, and EVM
  rollup chains

<Info>
  minitiad is built using the Cosmos SDK and provides a familiar interface for
  users of other Cosmos-based chains, specifically optimized for Initia rollups.
</Info>

## VM Types and Repositories

Different Initia rollup chains use different Virtual Machines (VMs), and each
requires a specific minitiad implementation:

* **Move**: [minimove](https://github.com/initia-labs/minimove) - For rollups
  running Move smart contracts
* **Wasm**: [miniwasm](https://github.com/initia-labs/miniwasm) - For rollups
  running WebAssembly smart contracts
* **EVM**: [minievm](https://github.com/initia-labs/minievm) - For rollups
  running Ethereum Virtual Machine smart contracts

<Tip>
  Check your rollup chain's documentation to determine which VM type it uses
  before installation.
</Tip>

## Prerequisites

Before installing minitiad, ensure you have the following requirements:

* **Go**: Version 1.21 or higher
* **Git**: For cloning the repository
* **Make**: For building the binary

<Tip>
  You can verify your Go installation by running `go version` in your terminal.
</Tip>

## Installation

<Steps>
  <Step title="Clone the Repository">
    First, clone the appropriate repository based on your rollup's VM type:

    <CodeGroup>
      <CodeBlock filename="Move" language="bash">
        git clone [https://github.com/initia-labs/minimove.git](https://github.com/initia-labs/minimove.git)
        cd minimove
      </CodeBlock>

      <CodeBlock filename="Wasm" language="bash">
        git clone [https://github.com/initia-labs/miniwasm.git](https://github.com/initia-labs/miniwasm.git)
        cd miniwasm
      </CodeBlock>

      <CodeBlock filename="EVM" language="bash">
        git clone [https://github.com/initia-labs/minievm.git](https://github.com/initia-labs/minievm.git)
        cd minievm
      </CodeBlock>
    </CodeGroup>

    <Note>
      Make sure to select the correct repository that matches your target rollup chain's VM type.
    </Note>
  </Step>

  <Step title="Get Version and Checkout">
    Fetch the current network version and checkout the corresponding tag. Set your rollup chain endpoints first:

    <CodeGroup>
      <CodeBlock filename="Using Chain Endpoints" language="bash">
        # Set your rollup chain endpoints (replace with your specific chain)

        export CHAIN\_REST\_ENDPOINT="[https://rest.your-rollup-chain.com](https://rest.your-rollup-chain.com)"
        export CHAIN\_RPC\_ENDPOINT="[https://rpc.your-rollup-chain.com](https://rpc.your-rollup-chain.com)"

        # Get the current rollup version and checkout

        export VERSION=$(curl -s $CHAIN\_REST\_ENDPOINT/cosmos/base/tendermint/v1beta1/node\_info | jq -r '.application\_version.version' | grep -oE 'v\[0-9]+.\[0-9]+.\[0-9]+')
        echo "Checking out version: $VERSION"
                    git checkout $VERSION
      </CodeBlock>

      <CodeBlock filename="Manual Version" language="bash">
        # Manually set a specific version and checkout

        export VERSION=v0.5.7
        echo "Checking out version: $VERSION"
                    git checkout $VERSION
      </CodeBlock>
    </CodeGroup>

    <Warning>
      Always use a specific version tag rather than the main branch for production
      environments to ensure stability.
    </Warning>

    <Note>
      Different rollup chains may run different versions. Always fetch the version from your target rollup chain.
    </Note>
  </Step>

  <Step title="Build and Install">
    Compile and install the minitiad binary:

    ```bash theme={null}
    make install
    ```

    This will build the binary and install it to your `$GOPATH/bin` directory.
  </Step>
</Steps>

## Verification

After installation, verify that minitiad is correctly installed and accessible:

<Note>
  The CLI binary is always named `minitiad` regardless of which VM-specific
  repository you cloned.
</Note>

### Check CLI Version

```bash theme={null}
minitiad version
# Output: v0.5.7
```

### Verify Installation Path

```bash theme={null}
which minitiad
# Output: /Users/username/go/bin/minitiad (or your $GOPATH/bin path)
```

### Check Available Commands

```bash theme={null}
minitiad --help
```

## Network Configuration

Configure the CLI to connect to your specific rollup chain by setting the
appropriate endpoints:

### Setting Chain Endpoints

```bash theme={null}
# Set your rollup chain endpoints
export CHAIN_REST_ENDPOINT="https://rest.your-rollup-chain.com"
export CHAIN_RPC_ENDPOINT="https://rpc.your-rollup-chain.com"
export CHAIN_ID="your-chain-id"

# Configure minitiad
minitiad config chain-id $CHAIN_ID
minitiad config node $CHAIN_RPC_ENDPOINT
```

<Warning>
  Make sure to use the correct endpoints for your specific rollup chain. Each
  Initia rollup has its own unique endpoints and chain ID.
</Warning>

## Next Steps

Now that you have minitiad installed and configured, you can start building and
deploying applications on Initia rollup chains. The specific workflow will
depend on your rollup's VM type (Move, Wasm, or EVM).

<Info>
  Additional minitiad CLI documentation pages are currently being developed and
  will be available soon.
</Info>