Toqua

toqua

Launch a Token on Rootstock: Leverage Bitcoin's Security with Smart Contracts

Hono is a cutting-edge, lightweight backend framework designed for cloud-native applications. Built on Node.js, Hono is optimized for speed and scalability, perfect for building high-performance APIs and services. Its minimalistic design allows developers to create efficient, scalable solutions for modern cloud environments quickly. Hono also offers support for edge computing, middleware, and routing, making it an excellent choice for developers looking to build cloud-native applications with minimal overhead and maximum performance. Create a Simple Backend We will use Bun - another JavaScript runtime, and Node.js-compatible package manager. If you are not familiar with Bun, please read this article. 1. Install Hono bun create hono hono-demo ✔ Using target directory … hono-demo ? Which template do you want to use? bun ? Do you want to install project dependencies? yes ? Which package manager do you want to use? bun ✔ Cloning the template ✔ Installing project dependencies 🎉 Copied project files Get started with: cd hono-demo Move to hono-demo cd hono-demo Install dependencies bun install 2. Run the Hono App Change the default port // index.ts

import { Hono } from 'hono';

const app = new Hono();

app.get('/', (c) => { 

 return c.text('Hello Hono!');

});

export default { port: 4200, fetch: app.fetch, }; Run the app bun dev Result $ bun run --hot src/index.ts Started server http://localhost:4200 Now, the HTTP requests coming to the Bun server will be handled by the Hono framework, providing us with a much more convenient API. 3. Grouped Routing in Hono.JS According to the official Hono documentation, the framework supports grouped routing, allowing you to organize routes using an instance of Hono and add them to the main application using the route method. Let’s create a post.ts inside a routes folder. Don’t forget to export posts as the default export: // routes/post.ts

import { Hono } from 'hono';

const post = new Hono();

post.get('/', (c) => c.text('List Posts')); // GET /post 

post.get('/:id', (c) => { 

 // GET /post/:id const id = c.req.param('id');

 return c.text('Get Post: ' + id);

}); 

post.post('/', (c) => c.text('Create Book')); // POST /post

export default post; Open Postman, and navigate to http://localhost:4200/post/2 to test it 4. So, what exactly is the "c" in the arguments? However, you might have noticed that c is used instead of req. This c stands for the context object, as detailed in the Hono.js documentation. In practice, all incoming and outgoing data is managed by this context object. Hono allows you to return responses in various formats, not just JSON but also others, such as body, text, notFound, redirect, and more. Hono is also well-suited for handling and returning small amounts of HTML. 5. Rendering TSX/JSX Although hono/jsx is typically used on the client side, it can also be utilized for server-side content rendering. In the JSX section, there’s an example of a functional React component. Let’s try rendering it server-side: Create a post page inside a pages folder: // pages/post.tsx

import { FC, PropsWithChildren } from 'hono/jsx';

type PostData = { title: string; id: string; };

const Layout: FC = ({ children }: PropsWithChildren) => { 

 return ( <html> <body>{children}</body> </html> );

};
const PostComponent = ({ title, id }: PostData) => { 

 return ( <Layout> <h1>Hello {title}</h1> <p>Your id is {id}</p> </Layout> );

};

export default PostComponent; Now, let’s connect it to our post route: // routes/post.tsx

post.get('/:id', (c) => { 

 // GET /book/:id const id = c.req.param('id');

 return c.html(<PostComponent id={id} title={' World!'} />);

}); Open http://localhost:4200/post/2 in your browser to test it. This approach is similar to SSR in Next.js or Remix.js, but it's much lighter. Hono also supports other features like asynchronous components, Suspense, and more. 6. Middleware Middleware is a function that integrates into the routing process and performs various operations. You can intercept a request before it's processed or modify a response before it's sent. HonoJS has a lot of built-in middleware, and you can add your own or reuse middleware created by the community. Let's take a look at the official example from the documentation. Add this code to index.ts file, before routes initialization app.use(async (c, next) => 

 { const start = Date.now();

 await next();

 const end = Date.now();

 c.res.headers.set('X-Response-Time', ${end - start});

}); 7. Handling Redirects You can create a redirect using the c.redirect() method: c.redirect('/go-there'); c.redirect('/go-there', 301); 8. Handling CORS import { cors } from 'hono/cors';
app.use('/api/*', cors()); 9. Testing Create index.test.ts file: import { expect, test, describe } from 'bun:test';

import { Hono } from 'hono';

import { testClient } from 'hono/testing';

describe('Example', async () => {

  const app = new Hono().get('/', (c) => c.json('Hello Hono!'));

  const res = await testClient(app).$get();

  test('GET /post', async () => {

    const res = await app.request('/');

    expect(res.status).toBe(200);

    expect(await res.json()).toEqual('Hello Hono!');

  });

}); Now run bun test bun test v1.1.26 (0a37423b)

src\index.test.ts: ✓ Example > GET /post

