smart contract development

Smart Contract Development

We understand the architectures that safely perform and produce the results you need…

DeFi Protocol development

DeFi Protocols

We build DeFi protocols that enable the exchange of products and services…

cross-chain bridge development

Cross-Chain Bridges

Extend your app and enable token transfers, smart contracts, data exchange, and more…

NFT platform development

NFT Platforms

We build platforms that enable the creation, buying, and selling of non-fungible tokens (NFTs)…


Discussion – 


Discussion – 


How to Leverage the Multi-chain World and Lower Development Risk

This year has taken a toll on the crypto-verse for sure!  With the implosions that have occurred (starting with Terra and USD, which started the unraveling – and now the high profile implosion of FTX and Alameda Research) – the extreme fear in the retail market and the implosions have dropped overall market cap below a trillion dollars, into the 800 billion territory.

It’s not all gloom and doom, however.  Development continues, for solid projects (like Ethereum, Chainlink, Cardano, and Cosmos to name a few), and also for institutions – and that bodes very well for the future of blockchain – as we come out of the deep winter that has descended upon the ecosystem.

From a development perspective, we’ve seen a drop in weekly active crypto devs of approximately 30% on average – but core developers remain.  Some speculate that the “tourist builders” are leaving along with the “tourist investors” – and that is leaving room to get the real work of crypto done.  

Some of the developments that have occurred this year help projects make solid dev decisions, and that will help the blockchain ecosystem mature – something that is much needed, if the events of this year to-date are any indication – both from a coding and policy perspective – time to grow up!

What is the best way to leverage multi-chain and take advantage of it?  Seems like it’s probably building for ETH and EVM, using Solidity.  

Just about every blockchain is building bridges and interoperability with Ethereum – so that smart contracts written in Solidity will also run on other chains.  Since Ethereum boasts the largest group of developers and Solidity is one of the most well-known development environments, leveraging Dapps that have been written for Ethereum on other blockchains, gives those projects more flexibility.

EVM also has the biggest momentum. Rather than trying to figure out which blockchain is the best for your app – keep your options open by building ETH/EVM first – then you can run it on different chains and see where you get momentum.

Let’s take one example, Cardano sidechains, that will allow Ethereum Dapps to run in Cardano fairly seamlessly.  This is a smart move by Cardano, who is looking to grow and take advantage of first, the advantage that EVMs enjoy as the predominant blockchain for development, and also any uncertainty that may unfold as Ethereum continues to redevelop as a Proof-of-Stake system, by making it easy for EVM developers and projects to utilize Cardano going forward.

The tooling within the EVM/Solidity dev environment (like testing suites, deployment packages, existing contract libraries, etc.) and dev familiarity of the EVM still make it a go-to for many people learning to program with blockchain. This means that any new chains that want developers and dApps will need to plug in an EVM. Cardano has several ways to do this. There is already an EVM sidechain (Milkomeda), and IOG (Input Output Global) itself is working on its own EVM sidechain, codenamed Mamba.

What we see in all of this is:  Flexibility.  If you want to leverage the multichain world – build for EVM, and then leverage the EVM-compatible sidechains for the blockchain ecosystem you want to run with.

If that’s the case, then what are the tools within the EVM dev-space that can make your development effort easier and the result better?

A Few Top Tools for EVM/Solidity Dapp Development


It’s like Hardhat, except it allows you to build your test harnesses in Solidity, rather than having to build them in Javascript/Typescript.

In a nutshell, Foundry is a suite of tools for building and testing decentralized applications (dApps) using the Solidity programming language. To set it up, you would need to take the following steps:

  1. First, you would need to install the Foundry command-line interface (CLI) on your computer. This would involve downloading the Foundry CLI package and running the appropriate installation command for your operating system.
  2. After installing the Foundry CLI, you would need to create a new project using the foundry init command. This would create a new directory on your computer containing the basic files and configuration for your dApp.
  3. Next, you would need to install the required dependencies for your project. This would typically involve running npm install or yarn install to download and install the required packages from the npm registry.
  4. Once all the dependencies are installed, you can start building your dApp using the Foundry CLI and Solidity. This would involve writing your contract code in Solidity and using the foundry compile command to compile it into bytecode that can be deployed to the Ethereum blockchain.
  5. You can then use the Foundry CLI to test your Solidity code using a local Ethereum blockchain emulator such as Ganache. This would involve running commands such as foundry test to run your contract’s unit tests and foundry console to interact with your contracts on a local blockchain.

Overall, setting up Foundry for Solidity development involves installing the Foundry CLI, creating a new project, installing dependencies, writing and compiling Solidity code, and testing it using a local Ethereum blockchain emulator.

