DEV Community: Bunzz

Bunzz Releases New Features for Smart Contract Analysis

Bunzz — Wed, 13 Dec 2023 09:59:58 +0000

We're thrilled to announce the release of two exciting new features on Decipher. These features address two key pain points: searching for smart contracts and understanding smart contract vulnerabilities quickly and efficiently.

Let's highlight these new updates briefly.

Tag Search for Decipher

With our new tag search functionality on Decipher, you can now search for tagged smart contracts with specific keywords.

This means you can find and filter smart contracts with similar functions without sifting through irrelevant contracts.

AI Summaries for Mythril & Slither Contracts

Security is very important in the blockchain world, and understanding potential vulnerabilities in your smart contracts is crucial. However, manually analyzing complex reports can be time-consuming and challenging.

To address this, we’ve integrated powerful AI capabilities into our platform.

Now, you can get clear, concise summaries of your Mythril & Slither reports, allowing you to identify and prioritize vulnerabilities for remediation quickly.

Benefits for DApp Developers

These new features offer a range of benefits for DApp developers, including:

Increased Efficiency:
Find relevant announcements faster with tag search and gain rapid insights into smart contract vulnerabilities with AI summaries.
Improved Decision-Making:
Make informed decisions about which announcements are most relevant to your project and how to address potential security risks identified by AI summaries.
Enhanced Security:
Gain a deeper understanding of your smart contract vulnerabilities and prioritize remediation efforts effectively.
Streamlined Development Workflow:
Save valuable time and effort by using efficient tools that cater to specific needs.

Start exploring today!

We’re confident that these new features will significantly enhance your DApp development, documentation, and smart contract analysis experience.

Here is a quick guide to building DApps and deploying smart contracts with Bunzz with low code

Take a look at our blog for more articles and guides on Web3 and smart contracts. If you have any feedback, feel free to reach out to us via Twitter.

You can always chat with us on our Discord community server, featuring some of the coolest web3 developers you’ll ever meet.

How to Generate Specs Documentation from Smart Contracts using AI tool

Bunzz — Tue, 25 Jul 2023 12:50:54 +0000

If you are looking for a way to generate Specs Documentation from Smart Contracts to understand their functionality before cloning or reusing any functionality for your next project then there is a good news.

That feature already exists from today and it's called "DECIPHER"

DeCipher is a GPT-based web3×AI tool capable of generating precise documentation from any Smart Contract URL on EVM Block Explorers like Etherscan.
From initial feedback by developers the level of accuracy is higher than 90%!

https://www.bunzz.dev/decipher

How to Use DeCipher:

Copy the contract URL from a Block Explorer (e.g., Etherscan, BSC Scan, etc.)
Paste the URL into the DeCipher product page (at the above link)
Understand the specifications
Import/Edit and Deploy on any EVM network using Bunzz CLI

Apart from using Decipher at https://www.bunzz.dev/decipher you can also use it directly through a Chrome Extension in your browser, to have it always handy!

With it you can generate docs with one click while keeping the Explorer page open. You can download it here:

https://chrome.google.com/webstore/detail/bunzz-decipher/ekkgjdbkmlcaepohenggjpfadklklpaj?hl=en&auth

See below how easy and fast it is

How to use DeCipher Chrome Extension:

Install the DeCipher Chrome Extension from the link above.
Open the page of the contract you want to document.
Press the “Click Here” button displayed at the bottom right of the screen.

Decipher was developed by Bunzz that also developed other Dapp development tools for blockchain developers. You may check out their Twitter for their latest updates.

Bunzz Integrates ChatGPT-based Smart Contract’s Document Generation AI to launch ‘DeCipher’

Bunzz — Wed, 21 Jun 2023 14:11:53 +0000

Pre-Registration Now Open! Try it first

Pre-register here (free) → https://blog.bunzz.dev/decipher-pre-launch-page/

Decipher will be launched shortly in July 2023. To remain informed about the launch and to be among the first users to try this new tool click on the link above to register.

We will be sending an invitation to the closed beta version by lottery from the registered accounts.