1 pass 0 fail 2 expect() calls Ran 1 tests across 1 files. [301.00ms] This article was originally published at JSDevSpace. Hono is a cutting-edge, lightweight backend framework designed for cloud-native applications. Built on Node.js, Hono is optimized for speed and scalability, perfect for building high-performance APIs and services. Its minimalistic design allows developers Hono Hono to create efficient, scalable solutions for modern cloud environments quickly. Hono also offers support for edge computing, middleware, and routing, making it an excellent choice for developers looking to build cloud-native applications with minimal overhead and maximum performance. Create a Simple Backend We will use Bun - another JavaScript runtime, and Node.js-compatible package manager. If you are not familiar with Bun, please read this article . Bun article 1. Install Hono bun create hono hono-demo bun create hono hono-demo ✔ Using target directory … hono-demo ? ✔ Using target directory … hono-demo ? Which template do you want to use? bun ? Which template do you want to use? bun ? Do you want to install project dependencies? yes ? Do you want to install project dependencies? yes ? Which package manager do you want to use? bun Which package manager do you want to use? bun ✔ Cloning the template ✔ Cloning the template ✔ Installing project dependencies ✔ Installing project dependencies 🎉 Copied project files Get started with: cd hono-demo 🎉 Copied project files Get started with: cd hono-demo Move to hono-demo cd hono-demo cd hono-demo Install dependencies bun install bun install 2. Run the Hono App Change the default port // index.ts

import { Hono } from 'hono';

const app = new Hono();

app.get('/', (c) => { 

 return c.text('Hello Hono!');

});

export default { port: 4200, fetch: app.fetch, }; // index.ts

import { Hono } from 'hono';

const app = new Hono();

app.get('/', (c) => { 

 return c.text('Hello Hono!');

});

export default { port: 4200, fetch: app.fetch, }; Run the app Run the app bun dev bun dev Result $ bun run --hot src/index.ts Started server http://localhost:4200 $ bun run --hot src/index.ts Started server http://localhost:4200 Now, the HTTP requests coming to the Bun server will be handled by the Hono framework, providing us with a much more convenient API. Bun Hono 3. Grouped Routing in Hono.JS According to the official Hono documentation , the framework supports grouped routing, allowing you to organize routes using an instance of Hono and add them to the main application using the route method. Hono documentation Let’s create a post.ts inside a routes folder. Don’t forget to export posts as the default export: post.ts // routes/post.ts

import { Hono } from 'hono';

const post = new Hono();

post.get('/', (c) => c.text('List Posts')); // GET /post 

post.get('/:id', (c) => { 

 // GET /post/:id const id = c.req.param('id');

 return c.text('Get Post: ' + id);

}); 

post.post('/', (c) => c.text('Create Book')); // POST /post

export default post; // routes/post.ts

import { Hono } from 'hono';

const post = new Hono();

post.get('/', (c) => c.text('List Posts')); // GET /post 

post.get('/:id', (c) => { 

 // GET /post/:id const id = c.req.param('id');

 return c.text('Get Post: ' + id);

}); 

post.post('/', (c) => c.text('Create Book')); // POST /post

export default post; Open Postman , and navigate to http://localhost:4200/post/2 to test it Postman 4. So, what exactly is the "c" in the arguments? However, you might have noticed that c is used instead of req. This c stands for the context object, as detailed in the Hono.js documentation. In practice, all incoming and outgoing data is managed by this context object. Hono allows you to return responses in various formats, not just JSON but also others, such as body , text , notFound , redirect, and more. JSON body text notFound redirect, Hono is also well-suited for handling and returning small amounts of HTML. Hono 5. Rendering TSX/JSX Although hono/jsx is typically used on the client side, it can also be utilized for server-side content rendering. hono/jsx In the JSX section, there’s an example of a functional React component. Let’s try rendering it server-side: Create a post page inside a pages folder: // pages/post.tsx

import { FC, PropsWithChildren } from 'hono/jsx';

type PostData = { title: string; id: string; };

const Layout: FC = ({ children }: PropsWithChildren) => { 

 return ( <html> <body>{children}</body> </html> );

};
const PostComponent = ({ title, id }: PostData) => { 

 return ( <Layout> <h1>Hello {title}</h1> <p>Your id is {id}</p> </Layout> );

};

export default PostComponent; // pages/post.tsx

import { FC, PropsWithChildren } from 'hono/jsx';

type PostData = { title: string; id: string; };

const Layout: FC = ({ children }: PropsWithChildren) => { 

 return ( <html> <body>{children}</body> </html> );

};
const PostComponent = ({ title, id }: PostData) => { 

 return ( <Layout> <h1>Hello {title}</h1> <p>Your id is {id}</p> </Layout> );

};

export default PostComponent; Now, let’s connect it to our post route: // routes/post.tsx

post.get('/:id', (c) => { 

 // GET /book/:id const id = c.req.param('id');

 return c.html(<PostComponent id={id} title={' World!'} />);

}); // routes/post.tsx

post.get('/:id', (c) => { 

 // GET /book/:id const id = c.req.param('id');

 return c.html(<PostComponent id={id} title={' World!'} />);

}); Open http://localhost:4200/post/2 in your browser to test it. This approach is similar to SSR in Next.js or Remix.js , but it's much lighter. Hono also supports other features like asynchronous components, Suspense , and more. Next.js Remix.js Suspense 6. Middleware Middleware is a function that integrates into the routing process and performs various operations. Middleware You can intercept a request before it's processed or modify a response before it's sent. HonoJS has a lot of built-in middleware, and you can add your own or reuse middleware created by the community. HonoJS Let's take a look at the official example from the documentation. Add this code to index.ts file, before routes initialization index.ts app.use(async (c, next) => 

 { const start = Date.now();

 await next();

 const end = Date.now();

 c.res.headers.set('X-Response-Time', ${end - start});

}); app.use(async (c, next) => 

 { const start = Date.now();

 await next();

 const end = Date.now();

 c.res.headers.set('X-Response-Time', ${end - start});

}); 7. Handling Redirects You can create a redirect using the c.redirect() method: c.redirect('/go-there'); c.redirect('/go-there'); c.redirect('/go-there', 301); c.redirect('/go-there', 301); 8. Handling CORS import { cors } from 'hono/cors';
app.use('/api/*', cors()); import { cors } from 'hono/cors';
app.use('/api/*', cors()); 9. Testing Create index.test.ts file: import { expect, test, describe } from 'bun:test';

import { Hono } from 'hono';

import { testClient } from 'hono/testing';

describe('Example', async () => {

  const app = new Hono().get('/', (c) => c.json('Hello Hono!'));

  const res = await testClient(app).$get();

  test('GET /post', async () => {

    const res = await app.request('/');

    expect(res.status).toBe(200);

    expect(await res.json()).toEqual('Hello Hono!');

  });

}); import { expect, test, describe } from 'bun:test';

import { Hono } from 'hono';

import { testClient } from 'hono/testing';

describe('Example', async () => {

  const app = new Hono().get('/', (c) => c.json('Hello Hono!'));

  const res = await testClient(app).$get();

  test('GET /post', async () => {

    const res = await app.request('/');

    expect(res.status).toBe(200);

    expect(await res.json()).toEqual('Hello Hono!');

  });

}); Now run bun test bun test bun test v1.1.26 (0a37423b)

src\index.test.ts: ✓ Example > GET /post

1 pass 0 fail 2 expect() calls Ran 1 tests across 1 files. [301.00ms] bun test v1.1.26 (0a37423b)

src\index.test.ts: ✓ Example > GET /post

1 pass 0 fail 2 expect() calls Ran 1 tests across 1 files. [301.00ms] This article was originally published at JSDevSpace. This article was originally published at JSDevSpace . JSDevSpace

Hono - A Cutting-Edge Backend Framework for Cloud-Native Applications

How to Deploy a Smart Contract to Ethereum Network Using dRPC API Key and Endpoint

Как да внедрите интелигентен договор в мрежата на Ethereum с помощта на dRPC API ключ и крайна точка

Cómo implementar un contrato inteligente en la red Ethereum usando la clave API y el punto final de dRPC

dRPC API कुंजी और एंडपॉइंट का उपयोग करके Ethereum नेटवर्क पर स्मार्ट कॉन्ट्रैक्ट कैसे तैनात करें

Intelligens szerződés üzembe helyezése az Ethereum hálózaton a dRPC API kulcs és végpont használatával

Cara Menyebarkan Kontrak Cerdas ke Jaringan Ethereum Menggunakan Kunci API dan Titik Akhir dRPC

dRPC API キーとエンドポイントを使用して Ethereum ネットワークにスマート コントラクトをデプロイする方法

Kā izvietot viedo līgumu Ethereum tīklā, izmantojot dRPC API atslēgu un galapunktu

Ahoana ny fametrahana fifanarahana marani-tsaina amin'ny tambajotra Ethereum amin'ny fampiasana dRPC API Key sy Endpoint

Maitiro ekutumira Smart Contract kuEthereum Network Uchishandisa dRPC API Kiyi uye Endpoint

Jinsi ya Kupeleka Mkataba wa Smart kwa Mtandao wa Ethereum Kwa Kutumia dRPC API Key na Endpoint

ከመይ ጌርና dRPC API Keyን Endpointን ብምጥቃም Smart Contract ናብ Ethereum Network ነዋፍር

Cách triển khai hợp đồng thông minh vào mạng Ethereum bằng khóa API dRPC và điểm cuối

As a big advocate of Test-Driven Development (TDD), I have spent a good amount of time wondering why 95% of my conversations about TDD with other engineers go something like this: “Yes, TDD is clearly the right way to build software. But I don’t actually do it.” At this point, the usual reasons and explanations are laid out: “It’s hard to know what tests to write until I have written the code.”
“How can I know how the tests should work if I don’t know how the code works?” It is true that if you are testing something that uses completely unfamiliar technology, you probably don’t know yet how to go about testing it. Most of the time, though, the technology is perfectly familiar. It’s not the tools that are unfamiliar and scary - it’s the product that you are trying to build. Enter my ✨One Simple Trick™✨… Forget about the code completely (for now). All of it. Don’t think about the implementation, and don’t think about the test code either. Instead, just write a plan for how the product should work. Here’s how I do it: Step 1 Start by writing simple comments in human language. Write as many as you can think of, with one per requirement, acceptance criteria, scenario, edge case, or error. Here’s an example: // animals.test.ts
// Plan for new API endpoint: GET /animals

// returns a list of animals with the ID and name

// paginated 10 at a time by default

// can change the pagination size

// optionally filters by species type (in the query params)

// returns a 403 error if not authenticated Of course, the code has to happen at some point. But by starting with comments like this, it removes all of the psychological resistance to the idea of writing tests, allowing you to focus on what you’re trying to build. Step 2 Write the actual tests one by one by converting each comment into an assertion. // animals.test.ts

import { request } from "supertest";
import { app } from "./app";

it('returns a list of animals with the ID and name', async () => {
  const result = await request(app).get('/animals');
  
  result.forEach(animal => {
    expect(animal).toEqual({
      id: expect.any(String),
      name: expect.any(String),
    });
  });
})

// paginated 10 at a time by default

// can change the pagination size

// optionally filters by species type (in the query params)

// returns a 403 error if not authenticated It is worth noting that this technique is best paired with the philosophy of Write Tests. Not Too Many. Mostly Integration. While the ‘comments-first’ approach can be applied to unit tests, it is much easier to start with higher-level, more product-focused integration tests. Step 3 Write the bare minimum application code to make the first test pass. For example, to make this first test pass, you could return this hardcoded array from the API endpoint: // animals.ts

res.send([{ id: "foo", name: "bar"}]); Step 4 Clearly, this isn’t enough. The urge to immediately write more code is strong. This critical moment is the final hurdle to overcome, and it is the hardest. Resist the urge! Stop, take a deep breath, and look back at your commented plan. Is there anything on that list that will force you to change the code to fix the glaring issue that you’ve seen? If yes, great! Keep going, it will be fixed soon. If not, you have two options: Improve your current test to have more specific checks
Add another comment to your plan for the missing requirement Step 5 Repeat the process. Write the next test, check that it fails, and then write the minimum code to make it pass. That’s it. Congratulations, you just TDD’ed! It will be worth it, I promise. Thank you for reading. This is the first of my new series, Dev Diaries, where I will be writing about something I’ve done, something I’ve learned, or something that I’ve found interesting that day. As a big advocate of Test-Driven Development (TDD), I have spent a good amount of time wondering why 95% of my conversations about TDD with other engineers go something like this: “Yes, TDD is clearly the right way to build software. But I don’t actually do it.” “Yes, TDD is clearly the right way to build software. But I don’t actually do it.” At this point, the usual reasons and explanations are laid out: “It’s hard to know what tests to write until I have written the code.” “How can I know how the tests should work if I don’t know how the code works?” “It’s hard to know what tests to write until I have written the code.” “It’s hard to know what tests to write until I have written the code.” “How can I know how the tests should work if I don’t know how the code works?” “How can I know how the tests should work if I don’t know how the code works?” It is true that if you are testing something that uses completely unfamiliar technology, you probably don’t know yet how to go about testing it. Most of the time, though, the technology is perfectly familiar. It’s not the tools that are unfamiliar and scary - it’s the product that you are trying to build. tools product that you are trying to build. Enter my ✨One Simple Trick™✨… Forget about the code completely (for now) . All of it. Don’t think about the implementation, and don’t think about the test code either. Forget about the code completely (for now) Instead, just write a plan for how the product should work . Here’s how I do it: just write a plan for how the product should work Step 1 Start by writing simple comments in human language. Write as many as you can think of, with one per requirement, acceptance criteria, scenario, edge case, or error. Here’s an example: // animals.test.ts
// Plan for new API endpoint: GET /animals

// returns a list of animals with the ID and name

// paginated 10 at a time by default

// can change the pagination size

// optionally filters by species type (in the query params)

// returns a 403 error if not authenticated // animals.test.ts
// Plan for new API endpoint: GET /animals

// returns a list of animals with the ID and name

// paginated 10 at a time by default

// can change the pagination size

// optionally filters by species type (in the query params)

// returns a 403 error if not authenticated Of course, the code has to happen at some point. But by starting with comments like this, it removes all of the psychological resistance to the idea of writing tests, allowing you to focus on what you’re trying to build. Step 2 Write the actual tests one by one by converting each comment into an assertion. // animals.test.ts

import { request } from "supertest";
import { app } from "./app";

it('returns a list of animals with the ID and name', async () => {
  const result = await request(app).get('/animals');
  
  result.forEach(animal => {
    expect(animal).toEqual({
      id: expect.any(String),
      name: expect.any(String),
    });
  });
})

// paginated 10 at a time by default

// can change the pagination size

// optionally filters by species type (in the query params)

// returns a 403 error if not authenticated // animals.test.ts

import { request } from "supertest";
import { app } from "./app";

it('returns a list of animals with the ID and name', async () => {
  const result = await request(app).get('/animals');
  
  result.forEach(animal => {
    expect(animal).toEqual({
      id: expect.any(String),
      name: expect.any(String),
    });
  });
})

// paginated 10 at a time by default

// can change the pagination size

// optionally filters by species type (in the query params)

// returns a 403 error if not authenticated It is worth noting that this technique is best paired with the philosophy of Write Tests. Not Too Many. Mostly Integration. While the ‘comments-first’ approach can be applied to unit tests, it is much easier to start with higher-level, more product-focused integration tests. Write Tests. Not Too Many. Mostly Integration. Step 3 Write the bare minimum application code to make the first test pass. For example, to make this first test pass, you could return this hardcoded array from the API endpoint: // animals.ts

res.send([{ id: "foo", name: "bar"}]); // animals.ts

res.send([{ id: "foo", name: "bar"}]); Step 4 Clearly, this isn’t enough. The urge to immediately write more code is strong. This critical moment is the final hurdle to overcome, and it is the hardest. Resist the urge! Stop, take a deep breath, and look back at your commented plan. Is there anything on that list that will force you to change the code to fix the glaring issue that you’ve seen? force you If yes, great! Keep going, it will be fixed soon. If not, you have two options: Improve your current test to have more specific checks Add another comment to your plan for the missing requirement Improve your current test to have more specific checks Add another comment to your plan for the missing requirement Step 5 Repeat the process. Write the next test, check that it fails, and then write the minimum code to make it pass. That’s it. Congratulations, you just TDD’ed! It will be worth it, I promise. Thank you for reading. This is the first of my new series, Dev Diaries, where I will be writing about something I’ve done, something I’ve learned, or something that I’ve found interesting that day.

Dev Diary #1: TDD Is Easy, When You Forget About The Code

How to Test React Components With Jest And React Testing Library

My Testing Journey With Jasmine and Mocha: What I've Learned

Ensuring Quality in BunJs Applications: Testing with Cucumber JS and Keplo

Hacking Backward and Forward-Compatible Application Releases