What are the benefits of using Foundry over Hardhat?

Hardhat is a development environment for building and testing Ethereum dApps, similar to Foundry. Both tools provide similar functionality, such as compiling and deploying Solidity code, running unit tests, and interacting with contracts on a local blockchain.

One potential benefit of using Foundry instead of Hardhat is that Foundry is built on top of the popular Truffle framework, which provides a well-established and widely-used set of tools and libraries for Ethereum development. This can make it easier to integrate Foundry with other tools and services in the Ethereum ecosystem.

Another potential benefit of Foundry is its focus on user experience and developer productivity. Foundry includes features such as a built-in console and graphical user interface (GUI) that can make it easier and more intuitive to work with compared to Hardhat.

Overall, the choice between using Foundry or Hardhat would depend on your specific needs and preferences as a developer. Both tools provide similar functionality for building and testing Ethereum dApps, but Foundry may be a better fit for certain use cases due to its focus on user experience and integration with the Truffle ecosystem.

More Advanced Ethereum Transaction Viewer

Built by Sam CZ Sun, a well-known white hat hacker, here’s a block explorer with more detail and for use by more advanced users.

You can check it out here: – and you can use this transaction hash to see what it reveals:  0x3443cd8f0c722fa9d83e12033f29eb590b177804ae625f2072625dfb79b329c2


AI is picking up steam!!  But it’s not a panacea for sure.  You must be discriminating, and be able to know how to evolve the starting point and make it your own.  There are pros/con arguments about using Copilot, but it is in the landscape to stay, and could be a great resource to pull in certain methods to boost/aid your development effort.

When is it a good idea to use Copilot for code generation?

Copilot is a tool for generating code based on a user-defined configuration. It is often used in cases where there is a need to quickly generate a large amount of boilerplate code, or to standardize the structure and organization of code across a project.

One common use case for Copilot is when working with a microservice architecture, where multiple services need to be created and integrated with each other. In this case, Copilot can be used to generate the basic structure and code for each service, saving time and effort for the developer.

Another potential use case for Copilot is when working with a large codebase that follows a specific pattern or structure. In this case, Copilot can be used to generate the necessary code for new features or modules, ensuring that they are consistent with the existing codebase.

Overall, it is a good idea to use Copilot for code generation when you need to quickly generate a large amount of boilerplate code, or when you want to ensure consistency and standardization across a codebase. Copilot can save time and effort for developers by automatically generating code based on a user-defined configuration.

How to get started with Copilot

To get started with Copilot, you would need to take the following steps:

  1. First, you would need to install Copilot on your computer. This would involve downloading the Copilot package and running the appropriate installation command for your operating system, such as npm install -g @ianwalter/copilot for npm.
  2. After installing Copilot, you can create a new project and generate code for it using the copilot new command. This will prompt you to enter a project name and select a code generation template, and then create a new directory for your project and generate the necessary code files.
  3. Once the code is generated, you can open the project directory in your code editor and start working on your project. This would typically involve modifying the generated code to add your own logic and functionality.
  4. As you work on your project, you can use Copilot to generate additional code files as needed. This would involve running the copilot generate command and specifying the type of code you want to generate, such as a component or service.
  5. When you are ready to test and deploy your project, you can use the copilot test and copilot build commands to run unit tests and create a production-ready build of your code, respectively.

Overall, getting started with Copilot involves installing the tool, creating a new project, modifying the generated code, and using Copilot to generate additional code files as needed. Copilot can save time and effort by automatically generating boilerplate code based on a user-defined configuration.

Upping your Dapp Dev Game

Hopefully this post will assist in keeping track of what is emerging that will aid in the evolution and maturity of Blockchain Dapp Development.  At AktaryTech, we take Blockchain development seriously — and welcome the evolution in the space as blockchain Dapps mature and gain solid footing.  We’re in a similar situation that the Internet went through in 2000, when the dot com bubble burst – but development on solid applications and by institutions continues — Blockchain is here to stay.

Reach out if you’ve got a project and would like to partner with a solid blockchain development team!

Kim Albee

As a complete blockchain enthusiast and the Director of Marketing, Kim brings her insights and questions to the forefront to help new blockchain startups gain clarity when developing their projects. When not totally absorbed in all things marketing and blockchain, you can find her at a tiny cabin next to a Wisconsin lake with people and critters that make her happy.


Submit a Comment

Your email address will not be published. Required fields are marked *

You May Also Like

Database for Web3 Dapps

Database for Web3 Dapps

Data storage on the blockchain has been pretty rudimentary.  However, that appears to be changing, and as it does,...