What is DeCipher?

DeCipher is a service that can generate highly accurate specifications documents for blockchain developers using smart contracts and ABI on the blockchain as input sources, fine-tuned GPT prompts for contract analysis through a proprietary processing system.

Attempting to generate documentation with regular GPT will not provide reliable analysis results, as most required information will be missing or incorrect answers will be returned.

On the other hand, DeCipher, which specializes in contract’s analysis, has achieved the accuracy required by web3 developers. Although we do not guarantee 100% accuracy, we have received evaluations from early testers such that Decipher offers high “accuracy and usefulness” and “preciseness that cannot be expected from GPT alone”.

Sample of a document generated by DeCipher

Decipher can generate detailed documentation out of any block explorer’s URL. Let’s see an example with The Doodles contract.

Input source example (URL of Block Explorer):

https://etherscan.io/token/0x8a90cab2b38dba80c64b7734e58ee1db38b8992e#code

Example of document generated by DeCipher:

https://lastrust.notion.site/Doodles-Smart-Contract-Documentation-312eed4a9bdc4c6692df2f51aed5a78e

We also provide a Chrome Extension for Decipher that can place a generate button on any EVM Block Explorer

Extra features: get supplementary information by chat, code editing and deployment by CLI

DeCipher not only generates documents, but also has the following features.

Ask questions in chat format about the generated results
Edit and deploy the source code of the analyzed smart contract
With these suit of features, we have realized a ‘development tool specialized in fork development of existing contracts’ that can obtain documents from all contracts on-chain, is able to understand the content, and able to edit the code for the DApp you want to develop and deploy to all EVM-compatible chains.

What DApp development problems does DeCipher solve?

Many DApps are developed with reference to existing smart contracts deployed on the blockchain, but since there are no clear specifications documents on the contracts on-chain, it was necessary to read and understand the source code for a long time. We developed DeCipher as a solution to this downside for web3 developers.

DeCipher’s launch comprises one of the features of ‘Bunzz v2’
Bunzz is a development platform for DApps (decentralized applications using blockchain). By providing frequently used contracts that have been modularized, the development difficulty dramatically decreases.

During the last year, over 12,000 web3 developers have used it, and the number of DApp projects deployed on the blockchain has exceeded 4,500 with over 200 smart contracts modules being available to use as templates.

Little by little getting closer to our goal of becoming the ‘web3 version of github”.

You can explore about Bunzz here: https://bunzz.dev/

This time, Bunzz plans to launch its first major update, ‘v2’, in late July. And DeCipher is a key feature of v2.

We have opened pre-registration for DeCipher, remember to pre-register here (free) →

https://blog.bunzz.dev/decipher-pre-launch-page/

How to Use the Bunzz’s User-Triggered Deployment SDK for DApp Development

Bunzz — Wed, 19 Apr 2023 10:03:31 +0000

Decentralized applications (DApps) have the potential to transform the way we interact with technology and conduct transactions. However, building and deploying smart contracts on a blockchain can be time-consuming and challenging for developers.

The Bunzz User Triggered Deployment SDK aims to simplify this process by providing developers with new functionality to implement contract deployment and cloning features more easily, improving the user experience for decentralized applications (DApps).

This article will discuss the contract cloning problem, the user Triggered Deployment SDK benefits, and how to use it.

The Problem with Contract Cloning

Sometimes, DApps require users to deploy or clone the same contract multiple times. For example, no-code web3 tools like DAO platforms, protocols like Uniswap, and NFT marketplaces allow users to create their own NFT projects. However, implementing this cloning functionality can be time-consuming and error-prone for developers.

The Benefits of the User-Triggered Deployment SDK

Bunzz’s User Triggered Deployment SDK solves this problem, allowing developers to quickly and easily integrate the cloning functionality into their DApps. Here are some of the benefits of using the SDK:

Simplifies the development process

Reduces the risk of errors
Speeds up time to market
Implementing the SDK

Installation

To use the SDK, you first need to install it from your CLI using the following command:

npm install @bunzz/deploy-sdk ethers@5.7.0

Note that @bunzz/deploy-sdk does not currently support ethers version 6.

Implementation Process

The complete implementation process includes the following steps:

Find an appropriate smart contract module from the explorer.
If you can’t find a suitable module, upload your own smart contract module from the repository page (requires signing up).
Copy the module template ID from the module template page.

Implement the deploy function using the SDK as shown below:

import { deploy } from '@bunzz/deploy-sdk';
import { providers } from 'ethers';

const TEMPLATE_ID = '<TEMPLATE_ID>';

const cloneContract = async () => {

  // get a Signer object in the ethers' style.
  const signer = getSigner();

  // Arguments for the constructor as an array.
  // The types must follow the ethers style.
  const arg = ['dummy', 123456];

  // The return value is the same as the ethers one.
  const tx = await deploy(TEMPLATE_ID, signer, args);

  // You can get receipt as well.
  const receipt = await tx.wait();
}

Using the example of an auto DAO creation platform, the difference in the process would be significant without the User Triggered Deployment SDK and with the SDK. With the SDK, developers can create a custom solution from scratch. With the SDK, they can easily integrate the cloning functionality with minimal coding.

Conclusion

Bunzz’s User Triggered Deployment SDK simplifies deploying and cloning smart contracts, reducing the risk of errors and speeding up time to market.

Following the installation and implementation process outlined above, developers can easily integrate the SDK into their DApps and improve the user experience.

Bunzz is a platform that helps to increase the number of blockchain developers who want to contribute to the Web3 scene. By providing tools like the User Triggered Deployment SDK, we aim to make it easier for developers to create DApps that meet users' needs.

If you have any questions or feedback, don't hesitate to contact us on Discord. Get started building your DApps with Bunzz now!

New features & Updates to the Module templates Upload process in Bunzz Repository

Bunzz — Fri, 27 Jan 2023 14:42:14 +0000

For all developers who already started contributing to our open source Smart Contract Hub by uploading their own custom modules templates in Bunzz Repository we now have some updates to complete the process in our GUI.

New Features:

Now you can deploy your Modules in any version of Solidity
Now you can enable an Optimization Flag

Update:

OpenZeppelin Version required is 4.3.2

Select the version of Solidity

Now you can deploy your Modules in any version of Solidity, like shown in the image below and you are not longer limited to use only version 0.8.0 like before

Enable an Optimization Flag

Now you can optionally enable an Optimization Flag that makes the compiler attempt to improve the performance and/or code size at the expense of compilation time and possibly the ability to debug the program.

You can select as shown in the image below.

New OpenZeppelin Version

The OpenZeppelin Version required to upload your smart contracts is 4.3.2

In case the latest OpenZeppelin version is required, you can use them by copying them to the uploaded directory.

For example, IERC20.sol can be used by moving it from

import '@openzeppelin/contracts/token/ERC20/IERC20.sol'

 import './interfaces/IERC20.sol'.

Start uploading your smart contract Modules in Bunzz Repository here:

https://app.bunzz.dev/repository/upload

Smart Contract Verification Feature Available in Bunzz

Bunzz — Wed, 28 Dec 2022 14:51:09 +0000

Bunzz keeps on over-delivering and now launched a Smart Contract Verification Feature, one of the most requested by its blockchain developers community.

Now you can verify the source code of all the smart contracts that you deploy in Bunzz in an easy way, getting all the data you need to copy and fill in all the input fields required to verify smart contracts whether in Etherscan or any network block explorer.

The source code verification provides transparency for users interacting with smart contracts. By uploading the source code on a block explorer it will match the compiled code with that on the blockchain.

Let’s have a look step by step at what you need to do to get your smart contracts verified using Bunzz.

CREATE YOUR DAPP

Create your DApp.

Give your DApp a name

Select the network in which you want to deploy your DApp

Select and add the smart contract module you want to deploy

Fill in the parameters required (in this example: name, symbol, cap) and finally click in DEPLOY