Africa is the second-largest continent in the world, with almost 20% of the global population and more than 1.46 billion people living there. That’s why the local level of crypto adoption influences global numbers. In terms of crypto regulation, this region still stays in a grey zone. Most nations on this continent haven’t issued any legal framework on virtual currencies. Among 54 UN member states, less than 10 have legal acts on this topic. However, Africa is moving toward the legalization of cryptocurrencies and VASP operations. The region's greatest economies by GDP, Nigeria, and South Africa, already have the following procedures. One more local country with a perspective economy, Kenya, is also working on its own crypto regulation framework. Last, but not least, Namibia and Botswana, South Africa's neighbors and former British colonies have also enacted legislation on this topic. In this article, I’d like to describe countries that stay ahead in crypto regulation. Nevertheless, several African countries still ban crypto like Egypt and Morocco, for example. Central African Republic One more nation in Africa which tried to make cryptocurrencies legal was the Central African Republic (CAR). In April 2022, the National Assembly of CAR declared bitcoin legal tender on the initiative of President Faustin-Archange Touadéra. However, this intention was quickly scrapped. In June 2022, CAR froze crypto legalization under pressure from the Bank of Central African States (BEAC). It also has postponed the ICO of the state cryptocurrency, SangoCoin. And it is still being determined when cryptocurrency payments will become legal in BEAC countries. In my opinion, BEAC agrees on this topic with IMF. South Africa South Africa is the most advanced African state in the field of crypto regulation. The country legalized crypto in 2022. VASP licenses are issued by the local financial regulator (FSCA) under the FAIS ACT, in March 2024 it has approved 59 VASPs to operate in the country. Moreover, in April, the regulator claimed that already 75 VASPs are registered as crypto asset service providers (CASPs). CASP is a special category of FSP (financial service provider) license. Virtual assets have the same legal status as financial assets, making the current framework understandable and predictable. South Africa is currently on the FATF gray list, which may be one reason the regulator introduced a requirement for all cryptocurrency companies in the country to register. South Africa has also allowed crypto payments, and the local tax authority (SARS) and created a regulation framework for crypto taxation. The basis of this approach is that cryptocurrencies in a country are regulated and taxed like other financial assets in accordance with the country's legislation. The capital gain tax rates for virtual assets are the same as for other forms of wealth: 18% for individuals and 21.6% for corporate capital gains tax. Nigeria Along with the Republic of South Africa, Nigeria is the largest economy in Africa. The country has 230 million inhabitants, at least 12 million of whom use crypto. Some sources even count more than 45% of crypto adoption there. This fact makes Nigeria one of the largest crypto markets, comparable to Argentina and even the United States, regarding the number of crypto users. The Central Bank of Nigeria was firmly against legalizing cryptocurrencies and banned crypto transactions for a long time. Moreover, Nigeria was one of the first major economies to implement its CBDC, E-naira. One of the goals of the CBDC issue is to offer residents an alternative to cryptocurrencies and cash in order to control all processes in the economy. However, Nigeria's SEC took a different stance and legalized crypto transactions (exchange and storage) in May 2022. On the other hand, direct crypto payments still have no legal status, and the taxation system for cryptocurrencies is still in its infancy. According to the Finance Act, the capital gains tax (purchase of cryptocurrency) is 10%. Unfortunately, Nigeria has recently worsened its attitude towards cryptocurrencies. The country's authorities have launched an investigation against Binance, and the exchange has officially stopped operating in the country. Other foreign exchanges also have issues with operations in the country Kenya This nation is the third largest economy in Sub-Saharan Africa after South Africa and Nigeria. In December 2022, local regulators issued a joint communique about crypto regulation. Based on the local Capital Markets Bill, this nation should implement a crypto regulation and taxation framework. The type of applicable tax on cryptocurrency gains depends on the time period during which the holder owns virtual assets. Personal income tax (up to 30%) is applied if the period is shorter than 12 months, and capital gain tax (15%) is applied for a longer period. However, a complete VASP regulation framework and licensing procedures are still in progress and will probably be implemented during this year. Other Nations The first country in Africa that adopted crypto regulation before anyone was Mauritius. It issued a legal framework for crypto assets and ICO in December 2021. FSC of Mauritius is the regulator. However, we have no information yet on how this law is enforced and what companies operate in Mauritius. As mentioned above, Namibia and Botswana are other African nations with crypto regulation procedures. Botswana passed the Virtual Assets Act at the beginning of 2022 and has already issued the first crypto licenses. Namibia approved the crypto bill in 2023. Also, Ghana has been working on new regulations for cryptocurrencies since December 2023, and it has created a special task force for this purpose. Despite the formal ban on cryptocurrencies, the Central Bank of Morocco announced its desire to legalize them in 2022. Conclusion South Africa and Mauritius were the first African nations to adopt crypto regulation into their legislation. They were followed by Nigeria, Namibia, and Botswana. A cryptocurrency law in Kenya is also in the process of being passed. Thus, there are only six countries in Africa that have clearer regulations on virtual assets. According to my information, the rest of African nations have no regulation of cryptocurrencies yet. Among the factors holding back the development of crypto regulation in Africa are: the high inflation rate in many countries in the region, the low standard of living, and the general difficulty in developing legislation. Another factor that slows down the legalization of cryptocurrencies in the region is the need to coordinate these laws with international organizations such as the IMF. If you are interested in crypto regulation, you can watch the global crypto regulation ratingshere, and get updates on my Telegram channel. Africa is the second-largest continent in the world, with almost 20% of the global population and more than 1.46 billion people living there. That’s why the local level of crypto adoption influences global numbers. In terms of crypto regulation, this region still stays in a grey zone. Most nations on this continent haven’t issued any legal framework on virtual currencies. Among 54 UN member states, less than 10 have legal acts on this topic. Africa is the second-largest continent in the world, with almost 20% of the global population and more than 1.46 billion people living there. That’s why the local level of crypto adoption influences global numbers. In terms of crypto regulation, this region still stays in a grey zone. Most nations on this continent haven’t issued any legal framework on virtual currencies. Among 54 UN member states, less than 10 have legal acts on this topic. However, Africa is moving toward the legalization of cryptocurrencies and VASP operations. The region's greatest economies by GDP, Nigeria, and South Africa, already have the following procedures. One more local country with a perspective economy, Kenya, is also working on its own crypto regulation framework. Last, but not least, Namibia and Botswana, South Africa's neighbors and former British colonies have also enacted legislation on this topic. In this article, I’d like to describe countries that stay ahead in crypto regulation. Nevertheless, several African countries still ban crypto like Egypt and Morocco, for example. Central African Republic One more nation in Africa which tried to make cryptocurrencies legal was the Central African Republic (CAR). In April 2022, the National Assembly of CAR declared bitcoin legal tender on the initiative of President Faustin-Archange Touadéra. However, this intention was quickly scrapped. declared declared In June 2022, CAR froze crypto legalization under pressure from the Bank of Central African States (BEAC). It also has postponed the ICO of the state cryptocurrency, SangoCoin. And it is still being determined when cryptocurrency payments will become legal in BEAC countries. In my opinion, BEAC agrees on this topic with IMF. froze froze postponed postponed South Africa South Africa is the most advanced African state in the field of crypto regulation. The country legalized crypto in 2022. VASP licenses are issued by the local financial regulator (FSCA) under the FAIS ACT, in March 2024 it has approved 59 VASPs to operate in the country. Moreover, in April, the regulator claimed that already 75 VASPs are registered as crypto asset service providers (CASPs). CASP is a special category of FSP (financial service provider) license. claimed claimed Virtual assets have the same legal status as financial assets, making the current framework understandable and predictable. South Africa is currently on the FATF gray list, which may be one reason the regulator introduced a requirement for all cryptocurrency companies in the country to register. South Africa has also allowed crypto payments, and the local tax authority (SARS) and created a regulation framework for crypto taxation. The basis of this approach is that cryptocurrencies in a country are regulated and taxed like other financial assets in accordance with the country's legislation. The capital gain tax rates for virtual assets are the same as for other forms of wealth: 18% for individuals and 21.6% for corporate capital gains tax. Nigeria Along with the Republic of South Africa, Nigeria is the largest economy in Africa. The country has 230 million inhabitants, at least 12 million of whom use crypto. Some sources even count more than 45% of crypto adoption there. This fact makes Nigeria one of the largest crypto markets, comparable to Argentina and even the United States, regarding the number of crypto users. The Central Bank of Nigeria was firmly against legalizing cryptocurrencies and banned crypto transactions for a long time. Moreover, Nigeria was one of the first major economies to implement its CBDC, E-naira. One of the goals of the CBDC issue is to offer residents an alternative to cryptocurrencies and cash in order to control all processes in the economy. However, Nigeria's SEC took a different stance and legalized crypto transactions (exchange and storage) in May 2022. On the other hand, direct crypto payments still have no legal status, and the taxation system for cryptocurrencies is still in its infancy. According to the Finance Act , the capital gains tax (purchase of cryptocurrency) is 10%. legalized legalized Finance Act Finance Act Unfortunately, Nigeria has recently worsened its attitude towards cryptocurrencies. The country's authorities have launched an investigation against Binance, and the exchange has officially stopped operating in the country. Other foreign exchanges also have issues with operations in the country Kenya This nation is the third largest economy in Sub-Saharan Africa after South Africa and Nigeria. In December 2022, local regulators issued a joint communique about crypto regulation. Based on the local Capital Markets Bill, this nation should implement a crypto regulation and taxation framework. The type of applicable tax on cryptocurrency gains depends on the time period during which the holder owns virtual assets. Personal income tax (up to 30%) is applied if the period is shorter than 12 months, and capital gain tax (15%) is applied for a longer period. However, a complete VASP regulation framework and licensing procedures are still in progress and will probably be implemented during this year. Other Nations The first country in Africa that adopted crypto regulation before anyone was Mauritius. It issued a legal framework for crypto assets and ICO in December 2021. FSC of Mauritius is the regulator. However, we have no information yet on how this law is enforced and what companies operate in Mauritius. legal framework legal framework As mentioned above, Namibia and Botswana are other African nations with crypto regulation procedures. Botswana passed the Virtual Assets Act at the beginning of 2022 and has already issued the first crypto licenses. Namibia approved the crypto bill in 2023. Virtual Assets Act Virtual Assets Act crypto bill crypto bill Also, Ghana has been working on new regulations for cryptocurrencies since December 2023, and it has created a special task force for this purpose. Despite the formal ban on cryptocurrencies, the Central Bank of Morocco announced its desire to legalize them in 2022. special task force special announced announced Conclusion South Africa and Mauritius were the first African nations to adopt crypto regulation into their legislation. They were followed by Nigeria, Namibia, and Botswana. A cryptocurrency law in Kenya is also in the process of being passed. Thus, there are only six countries in Africa that have clearer regulations on virtual assets. According to my information, the rest of African nations have no regulation of cryptocurrencies yet. Among the factors holding back the development of crypto regulation in Africa are: the high inflation rate in many countries in the region, the low standard of living, and the general difficulty in developing legislation. Another factor that slows down the legalization of cryptocurrencies in the region is the need to coordinate these laws with international organizations such as the IMF. If you are interested in crypto regulation, you can watch the global crypto regulation ratings here , and get updates on my Telegram channel . here Telegram channel

Is Africa a Sleeping Crypto Giant?

Writing takes time and effort. Nonetheless, many teams insist on writing them anyway—that’s because of the benefits they bring to a project. unit tests Those benefits are mainly the following: fast feedback—unit tests speed up each iteration of tweaking the code, and those gains can offset at least some time spent on writing tests. Explicit expectations—clear communication of what is expected from the code. Attention to edge cases—good unit tests will provide examples for every edge case that developers can think of. Easy refactoring—an infrastructure to support code evolution in the long term. Let’s see those benefits in more detail: Fast feedback Computers excel at well-defined, repetitive tasks. When you write unit tests, you write code that will verify whether your program does what it was meant to do. With automated verification in place, you can check your code very quickly. In my work, I have 3200+ that run in just under 14 seconds. With such performance, you can retest your whole codebase whenever you save your code. After I got more experience with writing unit tests, I started to feel that the time I saved with the quicker feedback loop returned the time I invested in writing tests. As an example, let’s see updated unit tests for the method introduced in my : translate last article describe("translate", () => {
    it("should translate to supported languages", () => {
      expect(translate("hello", "en")).toEqual("Hello!");
      expect(translate("hello", "pl")).toEqual("Cześć!");
    });

    it("should default to english if language missing", () => {
      expect(translate("hello", "fr")).toEqual("Hello!");
    });

    it("should return the key if translation is missing", () => {
      expect(translate("farewell", "en")).toEqual("farewell");
      expect(translate("farewell", "pl")).toEqual("farewell");
      expect(translate("farewell", "fr")).toEqual("farewell");
    });
  }); Running those tests happens in the blink of an eye: npm run test

> testing-example@1.0.0 test
> jasmine

Randomized with seed 31262
Started
...


