npm run run:klaytn:cleanlog

4. Writing the contract

In the contracts directory of our project, we can see a few example contracts to start with. Below are the standard contracts to create fungible and non-fungible tokens. We can use this example of contracts to deploy in our network and transfer tokens.

1. KIP7 similar to

ERC-20 token contract

1. KIP17 similar to

ERC-721 token contract

1. KIP37 similar to

ERC-1155 contract

In addition to the existing smart contracts, we can also write our own smart contracts under the contracts folder. Here is a very simple greeter contract:

KlaytnGreeter is a simple contract that returns a greeting message. A greeting message is set when the contract is deployed.

pragma solidity ^0.8.0; 
contract KlaytnGreeter  
/* Define variable greeting of the type string */ 
string greeting; 
/* This runs once when the contract is created */ 
constructor (string memory _greeting) public  
greeting = _greeting; 
 
/* Main function */ 
function greet() public view returns (string memory)  
return greeting;

Save the above code in a KlaytnGreeter.sol file under the contracts folder. The next step is to compile and deploy the smart contract in the local network.

5. Deploying the contract on your local network

The Migrations directory has all the deployment scripts. By default, there are deployment scripts for the token contracts.

1. First, let’s try adding a deployment script for the newly created smart contract. The below code will compile and deploy the

KlaytnGreeter contract in the local network and also saves the API and deployed address in the src folder for future reference.

const fs = require('fs') 
var greeter = artifacts.require('KlaytnGreeter') 
module.exports = function (deployer)  
deployer.deploy(greeter, 'Welcome to Klaytn!').then(() =>  
if (greeter._json)  
fs.mkdir('./src/deployed',  recursive: true , (err) =>  
if (err) throw err 
) 
// Save the deployed abi to greeterABI file in the src folder. 
fs.writeFile('./src/deployed/greeterABI', JSON.stringify(greeter._json.abi, 2), (err) =>  
if (err) throw err 
) 
 
// Save the deployed address to greeterAddress file in the src folder. 
fs.writeFile('./src/deployed/greeterAddress', greeter.address, (err) =>  
if (err) throw err 
console.log( 
`The deployed contract address * $greeter.address * is recorded on deployedAddress file` 
) 
) 
)

We can copy the above code and save it as 5_greeter_migration.js. Now run the below command to deploy the contract.

truffle migrate --f 5 --network klaytn

You will see the below logs once it’s deployed successfully.

2. Now let’s try deploying any one of the existing sample contracts in the network. Run the below command to compile and deploy the fungible token contract.

npm run deploy:klaytn:kip7

If the deployment is successful we can see the deployed API and address files generated under the src/deployed folder.

6. Deploying the contract on the test network

While deploying to the test network is similar to the local network, it requires some configuration changes. Baobab is Klaytn’s test network, similar to Ropsten in Ethereum.

The easiest way to access a testnet is via KAS (Klaytn API Service) which is a public node service similar to Infura. KAS provides access to public Klaytn nodes for testnets as well as the main network via free and paid plans.

1. You can sign up for

Klaytn API Service and get the assigned Access key and Secret key which are used to connect to the Baobab testnet.

1. The next step is to configure truffle-config.js to update the testnet configuration.

kasBaobab:  
provider: () =>  
const option =  
headers: [ 
 name: 'Authorization', value: 'Basic ' + Buffer.from(accessKeyId + ':' + secretAccessKey).toString('base64') ,  name: 'x-chain-id', value: '1001'  
], 
keepAlive: false, 
 
return new HDWalletProvider(privateKey, new Caver.providers.HttpProvider("https://node-api.klaytnapi.com/v1/klaytn", option)) , 
network_id: '1001', //Klaytn baobab testnet's network id 
gas: '8500000', 
gasPrice:'25000000000'

truffle-config.js file in the sandbox has the above configuration already.

3. Add the Access key and Secret key obtained from Step1 to the .env file

ACCESS_KEY_ID=KASKY9YK7JE3NEXQZN6PWT86 
SECRET_ACCESS_KEY=nO14rGPiz1QDpDdjWGcYoVTueC3ksJTcZ_eg3887 
KAS_TESTNET_API_URL=https://node-api.klaytnapi.com/v1/klaytn

4. Now we have all the configuration updates to deploy in the Baobab test network. Execute the below command to deploy.

truffle migrate --f 1 --to 2 --network kasBaobab

We can see the below output of the deployed API and address files generated under the src/deployed folder.