CryptoVIR

Cara Membuat Crowdsale (ICO) di Blockchain Coinex Smart Chain

Blockchain, Education, News, Sponsored Post

Cara Membuat Crowdsale (ICO) di Blockchain Coinex Smart Chain

Perusahaan blockchain yang baru merintis, lebih sering melakukan Initial Coin Offering (ICO) atau Crowdsale untuk menggalang dana dari masyarakat. ICO/Crowdsale adalah proses menjual unit digital cryptocurrecy atau token kepada investor, yang bertujuan untuk mengumpulkan uang, yang nantinya uang tersebut akan digunakan untuk mengembangkan proyek.

Sistem ICO atau Crowdsale sebenarnya sangat sederhana, yaitu investor mengirimkan (contoh) ETH ke alamat proyek, dan sebagai imbalannya adalah investor menerima token yang tersimpan di smart contract, jumlah token yang diterima tergantung jumlah ETH yang di kirim dan rate harga token, token ICO biasanya akan di terima secara otomatis, setelah investor berhasil mengirim ETH.

ICO-Crowdsale bisanya berjalan di blockchain yang support fitur smart contract, seperti Ethereum, Coinex Smart Chain, Polygon. Proses penjualan token ICO dilakukan otomatis oleh smart contract, prosess pengiriman token ICO dan coin native berjalan secara otomatis juga, hal ini sangat memudahkan developer proyek untuk menggalang dana.

Di Artikel ini kami akan memberikan tutorial Cara Membuat Crowdsale ICO di Blockchain Coinex Smart Chain. Cara ini bisa anda terapkan atau gunakan ketika anda ingin menggalang dana. Pembuatan ICO sangat mudah, hanya membutuhkan beberapa step saja, ICO bisa langsung digunakan. Mengapa saya memilih Coinex Smart Chain ? Karena blockchain CSC mempunyai performa tinggi, prosess transaksi sangat cepat, support EVM dan fee transaksi sangat murah.

Yang Perlu Anda Siapkan untuk Membuat Crowdsale ICO

1.  EVM Wallet

Anda bisa menggunakan wallet metamask untuk membuat crowdsale, metamask tersedia versi android dan browser, saya anjurkan menggunakan versi browser agar prosess menjadi lebih mudah.

2.  Coin CET (Coin Native Coinex Smart Chain)

Anda membutuhkan coin CET untuk membayar transaksi di jaringan-blockchain Coinex Smart Chain, untuk mendapatkan coin CET anda bisa membeli di Coinex Exchange. Jika sudah membeli, kirim CET ke wallet anda

3. Token CRC20

Karena kita akan menggalang dana dengan cara menjual token, maka anda menyiapkan token crc20 yang akan anda jual ke investor. Untuk membuat CRC20 bisa menggunakan smart contract openzeplin.

4. Smart Contract Crowdsale

Smart contract ICO/Crowdsale mempunyai beberapa jenis, di artikel ini kami akan menggunakan public crowdsale, tanpa ada fitur lain nya.

 

Cara Membuat Membuat Crowdsale ICO di Coinex Smart Chain
1. Deploy Token CRC20 

Deploy smart contract di bawah ini menggunakan remix ethereum IDE, silahkan ganti detail nama, supply dan symbol token

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";

contract CSCCryptoVIR1 is ERC20, ERC20Burnable {
constructor() ERC20("CSC CryptoVIR 1", "CSVR1") {
_mint(msg.sender, 1000000000 * 10 ** decimals());
}
}

Compile smart contract, dan deploy menggunakan Environment “Injected Web3” – Setelah itu lakukan konfirmasi di wallet metamask anda.

 

2. Deploy Smart Contract Crowdsale

Smart contract ini adalah public smart crowdsale, jadi siapa saja bisa membeli token ico, tanpa ada sistem whitelist. Ada beberapa hal yang perlu anda setting sebelum deploy crodwsale,

  • Rate Token : ini adalah harga untuk tiap token nya. Penjualan token akan menggunakan coin native CET, contoh jika rate (1000 token untuk 1 CET) maka ketika ada investor mengirim 100 CET, di akan menerima 100.000 token ico.
  • Alamat Wallet : alamat wallet yang akan menerima coin CET (hasil penjualan token ico), semua penjualan akan masuk ke wallet tersebut.
  • Smart Contract Address token ICO : kita perlu memasukan smart contract address token ico saat kita melakukan prosess deploy cmart contract crowdsale

Smart Contract Crowdsale

// SPDX-License-Identifier: MIT
pragma solidity 0.5.17;

library Address {
function isContract(address account) internal view returns (bool) {
bytes32 codehash;
bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
assembly { codehash := extcodehash(account) }
return (codehash != accountHash && codehash != 0x0);
}
}

contract Context {
constructor () internal { }
function _msgSender() internal view returns (address payable) {
return msg.sender;
}
}

contract ReentrancyGuard {
bool private _notEntered;
constructor () internal {
_notEntered = true;
}

modifier nonReentrant() {
require(_notEntered, "ReentrancyGuard: reentrant call");
_notEntered = false;

_;

_notEntered = true;
}
}

library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");

return c;
}

function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}

function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;

return c;
}

function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}

uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");

return c;
}
}

interface ERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}

library SafeERC20 {
using SafeMath for uint256;
using Address for address;

function safeTransfer(ERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}

function safeTransferFrom(ERC20 token, address from, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}

function callOptionalReturn(ERC20 token, bytes memory data) private {
require(address(token).isContract(), "SafeERC20: call to non-contract");

(bool success, bytes memory returndata) = address(token).call(data);
require(success, "SafeERC20: low-level call failed");

if (returndata.length > 0) { // Return data is optional
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}

contract ICO is Context, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for ERC20;
ERC20 private _mytoken;
address payable private _wallet;
uint256 private _ethRate;
uint256 private _mytokenDelivered;
event MyTokenPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor (uint256 ethRate, address payable wallet, ERC20 mytoken) public {

require(ethRate > 0, "ICO: ethRate shouldn't be Zero");
require(wallet != address(0), "ICO: wallet is the Zero address");
require(address(mytoken) != address(0), "ICO: token is the Zero address");
_ethRate = ethRate;
_wallet = wallet;
_mytoken = mytoken;
}

function mytokenAddress() public view returns (ERC20) {
return _mytoken;
}

function teamWallet() public view returns (address payable) {
return _wallet;
}

function ethRate() public view returns (uint256) {
return _ethRate;
}

function mytokenDelivered() public view returns (uint256) {
return _mytokenDelivered;
}

function () external payable {
buyMyTokenWithEther();
}

function buyMyTokenWithEther() public nonReentrant payable {
address beneficiary = _msgSender();
uint256 ethAmount = msg.value;
uint256 ContractBalance = _mytoken.balanceOf(address(this));
require(ethAmount > 0, "You need to sendo at least some Ether");
uint256 _mytokenAmount = _getEthRate(ethAmount);
_preValidatePurchase(beneficiary, _mytokenAmount);
require(_mytokenAmount <= ContractBalance, "Not enough MyToken in the reserve");
_mytokenDelivered = _mytokenDelivered.add(_mytokenAmount);
_processPurchase(beneficiary, _mytokenAmount);
emit MyTokenPurchased(_msgSender(), beneficiary, ethAmount, _mytokenAmount);
_updatePurchasingState(beneficiary, _mytokenAmount);
_forwardEtherFunds();
_postValidatePurchase(beneficiary, _mytokenAmount);
}

function _preValidatePurchase(address beneficiary, uint256 Amount) internal view {
require(beneficiary != address(0), "ICO: beneficiary is the zero address");
require(Amount != 0, "ICO: Amount is 0");
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
}

function _postValidatePurchase(address beneficiary, uint256 Amount) internal view {
}

function _deliverMyToken(address beneficiary, uint256 mytokenAmount) internal {
_mytoken.safeTransfer(beneficiary, mytokenAmount);
}

function _processPurchase(address beneficiary, uint256 mytokenAmount) internal {
_deliverMyToken(beneficiary, mytokenAmount);
}

function _updatePurchasingState(address beneficiary, uint256 Amount) internal {
}

function _getEthRate(uint256 ethAmount) internal view returns (uint256) {
return ethAmount.mul(_ethRate);
}

function _forwardEtherFunds() internal {
_wallet.transfer(msg.value);
}
}

contract LimitedUnitsIco is ICO {
using SafeMath for uint256;

uint256 private _maxMyTokenUnits;

constructor (uint256 maxMyTokenUnits) public {
require(maxMyTokenUnits > 0, "Max Capitalization shouldn't be Zero");
_maxMyTokenUnits = maxMyTokenUnits;
}

function maxMyTokenUnits() public view returns (uint256) {
return _maxMyTokenUnits;
}

function icoReached() public view returns (bool) {
return mytokenDelivered() >= _maxMyTokenUnits;
}

function _preValidatePurchase(address beneficiary, uint256 Amount) internal view {
super._preValidatePurchase(beneficiary, Amount);
require(mytokenDelivered().add(Amount) <= _maxMyTokenUnits, "Max MyToken Units exceeded");
}
}

Deploy menggunakan Remix-Ethereum-IDE, masuk detail Rate (harga token per 1 CET), Wallet yang akan menampung hasil jualan dan Smart Contract CRC20

 

3. Kirim Token ICO ke Smart Contract Address Crowdsale

Setelah pembuatan smart contract selesai, anda perlu mengirim token crc20 ICO ke contract address crowdsale, jumlah token yang di kirim sesuai dengan alokasi penjulan awal, jumlah tersebut tergantung dari tokenomics project anda.

 

4. Test Crowdsale / Membeli Token ICO

Untuk membeli token ico atau berpartisipasi di crowdsale sangat mudah, anda hanya perlu mengirim coin native CET ke alamat crowdsale  (alamat smart contract crowdsale) . Setelah anda mengirim coin CET, anda akan menerima token ico sesuai dengan rate harga token tersebut, prosess ini secara otomatis, anda akan langsung menerima token tanpa harus menunggu unlock atau vesting.

Saya mencoba membeli token ico dengan mengirim coin CET ke alamat crowdsale, dalam waktu 7 detik saya langsung menerima token ico tersebut, sangat fantastis, blockchain coinex smart chain benar-benar sangat cepat, dan fee transaksi sangat murah sekali. Dengan crowdsale tersebut anda bisa menggalang dana project dengan mudah, tanpa harus membayar biaya ke pihak lain

Selamat mencoba 

Alif Fahmi

Posted by

hi , I'm Alif, I'm a blockchain & cryptocurrency lover, I love writing & learning, my job is web developer & crypto trader

log in

Captcha!
Forgot password?

forgot password

Back to
log in