Ran 3 of 21 specs
3 specs, 0 failures
Finished in 0.003 seconds
Incomplete: fit() or fdescribe() was found
Randomized with seed 31262 (jasmine --random=true --seed=31262 Explicit expectation Another big advantage of unit tests is stating the expectations explicitly in the code. For example, the data formatting function could do one of the following things when provided with an argument that is not a date: shortDate throw an error, return undefined, or return an empty string. Each of those choices could be a good idea in some places, so it could happen that at some point the exact behavior will be changed. I like adding special cases like this to the test, so the future developer will be reminded that some code can depend on specific behavior when they start changing the API. tests, updated to cover invalid inputs: shortDate describe("shortDate", () => {
    it("should correctly format date", () => {
      const date = new Date("2023-11-02");
      expect(shortDate(date)).toEqual("2023-11-02");
    });

    it("should fail gracefully for no-dates", () => {
      expect(shortDate("")).toEqual("");
      expect(shortDate({})).toEqual("");
      expect(shortDate(1)).toEqual("");
      expect(shortDate()).toEqual("");
    });
  }); Attention to edge cases When I write the implementation for a method, I think about the happy path—everything going as expected. When I write unit tests, I think about everything that can go wrong: some arguments missing, wrong data type, or invalid combinations or arguments—such as dividing 0 by 0. Covering those edge cases makes the tests helpful. A few examples from the demo repository: tests: greet describe("greet", () => {
    it("should greet by name and surname", () => {
      expect(greet("Lorem", "Ipsum")).toEqual("Hello Lorem Ipsum!");
    });

    it("should fail gracefully for missing arguments", () => {
      expect(greet("Lorem")).toEqual("Hello Lorem!");
      expect(greet(undefined, "Ipsum")).toEqual("Hello Ipsum!");
      expect(greet()).toEqual("Hello!");
    });
  }); tests: applyDiscount describe("applyDiscount", () => {
    it("should lower the price accordingly", () => {
      expect(applyDiscount(120, 25)).toEqual(90);
      expect(applyDiscount(8, 50)).toEqual(4);
    });

    it("should manage rounding error", () => {
      expect(applyDiscount(0.1, 40)).toEqual(0.06);
    });

    it("should round results to 0.01", () => {
      expect(applyDiscount(1.11, 25)).toEqual(0.83);
    });

    it("should return NaN for corrupt inputs", () => {
      expect(applyDiscount("", 40)).toBeNaN();
      expect(applyDiscount(40)).toBeNaN();
      expect(applyDiscount()).toBeNaN();
    });

    it("should throw errors on discount percentage outside 0-100 range", () => {
      expect(() => applyDiscount(120, 125)).toThrowError();
      expect(() => applyDiscount(120, -25)).toThrowError();
    });
  }); tests: calculatePrice describe("calculatePrice", () => {
    it("should find a price of many products", () => {
      expect(calculatePrice(4, 3)).toEqual(12);
      expect(calculatePrice(9, 0.5)).toEqual(4.5);
    });

    it("should manage rounding error", () => {
      expect(calculatePrice(0.1, 0.4)).toEqual(0.04);
    });

    it("should round results to 0.01", () => {
      expect(calculatePrice(1.11, 0.5)).toEqual(0.56);
    });

    it("should return NaN for corrupt inputs", () => {
      expect(calculatePrice("", 40)).toBeNaN();
      expect(calculatePrice(40)).toBeNaN();
      expect(calculatePrice()).toBeNaN();
    });
  }); Easy refactoring Once I have all expectations for my code defined, it’s effortless to refactor it. We can safely reorganize the code, improving the quality while maintaining the behavior. Removing friction from code improvements is where we see plenty of long-term benefits from unit testing. When your team is enabled to improve code without the fear that they will break something, they are more likely to try improving things. On the flip side, code that nobody can change without causing some unexpected changes is code that is very difficult and risky to improve. Unit tests are often a barrier that prevents code from entering into a spiral of growing complexity and maintainability. tests are a good example of checking all the behaviors we could care about: ellipsis describe("ellipsis", () => {
    it("should shorten long text at 50 chars", () => {
      expect(
        ellipsis(
          "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque a faucibus massa."
        )
      ).toEqual("Lorem ipsum dolor sit amet, consectetur adipiscing…");
    });

    it("should leave short text unchanged", () => {
      expect(ellipsis("Lorem ipsum sin dolor")).toEqual(
        "Lorem ipsum sin dolor"
      );
    });

    it("should shorten to custom length", () => {
      expect(ellipsis("Lorem ipsum sin dolor", 10)).toEqual("Lorem ipsu…");
    });

    it("should return unchanged non-string argument", () => {
      expect(ellipsis(11)).toEqual(11);
      expect(ellipsis({ lorem: "ipsum" })).toEqual({ lorem: "ipsum" });
    });

    it("should ignore second argument if not number", () => {
      expect(
        ellipsis(
          "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Pellentesque a faucibus massa.",
          {}
        )
      ).toEqual("Lorem ipsum dolor sit amet, consectetur adipiscing…");
    });
  }); Summary The cost/benefit balance will depend a lot on the type of project and the team that works on it. For benefits to show, you need a certain quality of tests—and this can be difficult if nobody on your team has experience with building unit tests. The communication benefits are greater when you have a bigger team—so different people work on the code, or when the projects live a long time—so people need a reminder about their past decisions. Long-term benefits of enabled refactoring will appear only if the project exists long enough such that the need for refactoring has a chance to arise. Also published here.

The Long-Term Benefits of Unit Testing (With Jasmine Examples)

Stories, News & Mentions about TOQUA

Toqua’s Stories on HackerNoon