Solidity is a high-level, object-oriented programming language specifically designed for implementing smart contracts on blockchain platforms like Ethereum. Smart contracts are self-executing programs with the contract's terms written directly into lines of code. These contracts automatically enforce and execute agreements once predefined conditions are met, without the need for intermediaries.

Key Features of Solidity:

1. Statically Typed: Variables are declared with specific data types, such as uint, bool, address, etc. This allows for more optimized and predictable code execution.

2. Inheritance: Solidity supports multiple inheritance, allowing developers to create modular, reusable code for smart contracts.

3. Contract-Oriented: Solidity is specifically built for writing smart contracts. Each contract has its own state and can interact with other contracts.

4. EVM Compatibility: Solidity compiles down to bytecode that runs on the Ethereum Virtual Machine (EVM). This makes it compatible with all Ethereum-based blockchains.

5. Libraries: Solidity allows developers to define reusable libraries, which help in reducing code duplication.

6. Interfaces and Abstract Contracts: These are used to define templates and expected behaviors for other contracts, providing structure and reusability across the system.

Deploying on a Local Network

1. Compile the contract:

2. Deploy the contract: Create a script /scripts/deploy.js

OpenZeppelin

Introduction

OpenZeppelin is well known in the Ethereum developer community as their set of audited smart contracts and libraries are a standard in the industry. For example, most of the tutorials that show developers how to deploy an ERC-20 token use OpenZeppelin contracts.

You can find more information about OpenZeppelin on their .

As part of its Ethereum compatibility features, OpenZeppelin products can be seamlessly used on Phron. This page will provide information on different OpenZeppelin solutions that you can test.

OpenZeppelin on Phron

Currently, the following OpenZeppelin products/solutions work on the different networks available on Phron:

You will find a corresponding tutorial for each product in the following links:

• Contracts Wizard — where you'll find a guide on how to use OpenZeppelin web-based wizard to create different token contracts with different functionalities

• Contracts & libraries — where you'll find tutorials to deploy the most common token contracts using OpenZeppelin's templates: ERC-20, ERC-721 and ERC-1155

• Defender — where you'll find a guide on how to use OpenZeppelin Defender to manage your smart contracts in the Phron TestNet. This guide can also be adapted for Phron

