CONTRIBUTING.md

0x Mesh Development and Contribution Guide

Cloning the Repository and Opening PRs

Clone the repository with git clone [email protected]:0xProject/0x-mesh.git. Mesh uses Go Modules for dependency management, so depending on your settings you might need to clone the repository outside of your GOPATH.

0x Mesh uses two main branches:

1. The development branch contains the latest (possibly unreleased) changes and is not guaranteed to be stable.
2. The master branch contains the latest stable release.

If you intend to fork 0x Mesh and open a PR, you should work off of the development branch. Make sure you check out the development branch and pull the latest changes.

git checkout development
git pull

All PRs should use development as the base branch. When opening a new PR, use the dropdown menu in the GitHub UI to select development.

Prerequisites

• GNU Make If you are using a Unix-like OS, you probably already have this.
• Go version 1.15.x (or use the version manager called "g").
• Node.js version >=11 (or use the nvm version manager).
• Yarn package manager.
• golangci-lint version 1.27.0.
• Python. (Many OSes already have this).
• Google Chrome. If you already have Google Chrome you typically don't need to do anything. On Ubuntu you can run wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb && dpkg -i google-chrome-stable_current_amd64.deb; apt-get -fy install.
• A C compiler such as GCC or Clang. Some OSes will already have this. On Ubuntu you can run sudo apt-get install build-essential.

Installing Dependencies

make deps

Building TypeScript packages

Mesh contains some TypeScript packages, all of which are contained in a small monorepo in the packages/ directory. Some packages are published, and some are only used internally for development and testing.

To build all the TypeScript packages:

yarn build

You can also run yarn build inside of individual packages in order to just build that package and its dependencies. However, changing any Go code will require running yarn build at the root of the project again.

Running Tests

Some of the tests depend on having a test Ethereum node running. Before running the tests, make sure you have Docker installed locally and start 0xorg/ganache-cli with the appropriate snapshot version passed in the VERSION environment variable. The snapshot version that is used in the mesh project's CI can be found here

docker run --rm --pull -ti -p 8545:8545 -e VERSION=6.5.11 0xorg/ganache-cli

There are various Make targets for running tests:

# Run tests in pure Go
make test-go

# Compile to WebAssembly and run tests in Node.js
make test-wasm-node

# Compile to WebAssembly and run tests in a headless Chrome browser
make test-wasm-browser

# Run tests in all available environments
make test-all

Potential Issues

The default maximum number of open files is too low in some operating systems for the tests to be run successfully. If an error that reads like "Too many open files," it may be necessary to increase this limit. On Unix-like operating systems, the ulimit command can be used as follows to accomplish this change:

# Increase number of open files that are tolerated to 2048 (a big number)
ulimit -S -n 2048

It may be convenient to add this line to the .bashrc (or .bash_profile for MacOs users) file so that the change will go into effect whenever a new shell is created.

Running the Linters

0x Mesh is configured to use linters for both Go and TypeScript code. To run all available linters, run:

make lint

Running prettier

0x Mesh uses a tool called prettier, which is a tool that enforces a consistent style across the Typescript codebase. The continuous integration pipeline will fail if Typescript code is not "prettified," so prettier must be run to ensure that the code is properly formatted.

The prettier tool can be run using the following command from the top-level of the 0x-Mesh repository (outside of a directory inside packages/):

yarn prettier

Managing Dependencies

Mesh uses Go Modules for managing Go dependencies and Yarn for managing TypeScript/JavaScript dependencies.

Editor Configuration

Visual Studio Code

For VS Code, the following editor configuration is recommended:

{
  // ...

  "editor.formatOnSave": true,
  "go.formatTool": "goimports",
  "go.lintTool": "golangci-lint",
  "go.lintOnSave": "package",
  "go.vetOnSave": "off"

  // ...
}

When working on code with the build tag js,wasm, you might need to add the following to your editor config:

{
	// ...

  "go.toolsEnvVars": {
    "GOARCH": "wasm",
    "GOOS": "js"
  },
  "go.testEnvVars": {
    "GOARCH": "wasm",
    "GOOS": "js"
	}

	// ...
}

Prettier

Prettier configurations for most popular text editors can be found here.

TSLint

TSLint configurations for most popular text editors can be found here.

Updating the Go contract wrappers

Installing abi-gen:

See https://geth.ethereum.org/docs/dapp/native-bindings

git clone [email protected]:ethereum/go-ethereum.git
cd go-ethereum
git checkout v1.9.24
go install ./cmd/abigen

Obtain contract ABIs:

Extract any ABI from @0x/contract-artifacts/artifacts/*.json, taking only the contents of the abi key. For example for the V4 DevUtils contract:

git clone [email protected]:0xProject/protocol.git
jq < protocol/packages/contract-artifacts/artifacts/DevUtils.json .compilerOutput.abi > DevUtilsV4.abi.json

jq < ../protocol/packages/contract-artifacts/artifacts/IZeroEx.json .compilerOutput.abi > IZeroEx.abi.json

The V4 ABI contains some internal functions whose names start with _. The next abigen command will strip the underscores and fail due to name collisions with non-prefixed versions. The easiest solution is to manually remove these functions from the JSON. (TODO: Come up with a jq query to automate this).

Generate wrapper:

abigen --abi ./IZeroEx.abi.json --pkg wrappers --type ExchangeV4 --out ethereum/wrappers/exhange_v4.go

Then edit the file and correct the package name and remove any commonalities between different wrappers.