# Getting Started

## Template

If you're starting from scratch the best way to begin is to use the Andromeda smart contract template. This can be found on our Github [here](https://github.com/andromedaprotocol/andr-cw-template).

### Andromeda Standard Crate

Our crate can be found [here](https://crates.io/crates/andromeda-std).

## Contract Messages

The message definitions for an ADO can be added to any existing message definitions using our `andromeda-macros` crate (this is also available via the `andromeda-std` crate, so if you're using our full suite you don't need to install this crate explicitly). There are three macros for instantiation, execute and query messages.

{% code title="msg.rs" %}

```rust
use andromeda_std::{andr_exec, andr_instantiate, andr_query};

#[andr_instantiate]
#[cw_serde]
pub struct InstantiateMsg {
    // ... Your instantiation variables
}

#[andr_exec]
#[cw_serde]
pub enum ExecuteMsg {
    // ... Your execute messages
}

#[andr_query]
#[cw_serde]
#[derive(QueryResponses)]
pub enum QueryMsg {
    // ... Your query messages
}
```

{% endcode %}

These macros work by merging your existing message types with the available Andromeda message types. If you'd like to take a look at these messages you can see them [here](https://github.com/andromedaprotocol/andromeda-core/tree/main/packages/std/src/ado_base).

## ADOContract

All interactions with the Andromeda ecosystem can be done via the `ADOContract` interface. To use this interface you must first import it from the `andromeda-std` crate.

{% hint style="warning" %}
This is included in the template.
{% endhint %}

{% code title="contract.rs" %}

```rust
use andromeda_std::ado_contract::ADOContract;
```

{% endcode %}

Once imported you can create an instance of the contract in your code execution like so:

{% code title="contract.rs" %}

```rust
#[cfg_attr(not(feature = "library"), entry_point)]
pub fn instantiate(
    deps: DepsMut,
    env: Env,
    info: MessageInfo,
    msg: InstantiateMsg,
) -> Result<Response, ContractError> {

    let contract = ADOContract::default();
    ...
```

{% endcode %}

```rust
pub struct ADOContract<'a> {
    pub(crate) owner: Item<'a, Addr>,
    pub(crate) original_publisher: Item<'a, Addr>,
    pub(crate) block_height: Item<'a, u64>,
    pub(crate) ado_type: Item<'a, String>,
    pub(crate) app_contract: Item<'a, Addr>,
    pub(crate) kernel_address: Item<'a, Addr>,
    pub(crate) permissioned_actions: Map<'a, String, bool>,
    #[cfg(feature = "rates")]
    /// Mapping of action to rate
    pub rates: Map<'a, &'a str, Rate>,
}
```

From this struct we can access all of the state variables and various cross-contract calls that are needed by an ADO.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.andromedaprotocol.io/andromeda/developing-an-ado/getting-started.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.