3 posts tagged with "crypto "

In this tutorial, we will create your own token. The mintable supply version of this standard guarantees no token will ever be created after the initial emission. Fungible tokens are token from which the value of each token is equal to another.

In this tutorial, we will:

• Deploy the smart contract template for your token
• Process your first token transfer

Deploying the Smart contract from our template​

const axios = require("axios")

const axiosInstance = axios.create({
    baseURL: "https://api.starton.com",
    headers: {
        "x-api-key": "PUT HERE YOUR API KEY",
    },
})

axiosInstance
    .post("/v3/smart-contract/from-template", {
        network: "", // The blockchain network on which you want to deploy your smart contract
        signerWallet: "", // The address of the signer wallet
        templateId: "ERC20_MINT_META_TRANSACTION",
        name: "", // The name of the contract on Starton
        description: "", // The description of the contract on Starton
        params: [
            "", // The name of your smart contract which will be reflected on-chain.
            "", //  The symbol of your smart contract which will be reflected on-chain
            "", // The total amount of tokens that will ever be minted.
            "", // The address that will own the ERC20 contract.
        ],
    })
    .then((response) => {
        console.log(response.data)
    })

Congrats on deploying your smart contract.

Process your first token transfer​

const axios = require("axios")

const axiosInstance = axios.create({
    baseURL: "https://api.starton.com",
    headers: {
        "x-api-key": "PUT HERE YOUR API KEY",
    },
})

axiosInstance
    .post("/v3/smart-contract/YOUR_SMART_CONTRACT_NETWORK/YOUR_SMART_CONTRACT_ADDRESS/call", {
        functionName: "transfer(address,uint256)",
        params: [
            "", // Enter the wallet receiving tokens.
            "", //amount of token transferred
        ],
        signerWallet: "", // Enter the wallet from which tokens will be transferred.
        speed: "average",
    })
    .then((response) => {
        console.log(response.data)
    })

Congratulations! You've transferred your first token.

In this tutorial, we’ll use Starton Connect to create our own crypto token!

We will deploy a smart contract directly from code using the Relayer.

The contract will be an instance of an audited premade template available in Starton.

The language used will be Javascript but any language would work in a similar manner.

Get the list of available templates​

Before deploying our contract let's get the list of templates in order to find one that suits our need.

To do this, we’ll need to query Connect’s API and to authenticate ourselves using an API key.

We can create an API key from the dashboard in the Developer section. Using this API key we can call the API with the following JS code:

const axios = require("axios")

const http = axios.create({
	baseURL: "https://api.starton.com/v3",
	headers: {
		"x-api-key": "YOUR_API_KEY",
	},
})
http.get("/smart-contract-template").then((response) => {
	console.log(response.data)
})

Be sure to replace x-api-key value with your own api key! When querying the API, it should return a list of template items:

{
	"id": "ERC20_META_TRANSACTION",
	"name": "ERC20 Fungible Token with fixed supply",
	"description": "An ERC20 token contract keeps track of fungible tokens: any one token is exactly equal to any other token",
	"tags": ["..."],
	"blockchains": ["..."],
	"bytecode": "string",
	"constructorParams": ["..."],
	"abi": ["..."],
	"compilerVersion": "string",
	"source": "string",
	"isAudited": true,
	"isActivated": true,
	"createdAt": "string",
	"updatedAt": "string"
}

This is the object associated with the template we’ll use for our crypto token.

We’ll be using an ERC20 template as it is the standard for token creation on EVM based blockchains.

Choose a Network and fuel wallet​

Now that we know which template to use, we also need to choose a network on which to deploy.

The compatible blockchains for this template can be seen inside the blockchain objects in the previously returned template object.

For example for the Ethereum blockchain there are multiple available networks such as ethereum-mainnet or ethereum-sepolia (testnet).

We’ll choose to deploy our contract on the ethereum-sepolia network.

It is now important that we fuel our wallet with some Ether faucet otherwise the blockchain will reject our smart contract’s deployment as we will lack funds to cover the gas fees.

In order to claim test faucets we need to go on the Wallet section on Connect’s dashboard and find the address associated to the network we are interested in.

Here, it is the ethereum-sepolia network.

We can now claim free faucet on the official Ethereum faucet website. Enter your address, click Send me test Ether and wait for the transaction to complete.

Deploying the contract​

Everything is now in place so we can create an instance of the smart contract template we picked.

We’ll use the ID of the template we got in order to tell Deploy which template to use for the contract creation.

We also need to provide values for the parameters of our smart contract’s constructor.

For our ERC20, we’ll need to provide:

• a name for our token
• a ticker
• the initial supply

Let’s call our token the DemoToken, with DEMO as its ticker and an initial supply of 1.000.000 tokens.

Here is the code to deploy the contract (Axios being configured as before):

http.post("/smart-contract/from-template", {
	network: "ethereum-sepolia",
	templateId: "ERC20_META_TRANSACTION",
	name: "DemoToken",
	description: "Our own crypto token.",
	params: ["1000000", "DemoToken", "DEMO"],
}).then((response) => {
	console.log(response.data)
})

The expected result:

