DarkFi template smart contract
==============================

This repository is an example smart contract on DarkFi.

It shows how to write a Rust WASM contract that contains a ZK proof of
knowing a secret key and shows how to create signatures.

The source code is entirely documented, so it's best recommended to
read through it all to understand the structure.

`lib.rs` and `entrypoint.rs` define the actual smart contract, while
`main.rs` shows a simple tool that acts as the "client-side" of the
smart contract and explains how to create the contract calls that
become part of the transaction on DarkFi that will use this smart
contract.

The smart contract implements a simple membership proof and provides
two functions: `Register` and `Deregister`. These two functions simply
add or remove a public key commitment from a database on-chain,
provided that the functions' executions are valid and they pass.


## Compiling

The project requires the Rust WASM toolchain to compile the smart
contract, stable Rust to compile the helper client binary, and the
`zkas` compiler provided by DarkFi.

We can obtain the `wasm32-unknown-unknown` toolchain with `rustup`:

```
$ rustup target add wasm32-unknown-unknown
```

The `zkas` compiler can be compiled from the DarkFi repository:

```
$ git clone https://codeberg.org/darkrenaissance/darkfi && cd darkfi
$ make zkas
```

This project provides a convenient [`Makefile`](Makefile) that
is able to compile everything. Just make sure to update the path
to the `zkas` compiler or have it in your `$PATH`.

```
$ make
```

Running `make` should result in having both `membership` and
`membership.wasm` in the git project root directory.


## Deterministic WASM build

We can also use [`nix`](https://nixos.org/) to produce a deterministic
build of the WASM module. This is useful when we want to prove this
source code matches the deployed binary on the DarkFi blockchain.

The provided `flake.nix` contains the code necessary to produce such
a build.

```
$ nix build && cp -f result/membership.wasm .
```


## Deploying on DarkFi

TODO


## Creating a transaction using this smart contract

Once deployed, we should get a contract ID for our deployed contract.
For the example, let's assume it's `4eHp8tazRggmt8vhvs7To3rkUydPMrqDADKZYgEpr3uu`.

We can use the `membership` tool to generate an identity:

```
$ ./membership generate
Secret key: efksR5iyVzpBsaWDuoUL47EFe9LMspdMVLqQCk5Mgvk
Public key: 9RQLjpVS93oevYpC5Tj3brfQXDpb63wqos813aSWgP1k
```

And then we can create a `register` call with our new secret key:

```
$ ./membership register 4eHp8tazRggmt8vhvs7To3rkUydPMrqDADKZYgEpr3uu efksR5iyVzpBsaWDuoUL47EFe9LMspdMVLqQCk5Mgvk > register.call
```

Once we have this call, we can use the `drk` wallet tool to create
the actual transaction and attach the `fee` call to pay any necessary
execution fees on-chain.

```
$ drk tx-from-calls < register.call | drk attach-fee > register.tx
$ drk broadcast < register.tx
```

(Refer to the [DarkFi Book](https://dark.fi/book/) for more advanced usage)

## License

[GNU AGPL-3](LICENSE.md)