# Transfers

This is a simple Quartz demo app. It allows users to deposit funds to a
contract, transfer them around privately within the contract's encrypted state,
and withdraw whatever funds they have.

## Setup

### Install Rust

The minimum Rust supported version is v1.74.1.
The recommended Rust version v1.79.0 since we're running against
wasmd v0.45.

Install rust by executing a script from the internet (😅):

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Check the version with `cargo version`.

Finally add the wasm target:

```bash
rustup target add wasm32-unknown-unknown
```

And you should be good to go!

### Install Other Tools

You need a few other Go based tools. You should already have go.

First add the `~/go/bin` to your path by adding this line to the end of your
`~/.bashrc`:

```bash
export PATH="${PATH}:${HOME}/go/bin"
```

Then `source ~/.bashrc`. Now we can install some stuff.

You need grpcurl:

```bash
go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest
```

You need wasmd v0.45.0:

```bash
git clone https://github.com/cosmwasm/wasmd/
cd wasmd
git checkout v0.45.0
go install ./cmd/wasmd
```

Check that both work by running `grpcurl` and `wasmd`.

Finally, you need `websocat`:

```bash
cargo install websocat
```

### Fetch the Repo

While the repos are private you will need an ssh key registered on github in
order to fetch them. Run `ssh-keygen` and just follow the defaults. On Github,
go to Settings -> SSH and GPG Keys -> New SSH Key. Run `cat ~/.ssh/id_rsa.pub`
on the machine and copy and paste the result into Github.

This key will now have full access to your github account so its a good idea to
remove it when you're done and re-add everytime you need to push/pull the repo.

Now clone the repo:

```bash
git clone ssh://git@github.com/informalsystems/cycles-quartz
cd cycles-quartz
```

Tada!

### Setup Wasmd Accounts

Run `wasmd init <your name> --chain-id testing` to initialize the local wasmd
folder.

Now open the file `~/.wasmd/config/client.toml` and change the field
`keyring-backend` from `os` to `test`:

```toml
keyring-backend = "test"
```

Now, finally, we can create a local admin key for your wasmd. You'll use this to
deploy contracts:

```bash
wasmd keys add admin
```

This should output a wasm address.

Now either you will setup a local testnet or use an existing testnet. If its an
existing testnet, you need to fund this account. Send this address to someone
who has access to the admin account for your testnet. If you have access
yourself you can send funds yourself:

```bash
wasmd tx bank send <sender key name> <recipient address> <amount ucosm> --chain-id testing -y
```

If you're setting up your own local testnet, continue with the following:

```bash
# generate a second key for the validator
wasmd keys add validator

# fund both accounts in genesis
wasmd genesis add-genesis-account admin 100000000000stake,100000000000ucosm
wasmd genesis add-genesis-account validator 100000000000stake,100000000000ucosm

# sign genesis tx from validator and compose genesis
wasmd genesis gentx validator 100000000stake --chain-id testing
wasmd genesis collect-gentxs
```

Before finally starting the node, for it to work with the front end, you need to
configure CORS.

In `~/.wasmd/config/config.toml`, you'll need to make sure the listen address
binds to the public IP (0.0.0.0) and the CORS allows all origins:

```toml
[rpc]
laddr = "tcp://0.0.0.0:26657"
cors_allowed_origins = ["*"]
```

And in `~/.wasmd/config/app.toml`:

```toml
[api]
enable = true
address = "tcp://0.0.0.0:1317"
enabled-unsafe-cors = true
```

Now, finally:

```bash
wasmd start
```

And you should have a chain making blocks!

You can also reduce the block time by lowering `timeout_commit` in
`~/.wasmd/config/config.toml`.

Now that you have the chain running, you can start running the enclave and proxy
in other windows.

## Run

First set the `NODE_URL` variable to the address of the blockchain node. If it's
a local node, set it to `localhost:26657`. If it's a remote node, set it to that
node's address (eg. `export NODE_URL=143.244.186.205:26657`).

The `scripts` dir contains some bash scripts to help run the app. These scripts
should be replaced by a new `quartz` tool. See
[issue](https://github.com/informalsystems/cycles-quartz/issues/61).

**NOTE: If you want to run on a non-SGX machine, you must set the following
*environment variable prior to running any further commands in *all* terminals
*in which you run them:**

```bash
export MOCK_SGX=1
```

### Build the Binaries

Build the enclave binary and the smart contract binary:

```bash
bash scripts/build.sh
```

### Configure and Run Gramine

Setup and sign the Gramine config, and then start the gramine process, which
will run the gRPC server that hosts the transfer application. The quartz port
defaults to `11090`, but you can set it deliberately with `export
QUARTZ_PORT=XXXXX`. It is best to set it everytime, since if 2 people are sshing
into the same machine to use the secure enclave, this could create undesired env
conditions where your app is talking to the wrong enclave.

```bash
bash scripts/start.sh
```

The enclave binary is now running, waiting for commands.

### Contract Setup

With the enclave running in one window, open another window to deploy the
contract and start the listener.

In the new window, set the `NODE_URL` env variable again (e.g.
`export NODE_URL=143.244.186.205:26657`)

Now we can deploy the contract:

```bash
bash scripts/deploy.sh
```

Note the deployed contract address and save it into the `CONTRACT` env variable.

Now run the quartz handshake between contract and enclave:

```bash
bash scripts/handshake.sh $CONTRACT
```

This should output the pubkey and nonce.

### Run the Listener

Finally, we're ready to listen to events from the contract and trigger execution on the enclave:

```bash
bash scripts/listen.sh $CONTRACT
```

Now we can interact with the contract, and we'll see the events and contract
data come through.

### Run the Frontend

Now on your own machine, follow [these steps](./frontend/README.md#development).

Make sure you have Keplr installed in your browser and you should now be able to
use the app!

You may have to go to "Manage Chain Visibility" in Keplr settings to add the `My
Testing Chain` so you can see your balance.

You will also need to fund any keplr account by sending funds from the CLI using
your `admin` account.

Then you should be able to deposit, transfer, and withdraw using different Keplr
accounts. And everything will get processed automatically by the transfer.sh
script we have running on the enclave host!