{
	"id": "sc_24dce9e26a7d46a7b707e257a6a6cfb2",
	"name": "DemoToken",
	"description": "Our own crypto token.",
	"network": "ethereum-sepolia",
	"bytecode": " … ",
	"abi": ["..."],
	"projectId": "prj_f2108b28949d47898a39939cbc7277c3",
	"address": "0xDA96a733ec2C3eC1142A5A1Ef31cfd7755CAE037",
	"creationHash": "0xef4313209959d6441e14db5d43905f674a78adba2173b522b7fe37311e135c05",
	"createdAt": "Tue Jun 29 2021 13:09:17 GMT+0000 (Coordinated Universal Time)",
	"updatedAt": "Tue Jun 29 2021 13:09:17 GMT+0000 (Coordinated Universal Time)"
}

If it worked, congrats! You just created your own crypto token in a few minutes and with a minimal amount of code.

Checking the contract creation​

Most blockchains propose a blockchain explorer so we can inspect the state and history of the blockchain.

We can thus use the previously returned address and creation hash to check for our contract’s status on the blockchain.

The summary of the transaction created for the deployment of our contract (using the creationHash in the url) is available. We can also track here our new DEMO token.

Result​

Or more generally, we can use the address of the contract to find out how it interacted with the world.

Congratulations for completing this tutorial!

You can also deploy your smart contract from our web application.

You can use Starton to integrate blockchain into your application in a few steps. Let's create a project to deploy a smart contract from Code with Starton's API.

Step 1 - Initialize the project​

1. Start by creating a directory for your project:

   mkdir starton-deploy
   

2. Then, get into your project directory:

   cd starton-deploy
   

3. With your project directory set up, install the dependencies:

   npm add axios
   

4. Then, usetouch to create a index.js file and open it with your favorite editor.

   touch list.js
   

Step 2 - Add starton to your project​

1. First, import axios.

   const axios = require("axios")
   

2. Then, initialize axios using Starton URL and authenticate with your API KEY.

   Create an API key

   
   

      const starton = axios.create({
      baseURL: "https://api.starton.com",
      headers: {
          "x-api-key": "YOUR API KEY",
      },
   })
   

Step 3 - Creating a wallet​

Before we can continue you will need a Starton Wallet to sign our transaction.

We recommend you to create your wallet on Starton web application, but you can also create it from code if you'd like to automate it.

starton.post("/v3/kms/wallet", {
   "description": "string",
   "name": "string",
   "kmsId": "kms_33333333333333333333333333333333"
})
.then((response) => console.log(`New wallet address: ${response.data.address}`)
.catch(error) => console.error(error.response.data)

Step 4 - Deploy your ERC20 token​

Now, let's write your first API call!

starton.post("/v3/smart-contract/from-template", {
    "network": "binance-testnet", // you can choose any network
    "signerWallet": "YOUR STARTON WALLET", // This will be the wallet that pay the fee. Must be on starton, cannot be a Metamask wallet
    "templateId": "ERC20_META_TRANSACTION", // you can choose another template
    "name": "My first smart token", // the name that will be displayed on the dashboard, not on chain
    "description": "This is the first smart contract I deploy. ", // same, dashboard description and optional
    "params": [
        "My first token ", // Your smart contract name, on chain
        "MFT", // the symbol of your token
        "10000" + "000000000000000000", // 10000 token supply + 18 zero.
        "ANY WALLET YOU WANT" // The wallet that will receive the token supply, can be a starton wallet or metamask
    ],
    "speed": "average", // The fees you will pay on chain. More info HERE
}).then((response) => {
    console.log({
        transactionHash: response.data.transaction.transactionHash,
        smartContractAddress: response.data.smartContract.address,
        explorer: `https://testnet.bscscan.com/tx/${response.data.transaction.transactionHash}`
    })
}).catch(error => console.error(error.response.data))

Congratulations on your first request. Let's dive into what we just did:

• The endpoint /v3/smart-contract/from-template allows you to deploy audited smart contracts. You can also deploy smart contract your own code, or import an existing contract
• We selected a blockchain network for your deployment: binance-testnet. You can choose any network from our list of supported networks
• We used the Starton KMS to sign the transaction and pay gas fee. This allows you to automate transactions, but also to sponsor the end-user fees with gasless transaction
• We used a ERC20 template. You can find more templates in Starton Library
• We had to put 18 zeros after "10000" as the smart contract will read the amount in wei (the equivalent of cents, except there are 18 decimals and not 2).
• We selected an average speed for your transaction. But with Starton everything is customizable. You can also set up a gas strategy to automate the management of your transactions.

Almost done! Now we can execute it to get our first contract deployed!

node list.js

And voilà, your first contract is deployed!

{
    "transactionHash": "0x43462af8448e34ea5cddbb73b4dcf5c0c04fa6155111273a1573ec6c4c9a59e8",
    "smartContractAddress": "0xB4B4a180f065b2461eF64359909fb0cfCb04D986",
    "explorer": "https://testnet.bscscan.com/tx/0x43462af8448e34ea5cddbb73b4dcf5c0c04fa6155111273a1573ec6c4c9a59e8"
}

Congratulations on deploying your first smart contract! In this tutorial, you discovered how to deploy your first smart contract but this is only the first step.

What's next?​

Learn how to: