Certifié SOC 2 Type II · ISO 27001

An interactive command line alternative for your favorite Smart Contract development tool (like Truffle!)

In last week’s article, we talked about how to interact with an already-deployed Smart Contract using sbt-ethereum. This week we are going to create a Smart Contract using sbt-ethereum!

sbt-ethereum not only allows you to create Smart Contracts, but also helps you manage your web3 projects (like one would with Truffe), though sbt’s rich command line tool. (it just makes your life easier as a web3 developer!)

If you just stumbled upon this article, we strongly recommend you check the previous part of this series.

Part 1- sbt-ethereum — A Tool for Interacting with the Ethereum Blockchain via Command Line

Part 2- Interact with Smart Contracts using the Command Line

Before diving in, we need to install a few things (if you don’t have them already):

• Install Java (version ≥ 8 )

• Install Git

• Install Maven (Maven is dependency management for Java ecosystem; what is npm in nodejs, maven is for Java ecosystem)

Once installed we are ready to dive in 👉

In previous tutorials, we’ve run sbt by executing the ./sbtw wrapper script within the eth-command-line repository. This time, we need to create our own repository.

To get sbt-ethereum project’s template, we will use giter8. Giter8 is a command line tool to generate files and directories from templates published on Github or any other git repository. Giter8 helps us by scaffolding projects based on a pre-defined template.

Use this command to create a project repository:

As sbt-ethereum is an interactive build tool, this command will ask a few questions:

This will create a new eth-timelock directory (see above, we have given eth-timelock as a project name). This is how the directory structure looks like:

Now we are ready to create our first contract. Remember, create all contracts under src/main/solidity .

We are going to create Timelock contract. It accepts payment of ETH when the contract is created, and only allows that ETH to be withdrawn by the creator of the contract after a specified delay.

Create a Timelock.sol file under src/main/solidity

Timelock.sol

Now let's compile our project.

First, run sbt inside your eth-timelock directory:

Next run compile :

If you see any warning, just ignore it. You can see ABI get created under /target/ethereum/solidity .

Now we are ready to deploy our Smart Contract. But before that, if you want to switch the network, you can like this:

First, check your network with ethNodeChainIdPrint . sbt-etherum has MainNet set by default. Let’s change it to Ropsten (if you want some other testnet, feel free to do so too).

Here, 3 is the Ropsten network id. Remember, you should have a bit of ETH in your account to deploy the contract.

Now let’s start deploying:

Always use Tab, sbt-ethereum has very rich Tab support for command completion. When you press Tab, it will tell you what to do next.

Our Smart Contract will need two parameters:

days — The number of days when the owner will be able to withdraw Ether.

seconds — Number of seconds when the owner will be able to withdraw Ether.

We’ll need the Smart Contract’s compute time using days + seconds, so let’s pass 0 days and 300 seconds (5 minutes):

Now we need to pass the Ether amount, which will lock the contract for the given time. You can pass ETH amount using wei, gwei, szabo, finney, or ether units.

Let’s lock 10 wei for 5 minutes (300 seconds):

This will ask you to unlock your wallet using your passphrase and then ask you to submit the transaction. It will also ask to provide an alias name for your deployed contract.

Once done, it will give you deployed contract address which you can see on Etherscan. Let check the balance of the contract using:

Here timelock is alias name which we used while deploying our contract.

Interacting with your Smart Contract

Now, before 5 minutes runs out, let’s mock-test our Smart Contract using ethTransactionMock. This simulates a transaction on our Ethereum Node, but does not actually execute the transaction. So let’s try that:

If you execute this within 5 minutes of deploying the Smart Contract, you will see an error. Execute the above command after 5 minutes and you will see a success message, but it does not run the command actually.

Now let’s actually withdraw our 10 wei from the contract after 5 minutes using:

This will create a transaction and withdraw the locked 10 wei. Once this command succeeds, you can check the balance of the contract again:

Conclusion

That’s it for today! Now you have another way to #buidl and deploy Smart Contracts. Let us know if you liked the article in the comment section and if you want to see more on this (or similar) topic 🙏

Vous avez besoin d'aide pour votre projet ou vous avez des questions ? Contactez-nous via ce formulaire, sur TwitterQuicknode, ou envoyez-nous un message sur Discord!