# Set up your project · Monetizing your dapp · Learn Chromia

> Have the following prerequisites ready before you begin:

Source: https://chromia.com/learn/monetize-dapp/setup/

Monetizing your dappLesson 2 of 5

1. [01Monetizing your dapp](https://chromia.com/learn/monetize-dapp/introduction/)
2. [02Set up your project](https://chromia.com/learn/monetize-dapp/setup/)
3. [03Account registration](https://chromia.com/learn/monetize-dapp/account-registration/)
4. [04Open strategy](https://chromia.com/learn/monetize-dapp/open/)
5. [05Transfer strategies](https://chromia.com/learn/monetize-dapp/transfer/)

[Learn](https://chromia.com/learn/)[Monetizing your dapp](https://chromia.com/learn/monetize-dapp/)

02 / 05Advanced

# Set up your project

Have the following prerequisites ready before you begin:

Set up PostgreSQL database

## Set up PostgreSQL database

Rell needs PostgreSQL 16.3. Without it, the IDE still works, but you can't run a node. A console or a remote postchain app
does not need a database.

By default, Rell expects this database configuration:

* database: `postchain`
* user: `postchain`
* password: `postchain`

## Install

1. Get Homebrew by following the [Homebrew installation guide](https://brew.sh/).
2. Install PostgreSQL:

   shell

   ```
   brew install postgresql@16
   brew services start postgresql@16
   createuser -s postgres
   ```
3. Set up the PostgreSQL database:

   plsql

   ```nolines
   psql -U postgres -c "CREATE DATABASE postchain WITH TEMPLATE = template0 LC_COLLATE = 'C.UTF-8' LC_CTYPE = 'C.UTF-8' ENCODING 'UTF-8';" -c "CREATE ROLE postchain LOGIN ENCRYPTED PASSWORD 'postchain'; GRANT ALL ON DATABASE postchain TO postchain;"
   ```

   note

   A "peer authentication failed" error means you need to switch the authentication method from `peer` to
   `md5`. Make this change in the `pg_hba.conf` file of your `psql` database.

1. Install PostgreSQL:

   bash

   ```nolines
   sudo apt install postgresql-16
   ```
2. Set up the PostgreSQL database:

   bash

   ```nolines
   sudo -u postgres psql -c "CREATE DATABASE postchain WITH TEMPLATE = template0 LC_COLLATE = 'C.UTF-8' LC_CTYPE = 'C.UTF-8' ENCODING 'UTF-8';" -c "CREATE ROLE postchain LOGIN ENCRYPTED PASSWORD 'postchain'; GRANT ALL ON DATABASE postchain TO postchain;"
   ```

1. Get Docker by following the [Docker installation guide](https://docs.docker.com/engine/install/).
2. Set up the PostgreSQL database:

   dockerfile

   ```nolines
   docker run --name postgres -e POSTGRES_USER=postchain -e POSTGRES_PASSWORD=postchain -p 5432:5432 -d postgres:16.3-alpine3.20
   ```

   note

   The Alpine image of PostgreSQL is used here because its default collation settings are the right ones. You can also
   set the collation explicitly with this environment variable:

   bash

   ```nolines
   POSTGRES_INITDB_ARGS="--lc-collate=C.UTF-8 --lc-ctype=C.UTF-8 --encoding=UTF-8"
   ```

1. Get the PostgreSQL installer from the [PostgreSQL download page](https://www.postgresql.org/download/windows/).
2. Run the installer, then add the PostgreSQL folder that holds the binaries to your environment variables. In Command
   Prompt (CMD), run the command below. Point it at the correct binaries path and substitute the actual version number for
   the `<version>` placeholder:

   shell

   ```nolines
   setx POSTGRESQL "C:\Program Files\PostgreSQL\<version>\bin"
   ```
3. Close and reopen Command Prompt (CMD) so it picks up the new environment variables. Then run these two commands, one
   after the other, to set up the PostgreSQL database:

   plsql

   ```nolines
   psql -U postgres -c "CREATE DATABASE postchain WITH TEMPLATE = template0 LC_COLLATE = 'en_US.UTF-8' LC_CTYPE = 'en_US.UTF-8' ENCODING 'UTF-8';"
   psql -U postgres -c "CREATE ROLE postchain LOGIN ENCRYPTED PASSWORD 'postchain'; GRANT ALL ON DATABASE postchain TO postchain;"
   ```

   note

   Some Windows versions produce permission errors or problems caused by a faulty PostgreSQL installation. If you run
   into these, install Docker and run PostgreSQL as a container instead.

Install Chromia CLI

## Install Chromia CLI

Follow these steps to install and update the
[Chromia CLI](https://gitlab.com/chromaway/core-tools/chromia-cli).

## Prerequisite

Check that you have the following in place first:

* **PostgreSQL database**: Follow [Set up PostgreSQL database](https://docs.chromia.com/get-started/installation/#set-up-postgresql-database).
* **RELL\_JAVA environment**: Chromia CLI runs on a Java runtime, version 21 or later. The package managers
  handle this for you, so no manual setup is needed. To choose which Java runtime runs Chromia CLI, set the RELL\_JAVA
  environment variable to a valid Java installation.

## Installation

Install Chromia CLI through a package manager, or download it directly from
[Chromia CLI Packages](https://gitlab.com/chromaway/core-tools/chromia-cli/-/packages).

On macOS, install Chromia CLI (`chr`) as follows:

1. If you don't have Homebrew yet, install it:

   bash

   ```nolines
   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
   ```
2. Register the Chromia repository with Homebrew:

   bash

   ```nolines
   brew tap chromia/core https://gitlab.com/chromaway/core-tools/homebrew-chromia.git
   ```
3. Install Chromia CLI:

   bash

   ```nolines
   brew install chromia/core/chr
   ```

   info

   To pin a specific Chromia CLI version, run:

   shell

   ```
   brew install chromia/core/chr@<version>
   brew unlink chr
   brew link chr@<version>
   ```

   Run `brew search chr` to see which versions are available.
4. Confirm the installation by printing the version:

   bash

   ```nolines
   chr --version
   ```

On Linux or WSL (Windows Subsystem for Linux), install Chromia CLI (`chr`) as follows:

1. Fetch the public key for Chromia's `apt-repo` and add it to your system's trusted keyrings:

   bash

   ```nolines
   curl -fsSL https://apt.chromia.com/chromia.gpg | sudo tee /usr/share/keyrings/chromia.gpg
   ```
2. Add the Chromia repository to your package sources:

   bash

   ```nolines
   echo "deb [arch=amd64 signed-by=/usr/share/keyrings/chromia.gpg] https://apt.chromia.com stable main" | sudo tee /etc/apt/sources.list.d/chromia.list
   ```
3. Refresh your package sources:

   bash

   ```nolines
   sudo apt-get update
   ```

   info

   If `apt.chromia.com` was added on your system before Chromia CLI version `0.16.0`, run this command so the
   repository update is permitted:

   bash

   ```nolines
   sudo apt-get --allow-releaseinfo-change update
   ```
4. After the update completes, install Chromia CLI:

   bash

   ```nolines
   sudo apt-get install chr
   ```
5. Confirm the installation by printing the version:

   bash

   ```nolines
   chr --version
   ```

On Windows, install Chromia CLI (`chr`) with [Scoop](https://scoop.sh/) as follows:

1. If you don't have Scoop yet, open PowerShell as Administrator and run:

   powershell

   ```nolines
   iwr -useb get.scoop.sh | iex
   ```
2. Add the Chromia bucket (repository) to Scoop:

   powershell

   ```nolines
   scoop bucket add chromia https://gitlab.com/chromaway/core-tools/scoop-chromia/
   ```
3. Add the Java bucket to Scoop:

   powershell

   ```nolines
   scoop bucket add java
   ```

   With this bucket in place, Scoop can fetch openjdk21, which chromia-cli requires, during installation.
4. Install Chromia CLI:

   powershell

   ```nolines
   scoop install chr
   ```
5. Confirm the installation by printing the version:

   powershell

   ```nolines
   chr --version
   ```

## Updating Chromia CLI

Get the newest Chromia CLI from the
[Chromia CLI packages page](https://gitlab.com/chromaway/core-tools/chromia-cli/-/packages). If you installed it through a
package manager, update it with the matching command:

shell

```nolines
brew update
brew upgrade chr
```

shell

```nolines
sudo apt-get update
sudo apt-get install chr
```

shell

```nolines
scoop update
scoop update chr
```

## Docker

With Docker, you can run a self-contained Linux container that already includes Chromia CLI. You still need a
[PostgreSQL database](https://docs.chromia.com/get-started/installation/#set-up-postgresql-database) set up.

The published Docker images require Docker to be installed and configured on your host. The Docker documentation explains
how to [install Docker](https://docs.docker.com/get-docker/) on Windows, Mac, and Linux.

### Start the Docker container with Chromia CLI pre-installed

Run the latest Chromia CLI by passing the CLI Docker image name and `chr` to the `docker run`
command.

shell

```nolines
docker run --rm -v $(pwd):/usr/app registry.gitlab.com/chromaway/core-tools/chromia-cli/chr:<latest version> chr
```

Windows Command Prompt Users

Windows Command Prompt (cmd) does not understand the `$(pwd)` syntax. Use one of these instead:

* **PowerShell**: `$(Get-Location)` or `$(pwd)`
* **Command Prompt**: `%CD%`

**Command Prompt example:**

cmd

```nolines
docker run --rm -v %CD%:/usr/app registry.gitlab.com/chromaway/core-tools/chromia-cli/chr:<latest version> chr
```

note

Set up your `chromia.yml` file for your platform:

* **Mac**: Set `database:host` to `host.docker.internal`.
* **Windows**: Set `database:host` to `host.docker.internal` (Docker Desktop). If the node still cannot reach your database, try `172.17.0.1`, the default Docker bridge address on Linux.
* **Linux**: Pass the `--network=host` argument to your Docker commands.

Without these settings, Chromia CLI can't reach the PostgreSQL instance.

For details on updating or removing the Docker image, see the [Docker command line reference](https://docs.docker.com/engine/reference/commandline/docker/).

bash

```
#!/bin/bash

# Allocate a pseudo-TTY one when run in interactive mode
if [ -t 0 ] && [ -t 1 ] ; then TTY="--tty"; else TTY=""; fi

docker run \
  # Sets the network to host to not need to change the database hostname (linux only)
  --network=host \
  # Set timezone based on system settings (linux only)
  -e TZ=$(cat /etc/timezone) \
  # Sets process ownership to current user
  --user $(id -u):$(id -g) \
  --mount type=bind,source="/etc/passwd",target=/etc/passwd,readonly \
  --mount type=bind,source="/etc/group",target=/etc/group,readonly \
  # Configures ssh-agent (only needed if chr install is called on non-public repositores)
  -e SSH_AUTH_SOCK=$SSH_AUTH_SOCK \
  --volume "$SSH_AUTH_SOCK:$SSH_AUTH_SOCK" \
  --mount type=bind,source="${HOME}/.ssh",target=${HOME}/.ssh,readonly \
  --mount type=bind,source="${HOME}/.config/jgit",target=${HOME}/.config/jgit \
  # Mounts current folder into the container (Use `Get-Location` on PowerShell)
  --mount type=bind,source="$(pwd)",target=/usr/app \
  --interactive ${TTY} \
  --rm \
  registry.gitlab.com/chromaway/core-tools/chromia-cli/chr:${CHR_VERSION:-latest} chr "$@"
```

Windows Command Prompt Users

The bash script above relies on `$(pwd)`, which Windows Command Prompt does not support. On Windows:

* **PowerShell**: run the command unchanged; PowerShell also understands `$(pwd)`
* **Command Prompt**: Swap `$(pwd)` for `%CD%` in the mount command

**Mount line adjusted for Command Prompt:**

cmd

```nolines
--mount type=bind,source="%CD%",target=/usr/app \
```

First, create a new project with Chromia CLI.

shell

```nolines
chr create-rell-dapp fee_strategies --template=plain-multi
```

shell

```nolines
cd fee_strategies
```

Next, generate a new admin keypair:

shell

```nolines
chr keygen --file .chromia/admin-keypair
```

Finally, add the FT4 library to the project. In your `chromia.yml` file, create a `libs` section, add
`ft4` to it, and set the public key as your dapp's admin key:

chromia.yml

```
blockchains:
  fee_strategies:
    module: main
    moduleArgs:
      lib.ft4.core.admin:
        admin_pubkey: x"<dapp_account_pubkey>" # Replace with previously generated public key here.
compile:
  rellVersion: 0.14.9
database:
  schema: schema_fee_strategies
test:
  modules:
    - fee_strategies_test
  moduleArgs:
    lib.ft4.core.admin:
        admin_pubkey: x"<dapp_account_pubkey>" # Replace with previously generated public key here.
libs:
  ft4:
    registry: https://gitlab.com/chromaway/ft4-lib.git
    path: rell/src/lib/ft4
    tagOrBranch: v1.2.0r
    rid: x"E96915FD7C9A5DD4E183D86F4A5B4BB5083A7CC1EDEB1465EDFFC926E67C93F6"
    insecure: false
  iccf:
    registry: https://gitlab.com/chromaway/core/directory-chain
    path: src/lib/iccf
    tagOrBranch: 1.87.0
    rid: x"9C359787B75927733034EA1CEE74EEC8829D2907E4FC94790B5E9ABE4396575D"
    insecure: false
```

Install FT4 with:

shell

```nolines
chr install
```

Your project is now set up for FT4. The following lessons build on it to create assets, transfer tokens, and register user
accounts.

Written for this site from Chromia’s public course. Code samples are the course’s own.

[← Previous**Monetizing your dapp**](https://chromia.com/learn/monetize-dapp/introduction/)[Next →**Account registration**](https://chromia.com/learn/monetize-dapp/account-registration/)

On this page

* [Install](#install)
* [Prerequisite](#prerequisite)
* [Installation](#installation)
* [Updating Chromia CLI](#updating-chromia-cli)
* [Docker](#docker)