Nayms Smart Contracts v3

This repository contains Nayms V3 smart contracts.

Contract Deployments

| Network | Address | | --- | --- | | Ethereum | 0x39e2f550fef9ee15b459d16bD4B243b04b1f60e5 | | Base | 0x546Fb1621CF8C0e8e3ED8E3508b7c5100ADdBc03 |

Set up your project configuration

This is a Foundry based project, so make sure you have it installed.

Check .env.example to see some of the environment variables you should have set in .env in order to run some of the commands.

Create a .env and ensure it contains:

ETHERSCAN_API_KEY=...
BASESCAN_API_KEY=...
BLOCKSCOUT_API_KEY=...
ETH_MAINNET_RPC_URL=...
ETH_SEPOLIA_RPC_URL=...
ETH_LOCAL_RPC_URL=...
BASE_SEPOLIA_RPC_URL=...
BASE_MAINNET_RPC_URL=...
AURORA_MAINNET_RPC_URL=...
AURORA_TESTNET_RPC_URL=...

Create a nayms_mnemonic.txt file and ensure it contains the team mnemonic.

Build Project

make build

This will generate the diamond proxy interface, diamond helper library and the abi file.

Test Project

make test

Deploy the diamond

Smart contracts in this repository implement the EIP-2535 a.k.a. the diamond standard and use Gemforge for deployment. You can read more about it in the official docs.

A script - script/gemforge/deploy.js - is provided as a convenience for handling the Nayms phased deployments flow. You can call this directly or just use yarn deploy ...

Currently supported deployment targets are:

• local: Local Anvil Node
• sepolia: Sepolia
• sepoliaFork: a local fork of Sepolia
• mainnet: Ethereum Mainnet
• mainnetFork: a local for of Ethereum Mainnet
• base: Base Mainnet
• baseFork: a local fork of Base Mainnet
• baseSepolia: Base Sepolia
• baseSepoliaFork: a local fork of Base Sepolia
• aurora: Aurora Mainnet (NEAR)
• auroraFork: a local fork of Aurora Mainnet (NEAR)
• auroraTestnet: Aurora Testnet (NEAR)
• auroraTestnetFork: a local fork of Aurora Testnet (NEAR)

Querying

To see how the current deployed Diamond differs from the compiled code for a target:

yarn query <target>

Fresh deployments

To do a fresh deployment to a given target:

yarn deploy <target> --fresh

Upgrades

To upgrade a deployment on a target:

yarn deploy <target> --upgrade-start
yarn deploy <target> --upgrade-finish

Note: For mainnet you will need to enable the upgrade using the MPC wallet. For non-mainnet targets the script will automatically do this for you.

Running a Local Node

For development purposes, you can run a node locally using foundry's anvil. It's a simple way to bring up a local node exposing a JSON-RPC endpoint at http://127.0.0.1:8545. Make sure to start anvil in one of your terminal windows and in another one run a make target to deploy the Nayms' contracts to it.

Following commands are provided for working with anvil, to make it more convenient:

| Command | Description | | ----------- | ----------- | | make anvil | Run the local node seeding it with Nayms' shared wallet | | make anvil-docker | Rund the local node inside a container, also seeding it with Nayms' shared wallet | | make anvil-add-supported-external-token | Add GToken as supported external token | | make fork-sepolia| Fork Sepolia test net locally | | make fork-base-sepolia| Fork Base Sepolia test net locally | | make fork-mainnet| Fork Ethereum Mainnet locally | | make fork-base| Fork Base Mainnet locally | | make fork-aurora| Fork Aurora Mainnet locally | | make fork-aurora-testnet| Fork Aurora Testnet locally |

:warning: Anvil state is kept in anvil.json file in project root, except for forks. If this file is not present, node starts fresh and creates this file. In which case you need to do the deployment and setup.

One of the things you will need, to do proper testing with local node, is to deploy an ERC-20 compatible token along with Nayms contracts and make that token a supported external token. Below is an example of how to do that.

Bootstrapping a local node

When working with local node, there are a few things you might need to do in preparation to be able to actually use it with client applications. As a convenience, a script is provided automating the following tasks.

• Deploy the diamond to local node
• Deploy test ERC20 compatible token (GTOKEN) to local node
• Make this token a supported external token
• Mint some tokens to acc1, acc2, acc3 and acc4 from the nayms_mnemonic.txt

Run it from project root folder against fresh new local node instance, otherwise some steps might fail:

cli-tools/anvil_bootstrap.sh

Output, compare gas snapshots

make gas

Build Troubleshooting Tips

In case you run into an issue of forge not being able to find a compatible version of solidity compiler for one of your contracts/scripts, you may want to install the solidity version manager svm. To be able to do so, you will need to have Rust installed on your system and with it the accompanying package manager cargo. Once that is done, to install svm run the following command:

cargo install svm-rs

To list the available versions of solidity compiler run:

svm list

Make sure the version you need is in this list, or choose the closest one and install it:

svm install "0.8.20"

Fork testing

Convenience targets are provided in the Makefile for running a specific test against a forked network.

To run a test against a Goerli fork use the following command passing in the test matching expression i.e. testStartTokenSale

make test-goerli MT=testStartTokenSale

Similarly a Mainnet fork test can be executed via:

make test-mainnet MT=testStartTokenSale

Staging for Production Deployment Flow

Run integration tests with mainnet forking.

Ensure "initialization" of entire system.

Use deterministic deployment.

Monitor all events, Nayms Diamond transactions, mempool.

Production Flow

Helpful Links

Louper Diamond Inspector - Etherscan for Diamonds

Acknowledgements

Ramesh Nair @hiddentao

Foundry

Nick Mudge