And your smart contract module is deployed in your chosen network!

HOW TO VERIFY

Once your module is deployed you will get access to the verification feature in your DApp dashboard. Click on “Verify the contract”

Then please copy and use the following data provided to fill in the verification form in the network block explorer of your choice.

For example, if your module has been deployed in the Goerli testnet network, copy the contract address and paste it on the Goerli testnet block explorer’s search engine.

Then go to the contract tab and click on “Verify and Publish”.

And start copying all the data required in your Bunzz dashboard and pasting it or selecting the corresponding data field until you can see the Verify and Publish” button at the end.

And that’s it, the smart contract module you deployed in Bunzz got verified!

If you still haven’t signed up to Bunzz, what are you waiting for?

Payment Splitter Smart Contract Module in Bunzz

Bunzz — Wed, 21 Dec 2022 07:36:48 +0000

We are excited to announce our new Payment Splitter Module available in Bunzz and created by Alex Wang.

This contract allows splitting Ether payments among a group of accounts. The sender does not need to be aware that the Ether will be split in this way, since it is handled transparently by the contract. The split can be in equal parts or in any other arbitrary proportion.

This Module connects with other contracts and is used for sharing accumulated tokens on the contract with shared accounts.

The number of shared accounts is limited up to 10 and can be used for sharing revenues with a limited number of accounts. (NFT Mint, Launch Token, etc)

You can access this Module and the code here.

How to use

Add a payee with a share point on the contract
Connect with other contracts which accumulate tokens (both ERC20 and native token) itself.
Release tokens to payees based on their shares.
Contract owner can update the shares of payees, and disable the payee to prevent further payments (Of course, they can enable the payee again if needed)

In most cases, the contract accumulates tokens itself and then releases them to payees. Example:

Token Launch contract is getting a fee from the transaction (sell, buy, transfer, etc)
DEFI contract is getting the fee from the user's deposit and stake.
NFT Mint contract has some minting price and the contract is getting tokens from the minting transaction.
NFT Marketplace contract is getting a fee from the trades (sell, buy, transfer, etc)

For the above cases, the contracts need to have functions to withdraw the accumulated tokens or release them to payees with shares.

By using the PaymentSplitter module, the above contracts don't need to have those functions, just connect them with the PaymentSplitter Module and add payees with shares and release it to the payees.

Functions

#WRITE

updatePayeeStatus
withdrawEth
withdrawERC20
updatePayeeShares
transferOwnership
removePayee
renounceOwnership
setMaxPayeeCounter
releaseEth
releaseERC20
addPayee

READ

totalShares
totalEthWithdrawn
totalERC20Withdrawn
totalEthReleased
shares
totalERC20Released
releasableERC20
payeeCount
releasableEth
listOfPayees
isPayee
isEnabled
ethReleased
owner
maxPayeeCounter
erc20Released

You can access this Module and the code here.

If you still haven’t signed up to Bunzz, what are you waiting for? Sign up here and get your smart contracts deployed in 5 minutes through our great GUI.

ReflectionTokens Smart Contract Module in Bunzz

Bunzz — Wed, 14 Dec 2022 08:51:24 +0000

We are excited to announce our new ReflectionToken Module available in Bunzz and created by Yano.

Reflection tokens are also known as reward tokens, because they pay token holders a portion of collected fees simply for holding them through a static reward system. Their functionality provides investors with a source of passive income.

A portion of the transaction fees assessed on cryptocurrency transactions can be passed on to investors holding the reflection tokens. The process is completed through a reflection mechanism that uses smart contracts to distribute the tokens to all investors in the liquidity pool.

While this may seem like a complicated process, it’s simpler than either mining, staking or yield farming. Thus, crypto reflection tokens make it easier for investors of all skill levels to generate passive income from their holdings.

You can access this Module and the code here.

Let’s see how reflection tokens work. Cryptocurrency markets are well-known for their volatility, which is often the result of traders trying to achieve gains through buying low and selling high. For example, when whales, or major cryptocurrency investors, buy and sell a large number of crypto coins at one time, values can rise or dip dramatically in a short period of time.