This tutorial is for educational purposes only. As such, any contracts or code created in this tutorial should not be used in production.The information presented herein has been provided by third parties and is made available solely for general information purposes. Phron does not endorse any project listed and described on the Phron Doc Website (https://docs.Phron.ai/). Phron does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Phron disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Phron. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Phron has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Phron harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.

Debug API & Trace Module

Introduction

Geth's debug and txpool APIs and OpenEthereum's trace module provide non-standard RPC methods for deeper insight into transaction processing. Some of these non-standard RPC methods are supported as part of Phron's goal of providing a seamless Ethereum experience for developers. Supporting these RPC methods is an essential milestone because many projects like rely on them to index blockchain data.

This guide will cover the supported RPC methods available on Phron and how to invoke them using curl commands against a tracing node with the debug, txpool, and tracing flags enabled. You can access a tracing node in one of two ways: through a supported tracing RPC provider or by spinning up a tracing node of your own.

To view a list of tracing RPC providers, please check out the Network Endpoints page.

Setting Up the Development Environment

1. Initialize the Project

Create a new directory for your project and initialize it with npm

Security Best Practices for Smart Contracts

When writing and deploying smart contracts, ensuring security is crucial. Below are some key security considerations that must be followed to mitigate potential vulnerabilities and protect user funds and data.

1. Reentrancy Protection

Reentrancy attacks occur when an external contract makes recursive calls to the original function before the first invocation is completed. This can lead to funds being drained. Use OpenZeppelin’s nonReentrant modifier from the ReentrancyGuard library to protect against reentrancy attacks.

Verify Smart Contracts using PhronScan

Introduction

Verifying smart contracts on a PhronScan is a great way to improve the transparency and security of deployed smart contracts on Phron. Users can directly view the source code for verified smart contracts, and for some block explorers, they can also directly interact with the contract's public methods through the PhronScan's interface.

Writing Unit Tests

Unit tests are essential to ensure your smart contract behaves correctly. Using Mocha and Chai in conjunction with Hardhat provides a robust framework for testing your Solidity contracts.

Install Mocha/Chai

To set up testing, install the required libraries:

Example Test Suite: Token Contract

Here's an improved example of a test suite for a token contract:

Breakdown of the Test Cases:

1. Deployment Tests:

   • Ownership: Verifies that the contract's owner is correctly assigned upon deployment.

   • Initial Token Distribution: Confirms that the contract assigns the total token supply to the owner's balance.

2. Transaction Tests

Running the Tests

To run the test suite, use the following command:

This will execute all test cases and display the results, ensuring that your contract behaves as expected under various conditions.

Improvements in this Version:

• Modular Tests: Divided tests into logical groups (e.g., Deployment and Transactions) for better organization and readability.

• Edge Case Testing: Added test cases for failure conditions (like insufficient balances) to ensure that your contract handles errors correctly.

• Reusability: Used beforeEach to deploy a fresh contract instance for each test, ensuring isolation between test cases and preventing state leakage.

This structure makes the tests more maintainable and easier to extend as your contract grows.

Before starting development, ensure that you have the following tools installed:

• Node.js (v14 or above)

• NPM or Yarn (for package management)

• Solidity Compiler (solc)

• Truffle or Hardhat (for smart contract development)

• Phron testnet for local testing

• Metamask or any other Ethereum wallet

Here’s a quick guide on installing and setting up the tools you need for Solidity smart contract development, along with code examples for using each tool:

1. Node.js (v14 or above)

Node.js is required to run JavaScript-based tools like Truffle and Hardhat.

Installation:

• and install it for your operating system.

• Verify installation:

2. NPM or Yarn (for package management)

NPM comes with Node.js by default, but you can use Yarn as an alternative.

Installation (NPM is included with Node.js):

• Verify installation:

Installation (Yarn):

3. Solidity Compiler (solc)

Solidity compiler (solc) is needed to compile smart contracts.

Installation:

• Using NPM:

• Verify installation:

Example:

Compiling a contract with solc:

4. Truffle or Hardhat (for smart contract development)

Both tools are widely used for developing, testing, and deploying smart contracts.

Truffle Installation:

Hardhat Installation:

Example (Hardhat project setup):

Example (Truffle project setup):

5. Get a Phron end point from

Nodes and JSON-RPC Endpoints

Generally speaking, a JSON-RPC is a remote procedure call (RPC) protocol that utilizes JSON to encode data. For Web3, they refer to the specific JSON-RPCs that DApp developers use to send requests and receive responses from blockchain nodes, making it a crucial element in interactions with smart contracts. They allow frontend user interfaces to seamlessly interact with the smart contracts and provide users with real-time feedback on their actions. They also allow developers to deploy their smart contracts in the first place!

To get a JSON-RPC to communicate with a Phron blockchain, you need to run a node. But that can be expensive, complicated, and a hassle. Fortunately, as long as you have access to a node, you can interact with the blockchain. Phron has a handful of free and paid node options. For this tutorial, we will be using the Phron's public node for Phron, but you are encouraged to get your own private endpoint.

So now you have a URL. How do you use it? Over HTTPS, JSON-RPC requests are POST requests that include specific methods for reading and writing data, such as eth_call for executing a smart contract function in a read-only manner or eth_sendRawTransaction for submitting signed transactions to the network (calls that change the blockchain state). The entire JSON request structure will always have a structure similar to the following:

This example is getting the balance (in DEV on Phron) of the 0xf24FF3a9CF04c71Dbc94D0b566f7A27B94566cac account. Let's break down the elements:

• jsonrpc — the JSON-RPC API version, usually "2.0"

• id — an integer value that helps identify a response to a request. Can usually just keep it as `

• method — the specific method to read/write data from/to the blockchain. You can see many of the RPC methods on our docs site

There are also additional elements that can be added to JSON-RPC requests, but those four will be seen the most often.

Now, these JSON-RPC requests are pretty useful, but when writing code, it can be a hassle to create a JSON object over and over again. That's why there exist libraries that help abstract and facilitate the usage of these requests. Phron provides documentation on many libraries, and the one that we will be using in this tutorial is Ethers.js. Just understand that whenever we interact with the blockchain through the Ethers.js package, we're really using JSON-RPC!

6. Metamask or Other Ethereum Wallets

Metamask is a browser-based Ethereum wallet for interacting with decentralized applications (dApps).

Installation:

• and install the browser extension.

Contract Interfaces

Interfaces in Solidity are used to define the structure of external functions without providing their internal logic. They are essential for creating interoperable contracts that follow a standard design, ensuring that different contracts can interact with one another seamlessly.

• transfer(address recipient, uint256 amount): Defines a function to transfer tokens to a specified recipient. It returns a boolean (true

Supported Ethereum RPC Methods

Introduction

Nevertheless, not all Ethereum JSON-RPC methods are supported; some of those supported return default values (those related to Ethereum's PoW consensus mechanism in particular). This guide provides a comprehensive list of supported Ethereum JSON-RPC methods on Phron. Developers can quickly reference this list to understand the available functionality for interfacing with Phron's Ethereum-compatible blockchain.

Key Functions in the Smart Contract

1. transfer: Transfers tokens from the caller's account to the recipient.

• Purpose: To allow a user to send tokens from their balance to another address.

• Inputs:

  • recipient: The address receiving the tokens.

  • amount: The number of tokens to transfer.

• Outputs: Returns true if the transfer is successful.

• Logic: The function first checks if the sender has enough tokens, then deducts the specified amount from the sender’s balance and adds it to the recipient's balance. It also emits a Transfer event for transparency.

2. mint: Allows the contract owner to mint new tokens and increase the total supply.

• Purpose: To create (mint) new tokens and add them to the owner's balance, increasing the total token supply.

• Inputs:

  • amount: The number of tokens to be created and assigned to the owner's balance.

3. burn: Allows a user to burn tokens from their balance, reducing the total supply.

• Purpose: To allow users to burn (destroy) tokens from their balance, reducing the total supply.

• Inputs:

  • amount: The number of tokens to burn.

4. balanceOf: Returns the balance of a specified address.

• Purpose: To provide a way for anyone to check the token balance of a specific address.

• Inputs:

  • account: The address whose balance is being queried.

5. transferFrom: Allows an approved spender to transfer tokens on behalf of the token owner.

• Purpose: To allow a third-party (spender) to transfer tokens on behalf of the token owner, given that they’ve been granted approval.

• Inputs:

  • sender: The address of the token owner who is authorizing the transfer.

6. approve: Allows a token owner to approve a spender to transfer tokens on their behalf.

• Purpose: To grant approval to a third-party (spender) to transfer tokens on behalf of the token owner.

• Inputs:

  • spender: The address of the entity authorized to transfer tokens.

Summary of Key Functions

Each function serves a specific role in token management, ensuring that users can securely transfer, mint, burn, and authorize token transactions, all while maintaining transparency via events.

Using Tenderly on Phron

Introduction

is a Web3 development platform that contains a suite of tools designed to help developers throughout the DApp development life cycle. With Tenderly, you can build, debug, test, optimize, monitor, set up alerts, and view analytics for your smart contracts on Phron.

OpenZeppelin Defender

Introduction

OpenZeppelin Defender is a web-based application that allows developers to perform and automate smart contract operations in a secure way. Defender V2 offers the following components:

• — Automatic code analysis powered by AI models and tools developed by OpenZeppelin engineers

• — Manage the smart contract audit process and track issues and resolutions

• — Manage deployments and upgrades to ensure secure releases

• — to monitor your smart contract's events, functions, and transactions, and receive notifications via email

• — Configure predefined incident response scenarios triggered automatically by monitors or on-demand

• — Create automated actions to perform on-chain and off-chain operations

• — Manage smart contract accounts, roles, and permissions easily

OpenZeppelin Defender can be used on Phron, and the Phron TestNet. This guide will show you how to get started with Defender and demonstrate using OpenZeppelin Actions and Access Control to pause a smart contract on Phron.

Getting Started with Defender

This section goes through the steps for getting started with OpenZeppelin Defender on Phron.

Checking Prerequisites

The steps described in this section assume you have installed and connected to the Phron TestNet. If you haven't connected MetaMask to the TestNet, check out our MetaMask integration guide.

In addition, you need to sign up for a free OpenZeppelin Defender account, which you can do on the main .

Deploying the Pausable Box Contract

The contract used in this guide is an extension of the Box.sol contract used in the from the OpenZeppelin documentation. Also, the contract was made upgradable and to take full advantage of the Admin component. You can deploy your contract using the following code and following the :

Note

After deploying the above contract using Remix or another tool such as Hardhat, you'll need to call the initialize function to properly set the owner of the upgradeable contract. If you don't call this function, the owner will be set to the zero address, and you will be unable to proceed with the remainder of this tutorial.

Using the Access Control Component

This section goes through the steps for getting started with the to manage smart contracts on Phron.

Importing Your Contract

The first step to using Defender Access Control is to add the contract you want to manage. To do so, take the following steps:

1. Click on the Access Control menu item

2. Click Add Contract

3. Add a name for your contract

4. Select the Network on which the contract is deployed. For the demo,Phron is selected

If everything was successfully imported, you should see your contract on the Access Control Contracts main screen. You should see the address that you used to deploy the Pausable Box contract in the Owner field. If you see 0x0000000000000000000000000000000000000000, this means that you didn't call the initialize function after deploying the Pausable Box contract. To simplify a later step, take a moment to add your address to your Defender Address Book by hovering over the address in the Owner field and clicking Import into Defender 2.0.

Then, you can add your address to the Defender Address Book as follows:

1. Enter a name for your address

2. Select the relevant network that the address pertains to

3. Paste the address

4. Review all the information and press Create

Create a Contract Proposal

Proposals are actions to be carried out in the contract. You can propose any function of the contract to be enacted, including but not limited to:

• Pause — available if the pause feature is detected. Pauses token transfers, minting, and burning

• Upgrade — available if the upgrade feature is detected. Allows for a contract to be

• Admin action — call to any function in the managed contract

In this case, a new proposal is created to pause the contract. To do so, take the following steps:

1. Click on the Actions menu item

2. Click Transaction Proposals

3. Enter a name for the proposal

4. Optionally, you may enter a description of the proposal

To create a simple new approval process consisting of only the contract owner, take the following steps:

1. Enter a name for the approval process

2. Select EOA

3. Select the owner of the Pausable Box contract

4. Review all information and press Save Changes

The last step remaining is to submit the transaction proposal. To do so, take the following steps:

1. Press Connect Wallet and connect your EVM account to Defender

2. Press Submit Transaction Proposal

Approve a Contract Proposal

Press Continue, and you'll be taken to the proposal status page. Here, you'll be able to execute the proposal. Press Approve and Execute, and confirm the transaction in your EVM wallet. Once the transaction is processed, the status should show Executed.

If all went smoothly, your Pausable Box Contract is now paused. If you'd like to try out additional scenarios, you can try creating a proposal to unpause your contract. And that's it! You're now well on your way to mastering OpenZeppelin Defender to manage your smart contracts on Phron. For more information, be sure to check out the .

This tutorial is for educational purposes only. As such, any contracts or code created in this tutorial should not be used in production.The information presented herein has been provided by third parties and is made available solely for general information purposes. Phron does not endorse any project listed and described on the Phron Doc Website (https://docs.Phron.ai/). Phron does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Phron disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Phron. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Phron has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Phron harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.

Using Scaffold-ETH 2 to Deploy a DApp on Phron

Introduction

Scaffold-ETH 2 is a collection of commonly used Ethereum development tools to quickly deploy a Solidity smart contract and launch a DApp with a React frontend.

Scaffold-ETH 2 consists of several sub-components, including for creating, deploying, and testing smart contracts and for building a React frontend. These components can be used on Phron networks with some slight modifications.

This guide will walk through the steps to deploy and run the default example contract and DApp that Scaffold-ETH 2 comes with on a Phron network.

Checking Prerequisites

To get started, you will need the following:

• An account with funds. You can get DEV tokens for testing on Phron once every 24 hours from the

• A Phronscan API key

• To test out the examples in this guide on Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers

Installing Scaffold-ETH 2

First, download .

From the command line, enter:

After the download completes, run:

The Development Process with Scaffold-ETH 2

The process for developing a project with Scaffold-ETH 2 can be outlined as follows:

1. Update the network configurations in Hardhat for Phron

2. Add your smart contracts to the packages/hardhat/contracts

3. Edit your deployment scripts in the packages/hardhat/deploy

4. Deploy your smart contracts to Phron

In this guide, you can use the default contract and frontend that you get out of the box when you clone the Scaffold-ETH 2 repository. All you'll have to do is modify these components for Phron.

The Hardhat Component

In the following sections, you'll update the network configurations in the Hardhat configuration file to target the Phron-based network you want to interact with, and deploy and verify the example contract to that network.

Configure Hardhat for Phron

You can begin by making modifications to the Hardhat component under the packages/hardhat folder. You'll primarily be editing the hardhat.config.js file to configure it for Phron. However, you'll also need to create a .env file to store a couple of variables that will be consumed by the hardhat.config.js file.

You can refer to the .env.example file for the variables that are already used in the hardhat.config.js file. For Phron, you'll only need to create two variables: DEPLOYED_PRIVATE_KEY and ETHERSCAN_API_KEY.

Check out the Etherscan Plugins documentation to learn how to generate a Phronscan API key.

To get started, create a .env file:

Edit your .env file to include the following variables:

The private key you add to your .env file corresponds to the account that will deploy and interact with the smart contracts in your Hardhat project. Additionally, the Etherscan API key will correspond to your Phronscan API key and will be used to verify your deployed smart contracts. To learn how to generate a Phronscan API key, check out the Etherscan Plugins documentation.

With the environment variables taken care of, next you can modify the hardhat.config.js file for Phronscan:

1. Set the constant defaultNetwork to the network you are deploying the smart contract to

2. Add the network configurations for the Phron network you want to interact with under the networks configuration object

For more information on using Hardhat with Phron, please check the dedicated Hardhat page for more details.

Deploy Your Contract to Phron

After all the modifications to the configuration files are done, you can deploy your contract to the configured Phron-based network.

First, you can compile your contract by running:

Then, you can run the following command from the root directory of your project:

Note

If you did not set the defaultNetwork config in the hardhat.config.js file, you can append --network INSERT_NETWORK to the command. For example, the following command would deploy a contract to Phron.

Verify Your Deployed Contract

If you would also like to use Scaffold-ETH 2 to verify the deployed smart contract and have entered your Phronscan API key into the .env file, you can go ahead and verify your deployed contract.

If the smart contract you are verifying has constructor method parameters, you will also need to append the parameters used to the end of the command.

You can use the following command to verify the smart contract:

Note

If you did not set the defaultNetwork configuration in the hardhat.config.js file, you can append --network INSERT_NETWORK to the command. For example, the following command would verify a contract on Phron.

After a short wait, the console output will display the verification result and, if successful, the URL to the verified contract on Phronscan.

For more information about verifying smart contracts on Phron using the Hardhat Etherscan plugin, please refer to the Etherscan Plugins page.

The Next.js Component

In the following sections, you'll modify the Next.js configuration so that it targets the Phron-based network that your contract has been deployed to, and then you'll launch the dApp.

Configure the DApp for Phron

To target the Phron network that you deployed your smart contract to, you'll need to edit the configurations in the packages/nextjs/scaffold.config.ts file. More specifically, you'll need to modify the targetNetworks array in the scaffoldConfig object. You can use the to specify the chain(s) you've deployed your contract to.

That's all you have to do to configure Next.js! Next, you can launch the dApp.

Launch the DApp

After all the modifications to the configuration files are done, you can launch the example dApp. To do so, you can run:

This will launch the React-based DApp frontend at by default. You can then point your browser to and interact with the React frontend by connecting your wallet or checking out the contract debugger page.

And that's it! Now that you have the basics down, feel free to create and deploy your own smart contracts and modify the frontend to fit your dApp's needs! For more information, you can check out the .

This tutorial is for educational purposes only. As such, any contracts or code created in this tutorial should not be used in production.The information presented herein has been provided by third parties and is made available solely for general information purposes. Phron does not endorse any project listed and described on the Phron Doc Website (https://docs.Phron.ai/). Phron does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Phron disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Phron. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Phron has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Phron harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.

Using OpenZeppelin Contracts and Remix To Deploy To Phron

Introduction

contracts and libraries have become a standard in the industry. They help developers minimize risk, as their open-source code templates are battle-tested for Ethereum and other blockchains. Their code includes the most used implementations of ERC standards and add-ons and often appears in guides and tutorials around the community.

Using Remix to Deploy to Phron

Introduction

is an integrated development environment (IDE) for developing smart contracts on Ethereum and Ethereum-compatible chains. It provides an easy-to-use interface for writing, compiling, and deploying smart contracts. Given Phron’s Ethereum compatibility features, you can use Remix directly with any Phron network.

Using Brownie to Deploy To Phron

Introduction

Brownie is an Ethereum development environment that helps Python developers manage and automate the recurring tasks inherent to building smart contracts and DApps. Brownie can directly interact with Phron's Ethereum API so it can also be used to deploy smart contracts on Phron.

This guide will cover how to use Brownie to compile, deploy, and interact with Ethereum smart contracts on the Phron TestNet.

Please note that Brownie is no longer actively maintained. You can check out as an alternative Python Ethereum development environment.

Checking Prerequisites

To get started, you will need the following:

• Have MetaMask installed and connected to Phron

• Have an account with funds. You can get DEV tokens for testing on Phron once every 24 hours from the .

• To test out the examples in this guide on Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers

For this guide, Python version 3.9.10, pip version 22.0.3, and pipx version 1.0.0 were used.

Creating a Brownie Project

You will need to install Brownie and create a Brownie project if you don't already have one. You can choose to either create an empty project or use a , which is essentially a template to build your project on. For this example, you can create an empty project. You can get started by completing the following steps:

1. Create a directory for your project

2. If you don't already have pipx installed, go ahead and install it

3. , which is used to run executables installed locally in your project. Brownie will be installed into a virtual environment and be available directly from the command line

Note

A common error while installing Brownie on Ubuntu is:

This can be resolved by using the following command:

1. Create a project

Your Brownie project should contain the following empty directories:

• build - for project data such as contract artifacts from compilation

• contracts - to store the smart contract files

• interfaces - for smart contract interfaces that are required for your project

• reports - for JSON report files for use in the

Another important file to note that is not included in an empty project is the brownie-config.yaml configuration file. The configuration file is optional and comes in handy when customizing specific settings such as a default network, compiler version and settings, and more.

Network Configuration

To deploy to a Phron network, you'll need to add and configure the network. Network configurations in Brownie are added from the command line. Brownie can be used with both development and live environments.

Phron are supported out of the box with Brownie as of version 1.19.3. To view the complete list of supported networks, you can run the following command:

If you're looking to deploy a contract to a Phron development node you'll need to add the network configurations. Under the hood, Brownie uses Ganache for development environments. However, since a Phron development node acts as your own personal development environment, Ganache isn't needed. Therefore, you can configure a development node as a "live" network.

To add Phron development node configurations, you can run the following command:

If you successfully added the network, you'll see a success message along with the network details in the terminal.

To deploy to a Phron network, or run tests on a specific network, you can specify the network by appending the following to the given command:

If you would like to set a default network, you can do so by adding the following snippet to the brownie-config.yaml configuration file:

Note

Keep in mind that the brownie-config.yaml file isn't automatically created, you can optionally create it yourself.

Setting your Networks RPC URLs

It is recommended that you override the default Brownie RPC URLs to your own RPC endpoint or the public Phron network endpoints. You can override the default Brownie RPC URL for each network as follows:

Account Configuration

Before you can deploy a contract, you'll need to configure your account, which is also done from the command line. To add a new account you can run:

Make sure to replace INSERT_ACCOUNT_NAME with your name of choice. For this example, alice will be used as the account name.

You'll be prompted to enter in your private key and a password to encrypt the account with. If the account was successfully configured, you'll see your account address printed to the terminal.

The Contract File

Next you can create a contract inside of the contracts directory. The smart contract that you'll deploy as an example will be called Box, it will let you store a value that can be retrieved later. You can create a Box.sol contract by running the following command:

Open the file and add the following contract to it:

Compiling Solidity

To compile the contract you can simply run:

Note

The first time you compile your contracts it may take longer than usual while the solc binary is installed.

After compilation, you'll find the build artifacts in the build/contracts directory. The artifacts contain the bytecode and metadata of the contract, which are .json files. The build directory should already be in the .gitignore file but if it's not, it’s a good idea to add it there.

If you want to specify the compiler version or compilation settings, you can do so in the brownie-config.yaml file. Please note that if you haven't already created this file, you will need to do so. Then you can specify the compiler like so:

Note

You can view the list of in their documentation.

Your contracts will only be compiled again if Brownie notices that a change has been made. To force a new compilation, you can run:

Deploying the Contract

In order to deploy the Box.sol smart contract, you will need to write a simple deployment script. You can create a new file under the scripts directory and name it deploy.py:

Next, you need to write your deployment script. To get started start, take the following steps:

1. Import the Box contract and the accounts module from brownie

2. Load your account using accounts.load() which decrypts a keystore file and returns the account information for the given account name

3. Use the deploy method that exists within this instance to instantiate the smart contract specifying the

You can now deploy the Box.sol contract using the run command and specifying the network:

After a few seconds, the contract is deployed, and you should see the address in the terminal.

Congratulations, your contract is live! Save the address, as you will use it to interact with this contract instance in the next step.

Interacting with the Contract

You can interact with contracts using the Brownie console for quick debugging and testing or you can also write a script to interact.

Using Brownie Console

To interact with your newly deployed contract, you can launch the Brownie console by running:

The contract instance will automatically be accessible from the console. It will be wrapped in a ContractContainer which also enables you to deploy new contract instances. To access the deployed contract you can use Box[0]. To call the store method and set the value to 5, you can take the following steps:

1. Create a variable for the contract

2. Call the store method using your account and set the value to 5

3. Enter the password for your account

The transaction will be signed by your account and broadcasted to the network. Now, you can retrieve the value by taking these steps:

1. Call the retrieve method

2. Enter your password

You should see 5 or the value you have stored initially.

Using a Script

You can also write a script to interact with your newly deployed contract. To get started, you can create a new file in the scripts directory:

Next, you need to write your script that will store and then retrieve a value. To get started, take the following steps:

1. Import the Box contract and the accounts module from brownie

2. Load your account using accounts.load() which decrypts a keystore file and returns the account information for the given account name

3. Create a variable for the Box contract

To run the script, you can use the following command:

You'll need to enter the password for Alice to send the transaction to update the stored value. Once the transaction goes through, you should see a transaction hash and a value of 5 printed to the console.

Congratulations, you have successfully deployed and interacted with a contract using Brownie!

This tutorial is for educational purposes only. As such, any contracts or code created in this tutorial should not be used in production.The information presented herein has been provided by third parties and is made available solely for general information purposes. Phron does not endorse any project listed and described on the Phron Doc Website (https://docs.Phron.ai/). Phron does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Phron disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Phron. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Phron has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Phron harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.

Using Ape to Deploy To Phron

Introduction

Ape is an Ethereum development environment that helps Python developers manage and automate the recurring tasks inherent to building smart contracts and DApps. Ape can directly interact with Phron's Ethereum API, so you can also use Ape to deploy smart contracts on Phron.

This guide will walk you through using Ape to compile, deploy, and interact with Ethereum smart contracts on the Phron TestNet.

Checking Prerequisites

To get started, ensure you have the following:

• MetaMask installed and connected to Phron

• An account with funds. You can get DEV tokens for testing on Phron once every 24 hours from the

• To test out the examples in this guide on Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers

Creating an Ape Project

If you don't already have an Ape project, you must install Ape and create a new one. You can follow the steps below to get started and create an empty project:

1. Create a directory for your project

2. If you don't have pipx installed, install it

4. Create a project

Your Ape project contains a bare-bones ape-config.yaml file for customizing specific settings and the following empty directories:

• contracts - an empty directory for storing smart contracts

• scripts - an empty directory for storing Python scripts, such as deployment scripts and scripts to interact with your deployed contracts

• tests - an empty directory for pytest testing scripts

Configure Accounts

You'll need to import an account before you can deploy smart contracts or interact with previously deployed contracts from your Ape project. You can run the following command, which will import your account and give it a name:

You'll then be prompted to enter your private key and add a password to encrypt your account.

Note

If you wish to use a mnemonic instead, you can append the --use-mnemonic option to the import command.

Create Smart Contracts

Now that you have set up your account, you can start writing smart contracts. As a basic example, you can use the following Box contract to store a value you can retrieve later.

Start by creating a file named Box.sol inside the contracts directory:

Open the file and add the following contract to it:

You can store any additional contracts in the contracts directory.

Compile the Solidity Contract

Before compiling the Solidity, you must install the Solidity compiler plugin. Running the following command will install the latest version of the plugin:

To use a specific version of Solidity or a specific EVM version, you can modify your ape-config.yaml file as follows:

For more information on the Solidity plugin, please refer to the .

With the Solidity plugin installed, the next step is to compile the smart contract:

After compilation, you can find the bytecode and ABI for your contracts in the .build directory.

Test the Contract

Before you deploy your contract, you can test it out directly inside your Ape project using the to make sure it works as you expect.

You should already have a tests directory where you'll create your tests, but if not, please create one, as all tests must be located in a directory named tests. Additionally, each test file name must start with test_ and end with .py. So, first, you can create a test file for the Box.sol contract:

In addition to the test file, you can create a conftest.py file that will define a couple of essential . Fixtures allow you to define functions that set up the necessary environment or resources to run your tests. Note that while the Box.sol contract is simple, incorporating fixtures into your testing process is good practice.

To create the file, you can run the following command:

Since your tests will rely on the injection of the fixtures, you must define the fixtures first. When defining fixtures, you need to apply the pytest.fixture decorator above each function. For this example, you'll create two fixtures: one that defines the owner of the contract and one that deploys the contract from the owner's account.

The owner fixture will use the built-in accounts fixture to take the first account in the list of test accounts provided by Ape and return it. The box fixture will deploy the Box contract type using the built-in project fixture, you simply have to provide the name of the contract and use the owner fixture to deploy it.

tests/conftest.py

Now that you've created the fixtures, you can start creating your tests. Each test function name must start with test_ and describe what the test does. For this example, you can use test_store_value, as you'll create a test for the store function. The test will store a value and then retrieve it, asserting that the retrieved value is equal to the value passed into the store function.

To use the owner and box fixtures, you must pass them into your test function, which will inject the fixtures automatically for you to use. The owner account will be used to call the store function of the box contract instance.

tests/test_box.py

And that's it! That's all you'll need inside your test file. You can use the following command to run the test:

The results of running the test will be printed to the terminal.

Now that you have confidence in your contract, the next step is to deploy it.

Deploy the Contract

To deploy your contracts, create a deployment script named deploy.py inside of the scripts directory:

Next, you'll need to write the deployment script. You'll need to load the account you will use to deploy the contract and access it by its name using the project manager.

scripts/deploy.py

Now you're ready to deploy the Box contract! To configure your project for Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers.

Take the following steps to initiate and send the deployment transaction:

1. Run the deployment script using the ape run deploy command

1. Review the transaction details and enter y to sign the transaction

2. Enter your passphrase for your account

3. Enter y to leave your account unlocked or n to lock it

After you follow the prompts and submit the transaction, the transaction hash, total fees paid, and contract address will be displayed in the terminal.

Congratulations! Your contract is live! Save the address to interact with your contract in the following section.

Interact with the Contract

You can interact with contracts using the Ape console for quick debugging and testing, or write a script.

Using The Ape Console

To interact with your newly deployed contract, you can launch the Ape console by running:

Next, you'll need to create a contract instance using the contract's address:

Now, you can interact with your contract instance! For example, you can set the variable to be stored in the Box contract using the following commands:

1. Call the store method by passing in a value to store and the account you want to use to send the transaction:

2. Review the transaction details and enter y to sign the transaction

3. If you previously locked your account, you must enter your passphrase to unlock it. Otherwise, Ape will use the cached key for your account

4. If you unlocked your account in the previous step, you'll be asked if you want to leave your account unlocked. You can enter

After you follow the prompts and submit the transaction, the transaction hash and total fees paid will be displayed in the terminal.

Then, you can retrieve the stored value by calling the retrieve method:

The number you just stored in the previous steps will be printed to the console.

contract.retrieve() 4

Using a Script

You can also write a script to interact with your newly deployed contract. To get started, you can create a new file in the scripts directory:

Next, you can write a script that stores and retrieves a value. Note that when creating a contract instance to interact with, you must pass in the address of the deployed contract.

scripts/store-and-retrieve.py

Now, you can run the script to set the stored value and retrieve it:

1. Run the script

2. Review the transaction details and enter y to sign the transaction

3. If you previously locked your account, you must enter your passphrase to unlock it. Otherwise, Ape will use the cached key for your account

4. If you unlocked your account in the previous step, you'll be asked if you want to leave your account unlocked. You can enter y to leave it unlocked or n to lock it

Once completed, you should see a transaction hash and a value of 4 printed to the console.

Congratulations! You have successfully deployed and interacted with a contract using Ape!

This tutorial is for educational purposes only. As such, any contracts or code created in this tutorial should not be used in production.The information presented herein has been provided by third parties and is made available solely for general information purposes. Phron does not endorse any project listed and described on the Phron Doc Website (https://docs.Phron.ai/). Phron does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Phron disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Phron. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Phron has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Phron harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.

Using Waffle & Mars to Deploy to Phron

Introduction

Waffle is a library for compiling and testing smart contracts, and Mars is a deployment manager. Together, Waffle and Mars can be used to write, compile, test, and deploy Ethereum smart contracts. Since Phron is Ethereum compatible, Waffle and Mars can be used to deploy smart contracts to a Phron development node or the Phron TestNet.

Waffle uses minimal dependencies, has syntax that is easy to learn and extend, and provides fast execution times when compiling and testing smart contracts. Furthermore, it is compatible and uses to make tests easy to read and write.

Mars provides a simple, TypeScript compatible framework for creating advanced deployment scripts and staying in sync with state changes. Mars focuses on infrastructure-as-code, allowing developers to specify how their smart contracts should be deployed and then using those specifications to automatically handle state changes and deployments.

In this guide, you'll be creating a TypeScript project to write, compile, and test a smart contract using Waffle, then deploy it on to the Phron TestNet using Mars.

Checking Prerequisites

You will need to have the following:

• MetaMask installed and connected to Phron

• An account with funds. You can get DEV tokens for testing on Phron once every 24 hours from the

• To test out the examples in this guide on Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers

Once you've created an account you'll need to export the private key to be used in this guide.

Create a TypeScript Project with Waffle & Mars

To get started, you'll create a TypeScript project and install and configure a few dependencies.

1. Create the project directory and change to it:

2. Initialize the project. Which will create a package.json in the directory:

3. Install the following dependencies:

   • - for writing, compiling, and testing smart contracts

Now, you should have a basic TypeScript project with the necessary dependencies to get started building with Waffle and Mars.

Add a Contract

For this guide, you will create an ERC-20 contract that mints a specified amount of tokens to the contract creator. It's based on the OpenZeppelin ERC-20 template.

1. Create a directory to store your contracts and a file for the smart contract:

2. Add the following contract to MyToken.sol:

In this contract, you are creating an ERC-20 token called MyToken with the symbol MYTOK, that allows you, as the contract creator, to mint as many MYTOKs as desired.

Use Waffle to Compile and Test

Compile with Waffle

Now that you have written a smart contract, the next step is to use Waffle to compile it. Before diving into compiling your contract, you will need to configure Waffle:

1. Go back to the root project directory and create a waffle.json file to configure Waffle:

2. Edit the waffle.json to specify compiler configurations, the directory containing your contracts, and more. For this example, we'll use solcjs and the Solidity version you used for the contract, which is 0.8.0:

3. Add a script to run Waffle in the package.json

That is all you need to do to configure Waffle, now you're all set to compile the MyToken contract using the build script:

After compiling your contracts, Waffle stores the JSON output in the build directory. Since the contract in this guide is based on OpenZeppelin's ERC-20 template, relevant ERC-20 JSON files will appear in the build directory too.

Test with Waffle

Before deploying your contract and sending it off into the wild, you should test it first. Waffle provides an advanced testing framework and has plenty of tools to help you with testing.

You'll be running tests against the Phron TestNet and will need the corresponding RPC URL to connect to it: https://testnet.phron.ai.

To configure your project for Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers.

Since you will be running tests against the TestNet, it might take a couple minutes to run all of the tests. If you want a more efficient testing experience, you can spin up a Phron development node using . Running a local Phron development node with the instant seal feature is similar to the quick and iterative experience you would get with .

1. Create a directory to contain your tests and a file to test your MyToken contract:

2. Open the MyToken.test.ts file and setup your test file to use Waffle's Solidity plugin and use Ethers custom JSON-RPC provider to connect to Phron:

3. Before each test is run, you'll want to create wallets and connect them to the provider, use the wallets to deploy an instance of the MyToken contract, and then call the initialize function once with an initial supply of 10 tokens:

Congratulations, you should now have two passing tests! Altogether, your test file should look like this:

If you want to write more tests on your own, you could consider testing transfers from accounts without any funds or transfers from accounts without enough funds.

Use Mars to Deploy to Phron

After you compile your contracts and before deployment, you will have to generate contract artifacts for Mars. Mars uses the contract artifacts for typechecks in deployments. Then you'll need to create a deployment script and deploy the MyToken smart contract.

Remember, you will be deploying to Phron and will need to use the TestNet RPC URL:

To configure your project for Phron, you will need to have your own endpoint and API key, which you can get from one of the supported Endpoint Providers.

The deployment will be broken up into three sections: generate artifacts, create a deployment script, and deploy with Mars.

Generate Artifacts

Artifacts need to be generated for Mars so that typechecks are enabled within deployment scripts.

1. Update existing script to run Waffle in the package.json to include Mars:

2. Generate the artifacts and create the artifacts.ts file needed for deployments:

If you open the build directory, you should now see an artifacts.ts file containing the artifact data needed for deployments. To continue on with the deployment process, you'll need to write a deployment script. The deployment script will be used to tell Mars which contract to deploy, to what network, and which account is to be used to trigger the deployment.

Create a Deployment Script

Now you need to configure the deployment for the MyToken contract to the Phron TestNet.

In this step, you'll create the deployment script which will define how the contract should be deployed. Mars offers a deploy function that you can pass options to such as the private key of the account to deploy the contract, the network to deploy to, and more. Inside of the deploy function is where the contracts to be deployed are defined. Mars has a contract function that accepts the name, artifact, and constructorArgs. This function will be used to deploy the MyToken contract with an initial supply of 10 MYTOKs.

1. Create a src directory to contain your deployment scripts and create the script to deploy the MyToken contract:

2. In deploy.ts, use Mars' deploy function to create a script to deploy to Phron using your account's private key:

3. Set up the deploy

So far, you should have created a deployment script in deploy.ts that will deploy the MyToken contract to Phron, and added the ability to easily call the script and deploy the contract.

Deploy with Mars

You've configured the deployment, now it's time to actually deploy to Phron.

1. Deploy the contract using the script you just created:

2. In your Terminal, Mars will prompt you to press ENTER to send your transaction

If successful, you should see details about your transaction including it's hash, the block it was included in, and it's address.

Congratulations! You've deployed a contract to Phron using Waffle and Mars!

Example Project

If you want to see a completed example of a Waffle and Mars project on Phron, check out the phron-waffle-mars-example created by the team behind Waffle and Mars, EthWorks.

This tutorial is for educational purposes only. As such, any contracts or code created in this tutorial should not be used in production.The information presented herein has been provided by third parties and is made available solely for general information purposes. Phron does not endorse any project listed and described on the Phron Doc Website (https://docs.Phron.ai/). Phron does not warrant the accuracy, completeness or usefulness of this information. Any reliance you place on such information is strictly at your own risk. Phron disclaims all liability and responsibility arising from any reliance placed on this information by you or by anyone who may be informed of any of its contents. All statements and/or opinions expressed in these materials are solely the responsibility of the person or entity providing those materials and do not necessarily represent the opinion of Phron. The information should not be construed as professional or financial advice of any kind. Advice from a suitably qualified professional should always be sought in relation to any particular matter or circumstance. The information herein may link to or integrate with other websites operated or content provided by third parties, and such other websites may link to this website. Phron has no control over any such other websites or their content and will have no liability arising out of or related to such websites or their content. The existence of any such link does not constitute an endorsement of such websites, the content of the websites, or the operators of the websites. These links are being provided to you only as a convenience and you release and hold Phron harmless from any and all liability arising from your use of this information or the information provided by any third-party website or service.

Using Foundry to Deploy To Phron

Introduction

is an Ethereum development environment written in Rust that helps developers manage dependencies, compile projects, run tests, deploy contracts, and interact with blockchains from the command line. Foundry can directly interact with Phron's Ethereum API so it can be used to deploy smart contracts into Phron.