Writing efficient smart contracts on Celo using AssemblyScript

Writing efficient smart contracts on Celo using AssemblyScript https://celo.academy/uploads/default/optimized/2X/7/7f2bb3f6f9fbe78eff49747daab6fb783abda7f5_2_1024x576.png
none 0.0 0


This tutorial will cover the basics of AssemblyScript, a variant of TypeScript (which itself is a superset of JavaScript), that you can compile to WebAssembly. We’ll also discuss how to write smart contracts that are optimized for the Celo blockchain, best practices for writing efficient code, and provide examples of smart contracts that utilize AssemblyScript on Celo.

Smart contracts are self-executing contracts with the terms of the agreement directly written into code. The code controls the execution, and transactions are trackable and irreversible. With the rise of blockchain technologies like Ethereum, and more recently Celo, smart contracts are becoming more and more important.

Here’s the source code for our project


Before we proceed, ensure you have:

  • Basic knowledge of JavaScript/TypeScript
  • Familiarity with the concept of smart contracts and blockchain
  • Knowledge of the Celo blockchain and its capabilities.
  • Knowledge of Node.js and npm (Node Package Manager)


The development of smart contracts on Celo using AssemblyScript will require the use of the tools and technologies listed below.

  • Installed Node.js and npm on your local machine
  • Installed Celo development tools (see Celo’s official documentation for instructions)
  • Installed AssemblyScript compiler (asc) using npm. You can install it globally with npm

install -g assemblyscript

Why AssemblyScript?

While Solidity is a popular choice for writing smart contracts, we chose AssemblyScript due to its similarity to TypeScript, making it accessible for JavaScript developers. Furthermore, AssemblyScript compiles directly to WebAssembly (a binary instruction format for a stack-based virtual machine), enabling efficient execution and providing significant performance improvements over JavaScript.


Step 1: Set Up the Development Environment

Start by creating a new directory for your project and navigate into it:


mkdir celo-assemblyscript && cd celo-assemblyscript

Initialize a new AssemblyScript project:

npx asinit .

This command creates a basic AssemblyScript project with a configuration file (assemblyscript.json), an AssemblyScript source file (assembly/index.ts), and a test file (tests/index.spec.ts).

Step 2: Writing the Smart Contract

Navigate to the assembly/ directory, and create a new file contract.ts:


cd assembly && touch contract.ts

Open contract.ts in your preferred text editor and define your contract:


export function helloWorld(): string {

return "Hello, Celo!";


This is a simple “Hello World” smart contract. It contains one function helloWorld() that returns a string.

Step 3: Compile the Smart Contract

Back in your project root directory, run the AssemblyScript compiler to compile your smart contract to WebAssembly:


asc assembly/contract.ts -b build/contract.wasm

This command tells the AssemblyScript compiler (asc) to compile your smart contract and outputs a WebAssembly binary file (contract.wasm) in the build/ directory.

Step 4: Deploying the Smart Contract to the Celo Blockchain

To deploy your smart contract to the Celo blockchain, you’ll need a deployment script. This script interacts with the Celo blockchain, sending transactions to deploy your smart contract. We’ll use the @celo/contractkit library to interact with the Celo blockchain. Install this dependency in your project root:


npm install @celo/contractkit

//Next, create a new file deploy.js in your project root:


const ContractKit = require('@celo/contractkit');

const Web3 = require('web3');

// Connect to the Celo network

let web3 = new Web3('https://alfajores-forno.celo-testnet.org');

let kit = ContractKit.newKitFromWeb3(web3);

let getAccount = require('./getAccount').getAccount;

async function awaitWrapper(){

let account = await getAccount();

// Add your account to contractKit to sign transactions




Replace the https://alfajores-forno.celo-testnet.org with your Celo node URL.

Step 5: Testing the Smart Contract

Testing is an essential step in the development of any application. For smart contracts, due to the immutable nature of the blockchain, testing is even more critical.

Celo’s SDK includes a test framework that you can use to write tests for your smart contracts. Create a new file test/contract.test.ts:


import { expect } from 'chai';

import { helloWorld } from '../assembly/contract';

describe('Hello World Contract', () => {

it('should return "Hello, Celo!"', () => {

expect(helloWorld()).to.equal('Hello, Celo!');



//Run your tests with the as-pect command:

npx as-pect


This article discussed how to write efficient smart contracts for the Celo blockchain using AssemblyScript. We went through setting up the development environment, writing and compiling a smart contract, deploying it to the Celo blockchain, and writing tests.

As you continue your journey in smart contract development, consider diving deeper into the AssemblyScript language and Celo’s features to create more robust and efficient contracts.

By writing your smart contracts in AssemblyScript and deploying them on Celo, you can leverage the performance of WebAssembly and the user-friendly, mobile-first approach of the Celo ecosystem.

Next Steps

Now that you have learnt how to write efficient smart contracts on Celo using AssemblyScript, you can explore more advanced topics such as integrating with external systems, implementing complex business logic, and building decentralized applications on the Celo platform.

About the Author

Michael Diagbare is a Software Engineer with expertise in Web, Blockchain development and content creation, certified by Cisco and MongoDB university. He is passionate about building software, problem solving and helping programmers deal with complicated tasks and challenges.

Connect with me on LinkedIn


AssemblyScript documentation

Celo ContractKit documentation


Hi @Micholn - Contribute is a place for information that helps support contributors to the Celo Academy. It looks like this belongs in Proposals, which is a place to make new Proposals for the Academy. Moving for you now. Thanks for your proposal!

Congratulations on being among the highest voted proposals for this week! I’m moving this to todo so that you can get started on this project. :mortar_board: :seedling:


@Celo_Academy Thank you


I will be reviewing this @Micholn

1 Like

Trypescript seems the future of JavaScript for devs. Nicely dished tutorial👍

1 Like