Reflection tokens provide investors with another way to earn income, encouraging investors to hold rather than trade their tokens. This promotes market stability and allows investors to profit, even if they don’t have the time available to constantly monitor the market.

The reflection mechanism gives token holders a percentage of the transaction tax imposed when a native token is traded. Distribution is equitable to all liquidity pool providers, based on their share of the pool. This smart contract ensures that the reflection process is fully transparent and executed instantly.

Reflection tokens also benefit each program responsible for its native coin. This benefit stems from raising and maintaining funds that can be used to further develop the program, which can use a portion of its transaction tax to fund growth and stability.

How to use

Similar to the ERC20 token.
The owner makes the necessary settings and then adds the liquidity to the DEX.
Users can transfer the tokens
The holders can get the rewards when users transfer the tokens

Functions

#WRITE

withdrawETH
withdrawToken
updateRouterAndPair
whitelistAddress
updateBurnAddress
transferFrom
transferOwnership
unBlacklistAddress
transfer
swapAndEvolve
setOwnerFeePercent
setTaxFeePercent
setSwapAndEvolveEnabled
setOwnerFeeAddress
setNumberOfTokenToCollectETH
setNumOfETHToSwapAndEvolve
setMigrationAddress
setLiquidityFeePercent
setMaxTxPercent
setEcoSystemFeePercent
setDefaultSettings
setEcoSystemFeeAddress
setBurnFeePercent
renounceOwnership
migrate
increaseAllowance
includeInFee
includeInReward
excludeWhitelistedAddress
excludeFromFee
excludeFromReward
decreaseAllowance
blacklistAddress
approve
addTier

READ

uniswapV2Router
uniswapV2Pair
symbol
tokenFromReflection
totalSupply
totalFees
swapAndEvolveEnabled
numTokensToCollectETH
numOfETHToSwapAndEvolve
owner
reflectionFromTokenInTiers
reflectionFromToken
migration
maxTxAmount
isWhitelisted
name
isMigrationStarted
maxFee
isExcludedFromReward
isExcludedFromFee
isBlacklisted
getContractBalance
inSwapAndLiquify
feeTiersLength
getETHBalance
defaultFees
feeTier
balanceOf
decimals
burnAddress
allowance
accountTier
WETH

You can access this Module and the code here.
If you still haven’t signed up to Bunzz, what are you waiting for?

EscrowByAgent Smart Contract Module in Bunzz

Bunzz — Fri, 09 Dec 2022 16:50:17 +0000

We are excited to announce our new EscrowByAgent Module available in Bunzz and created by Yano.

With the Escrow smart contract freelancers can receive payments that are being put on hold until their work is finished and the service beneficiary approves the payment to be released.

This escrow module is intended for a freelancer service operated by agents. The sender deposits money for the recipient and sets agent for the payment. If the sender wants to release the payment, then he can ask the agent to release the payment for the recipient.

Deployer will set the owner fee percent and agent fee percent. The fee percent and cancelLockTime are fixed values.

With the Escrow contract you can create and manage Escrow pool payments. This contract is reviewed, it works on all EVM-chains and it’s available as OSS too.

You can access this Module here.

How to use

Deploy this contract. (Anybody can deploy this contract for an escrow service and make money from this service)
Create an escrow pool with recipient, agent and amount
a) call depositByETH function to deposit ETH
b) call deposit function to deposit ERC20 token

_*You can't use the same address for recipient and agent. _

Once you (sender) allow the agent to release the payment (this option is outside of blockchain), the agent will release the payment.
- call the release function by agent

*ownerFee will be transferred to smart contract owner
*agentFee will be transferred to the agent

Approve to cancel the payment when you want to cancel it.
- call approveCancel function

*sender, recipient and agent will approve for canceling

Cancel the payment

*call cancel function to cancel the payment

This function works for these cases:
a) recipient and sender accepted.
b) sender accepted and recipient didn't
*needs agreement of agent

Functions

#WRITE

release
transferOwnership
renounceOwnership
depositByETH
deposit
cancel
approveCancel

#READ

refundStatusList
feePercent
pools
owner
poolCount
cancelLockTime
cancelable
agentFeePercent

You can access this Module and the code here.

If you still haven’t signed up to Bunzz, what are you waiting for?

Announcing Bunzz's new series of Smart Contract Modules.

Bunzz — Wed, 07 Dec 2022 13:43:18 +0000

Dear blockchain developer,

We are excited to announce our new series of Smart Contract Modules available in Bunzz. These contract modules cover different web3 use cases and make your Dapp development process easier and faster.

Today we’re gonna start with our new VestingWallet Module, created by CryptoFist.

With the VestingWallet contract you can create and manage only one vesting schedule. This contract is audited, it works on all EVM-chains and it’s available as OSS too.

You can access this Module here

Overview

By using the VestingWallet Module, developers can create their own vesting schedule.

It allows a different way to claim rewards by staking after a certain period of time.

This smart contract is helpful mainly for two purposes:

Keep token price and
Pay devs or investors.

Once implemented this smart contract allows you to put any token into a vesting schedule to distribute them later. The wallet owner sets and manages only one vesting schedule. In addition, this VestingWallet connects to the ERC20 contract.

How to use

Deploy smart contract via Bunzz
Set vesting token address by calling connectToOtherContracts function. (If you deploy this module and ERC20 at the same time, the connectToOtherContracts function is executed by Bunzz automatically)
By calling createVestingSchedule function, it creates the vesting schedule. Before that, you should deposit a vesting token.
If you think it’s not fair, you can revoke the vesting schedule anytime by calling the revokeVestingSchedule function.
Beneficiaries will get released vesting tokens when someone calls release function.

Module Parameters

There are no arguments

Functions

WRITE

Release
transferOwnership
renounceOwnership
revokeVestingSchedule
createVestingSchedule
emergencyWithdraw
connectToOtherContracts

READ

vestedAmount
vestingToken
releasableAmount
paused
start
released
revocable
duration
owner
beneficiary
_vestingToken

You can access this Module and the code here

If you still haven’t signed up to Bunzz, what are you waiting for? Sign up here and get your smart contracts deployed in 5 minutes through our GUI.

Introduction to Bunzz SDK: Key functionality for a speedy DApp development process

Bunzz — Thu, 27 Oct 2022 16:38:14 +0000

Bunzz SDK is a client-side library to interact with smart contracts deployed by Bunzz.

This is a brief and broad overview of Bunzz SDK functionality and dependencies included in it.

We are constantly improving and updating it for blockchain developers to figure out how their Dapp building process can be accelerated and become smoother by reducing lines of code and the hassles involved in many Ethers.js methods calls that get wrapped and simplified significantly when using Bunzz SDK.

Our API allows you to save development time when it comes to connecting your deployed smart contracts in Bunzz with your frontend application to finish your DApp.

When you create a new Bunzz project, you can get the API key and DApp ID in the Client SDK page.By passing those values to Bunzz SDK, you can connect it to the Bunzz project you created, you can perform the following and more:

Connect to different chains
Connect and get smart contracts addresses including ABI and transactions
Read on-chain status

All these and more can be done using the Bunzz SDK in a smoother and much easier way than coding the whole set of functions and methods calls using Ethers.js.

Bunzz SDK Functionality:

If you’re wondering what Bunzz SDK can do for you, then let’s start by refreshing our notion of what an SDK is. It stands for Software Development Kit, and is a collection of software development tools in one installable package. They facilitate the creation of applications by having a compiler, a debugger, and sometimes a software framework. They are typically specific to a hardware platform and operating system combination.

The Bunzz SDK is a Javascript library that provides accessible interfaces to interact with smart contracts deployed by Bunzz (Bunzz Modules). It synchronizes a front-end application and the smart contracts deployed in Bunzz, allowing the front-end app to interact with the smart contracts seamlessly.

It includes functions such as:

Smart contract compilation
Interacting with JSON-RPC interfaces
Connecting with wallet address (Metamask and WalletConnect)
Connecting and getting Smart Contracts’ Address and ABI
Constructing and sending Transactions and Reading on-chain Status
Contract subscription events
Encoding and decoding data with ABI

Dependencies

Bunzz SDK includes the following dependencies installed:

@metamask/detect-provider
@metamask/provider
@walletconnect/ethereum-provider
@Dotenv-cli
@Ethers
@events
@luxon
@types/jest
@types/luxon
@typescript-eslint/eslint-plugin
@typescript-eslint/parser
@esbuild
@eslint
@eslint-config-prettier
@eslint-plugin-prettier
@ganache-cli
@jest
@Jest-fetch-mock
@npm-run-all
@Prettier
@rimraf
@Source-map-loader
@Ts-jest
@ts-loader
@typescript
@webpack-cli

Installation and Version

At the moment the latest is version 1.2.3 .

You can always check out the latest version in our official nmp page here

For further details on how to install Bunzz SDK please refer to our official Bunzz Documentation here

——————-

Bunzz is helping to increase the number of blockchain developers who want to contribute to the Web3 scene. We would love to have your feedback.

Feel free to reach out to us on Discord!

Get to know more about Bunzz and start building your Dapps now!

https://bunzz.dev

How to launch a cryptocurrency (ERC-20 Tokens) with Bunzz - Part 1

Bunzz — Mon, 12 Sep 2022 12:27:55 +0000

To create a simple ERC-20 token, you’ll need some basic coding skills to deploy a smart contract to the Ethereum chain.

You’ll also need to have MetaMask installed and some FUNDS in your wallet to pay gas fees (you can get them from testnet faucets). We’d use the Goerli test network and Bunzz in this tutorial.

Not every step in the tutorial below will apply if you're only creating a token. We will cover the basics of creating a token in a blockchain and how to mint its supply before finally minting your coin.

Create your own cryptocurrency

We will will cover the basics of creating a token on the Ethereum blockchain first before finally minting your token.

How to create an ERC-20 token

First, visit Bunzz and log in or sign up if you're new to the platform.

Once you are logged in, you will have access to the Bunzz dashboard where all the magic happens. The next step is to connect your Metamask wallet and then create a DApp as seen in the image below.

Give your DApp a name, you can use any name that comes to mind, I have used "Crypto Token" as mine.

Next, you will be asked to select a network for the DApp, you can select Testnet or Mainnet depending on what you wish to do. I have chosen Goerli Testnet as seen in the image below.

Up next is to select a template from the many available already made smart contract templates. Since we are launching a cryptocurrency, we'd select the simple ERC20 token.

As seen in the image below, the next step is to customize your token by adding a name and a symbol. I have named by token Test Trust Currency and TTC as the symbol.

If you wish to see the code behind the ERC-20 smart contract, click on the document button. In the future, Bunzz will add an edit code feature for developers to add extra functions to the Solidity code.

Once you are done customizing, click on deploy and wait for it to sync by approving 3 transactions that would pop up via Metamask as seen in the image below.

Hurray! you've done it, we have successfully deployed an ERC-20 smart contract for our new token named TTC.

As you can see in the image below, the dashboard now has other features that will allow us to interact with and use our newly launched token as we please.

Now, let's proceed to check Etherscan Token Tracker and confirm if our new token is really on the blockchain. First, copy the token address as highlighted in the image below.

Once you have copied the address, head over to Etherscan Token Tracker, paste the address, and search.

Great! We can see our token name and symbol. Congrats once again!

If you observe in the image below, the total supply of TTC is zero. We’d fix that in the next article as we learn how to mint tokens.

Closing thoughts

If you decide to make your own cryptocurrency, make sure to use this tutorial only as a starting point. It's a deep topic that takes a long time to understand fully.

Beyond creating the token or coin, you also need to think about making it a success post-launch and studying other projects and their launches to see what worked well and what didn't can help with creating your own cryptocurrency.

Follow and Join Bunzz on Discord | Twitter