# Content

## Writing your first smart contract

Now that we have the project setup out of the way, let us jump into writing our first contract.

Open up the `counter.clar` file inside the `contracts` directory.

### Defining the data store

A map will be used to store the individual counter values. Maps are a great choice because data can be added as more principals call into the contract over time.

``````(define-map counters principal uint)
``````

Our map is called `counters`, it is indexed by a key of the principal type and contains an unsigned integer. Since our counter will always count up, using an unsigned integer as opposed to a signed integer makes the most sense. The map thus relates a principal to a number.

We will also add a read-only function that returns the counter value for a specified principal. If the principal does not exist in the map, we return a default value of `u0`. Clarity has a built-in function called `default-to` that takes a default value and an optional type. If the optional type is a `(some ...)`, it will unwrap and return it. If it is a `none`, then it will return the specified default value.

``````(define-read-only (get-count (who principal))
(default-to u0 (map-get? counters who))
)
``````

Since `map-get?` returns either a `(some ...)` if the value is found or `none` otherwise, it is perfect to directly plug into `default-to`.

### Creating the public function

The next step is to create the `count-up` function that will increment the counter for the `tx-sender`. We will simply have the function return a `true` status. (Remember, overflows cause an abort automatically, so we do not have to deal with it ourselves.) We already created a really useful read-only function that we can repurpose. All we got to do is to set the map value for the `tx-sender` to be equal to the current counter value incremented by `u1`.

``````(define-public (count-up)
(begin
(map-set counters tx-sender (+ (get-count tx-sender) u1))
(ok true)
)
)
``````

Looks great! But we can simplify it further. The `map-set` actually returns a boolean value so we could wrap it in an `ok` to cut down on the lines of code. The refactored function therefore looks like this:

``````(define-public (count-up)
(ok (map-set counters tx-sender (+ (get-count tx-sender) u1)))
)
``````

### Putting it together

Our first contract turned out to be surprisingly simple. That is the power of Clarity. Let us put the entire contract together so that we can start testing it.

``````;; Multiplayer Counter contract

(define-map counters principal uint)

(default-to u0 (map-get? counters who))
)

(define-public (count-up)
(ok (map-set counters tx-sender (+ (get-count tx-sender) u1)))
)
``````

If we made any typos along the way, then the Clarity for VSCode Extension should have highlighted them. Still, we can use Clarinet to validate our contract by running the check command:

``````clarinet check
``````

The command will output any errors it finds or nothing if the contract is in order. No errors? Great, it is high time to play around with our contract.