An Introduction To Blockchain Application Development - Part 1/2

In this post we will get familiar with the architectural approaches that make blockchain application development almost like a walk in the park. We will address five simple, yet efficient software development approaches for blockchain applications. Each of them being supported with code samples and tutorials.

This is an introductory post, that will be followed by separate tutorials and workshops where we will build a fully working blockchain application.

Bootstrapping The Development Environment Setup

1. Our own chain running.
2. The knowledge to launch a local node.
3. Connect to some kind of public test blockchain network that is run and maintained by someone else and out of our control.
4. Knowledge of blockchain mechanics (p2p layer, consensus mechanism, a vast array of developer tools for client/server side).

We all know the sysadmin magic that had to be done in order to get a blockchain node running in the past. As a consequence a lot of developers got turned away by the sheer complexity of the development environment setup or missing cryptographic libraries and implementations. Luckily for all of us, our HERO —  came along. Delivering the promise of seamless and easily customisable blockchain deployment in three simple steps.

ARK Logic: Blockchain Application Development Steps

With ARK’s modular core our distributed-servers/nodes running in the background translate into containers — where you can deploy your own blockchain based applications and you don’t need to worry about consensus protocol or peer-to-peer network mechanics — it’s a protocol thing, just like TCP/IP, well a lot more complex; but it’s there running in the background, delivering security, trust and immutability — delivering the promise of blockchain.

Distributed Blockchain Applications in General

This gives us the power to create agnostic blockchain applications, that can be run within any blockchain based on ARK Core technology. By developing applications on our plug-able core technology developers can build blockchain agnostic applications, target bigger audiences and provide cross-chain compatible solutions.

This introduces and further strengthens the role of the ARK Ecosystem, by bringing in new interchain monetization services allowing businesses to fully exploit and research new crypto driven business models. Our blockchain application development approach is closing the gap between traditional development practices by bridging the concept of software libraries and blockchain development.

ARK Logic: Basic Overview of dapp Structure

• Blockchain application is an abbreviated form for decentralized application-dapp, that can already be deployed as a blockchain module.
• A dapp has its backend code running on a decentralized peer-to-peer network (ARK). Contrast this with an app where the backend code is running on centralized servers.
• A dapp can have frontend code and user interfaces written in any language (just like a normal application) that can make calls to its backend via simple API calls, or by using any kind of protocol that was implemented as a communication channel in the dApp module implementation (see point 1).
• A dapp can also host its frontend on a decentralized network, in this case, the language limitations must be compatible with our core-technology language landscape and our blockchain network servers as an application provider.
• A dapp can implement only micro services, allowing modular design, easier bug-fixing, and upgrading as a normal software application.

Ok, so what now? Now we can deploy a module, like in most web applications — but where is “the blockchain/the ledger” and how do we use it?

Don’t worry, we got you covered with ARK Logic — Enabling your application to run in a modular fashion on the distributed network. Your application life cycle is maintained by our Core and is inherited by the overall life cycle of a blockchain node. A strong benefit of plug-able applications/modules is having access to the blockchain mechanics in a very simple and developer friendly way. Blockchain interaction is something we take very seriously, and we deliver this via the following approaches.

ARK Logic: Best Practices

• How to interact with the blockchain state.
• How to interact with the blockchain database.
• Learn to use events and react to state changes.
• Add new API endpoints via customisable HTTP server running within core nodes.
• Pack your blockchain application as a module and distribute it.

1. Interacting with the blockchain state

import { app } from "@arkecosystem/core-container";

const blockchain = app.resolvePlugin("blockchain");

async function callBlockchainMethods() {
  // Check if the blockchain is fully synced
  blockchain.isSynced();

  // Get the last block we've received
  blockchain.getLastBlock();

  // Get the height of the last block we've received
  blockchain.getLastHeight();

  // Get the last block we've downloaded
  blockchain.getLastDownloadedBlock();

  // Get a list of events the blockchain emits
  blockchain.getEvents();
}

callBlockchainMethods();

Full Tutorial:

2. Interacting with the database

import { app } from "@arkecosystem/core-container";

const database = app.resolvePlugin("database");

async function callDatabaseMethods() {
  // Get a block from the database by its id
  await database.getBlock("some block id");

  // Skip the first 100 blocks, grab the next 100
  await database.getBlocks(100, 100);

  // Grab blocks at height 1, 5 and 10
  await database.getBlocksByHeight([1, 5, 10]);

  // Get all blocks that have been forged in round 10
  await database.getBlocksForRound(10);

  // Get the last block we've received
  await database.getLastBlock();

  // Get the last 10 blocks we've received
  await database.getRecentBlockIds();

  // Get a transaction from the database by its id
  await database.getTransaction("some transaction id");
}

callDatabaseMethods();

Full Tutorial:

3. Use events to listen and react to changes

import { app } from "@arkecosystem/core-container";
import { EventEmitter, Logger } from "@arkecosystem/core-interfaces";

const logger = app.resolvePlugin<Logger.ILogger>("logger");
const emitter = app.resolvePlugin<EventEmitter.EventEmitter>("event-emitter");

emitter.on("forger.missing", delegate => {
  // This will be a wallet object that contains information like the address, username, public key, votes, etc.
  logger.warn(`${delegate.username} just missed a block.`);

  // Here we could for example send a slack notification that we just missed a block
});

Full Tutorial:

4. Add new API endpoints via customisable HTTP server running within core nodes

import { createServer, mountServer } from "@arkecosystem/core-http-utils";

export async function startServer(config) {
  const server = await createServer({
    host: config.host,
    port: config.port
  });

  server.route({
    method: "GET",
    path: "/",
    handler(request, h) {
      return "Hello World";
    }
  });

  return mountServer("My HTTP Server", server);
}

startServer({ host: "localhost", port: 8000 });

Full Tutorial:

5. Pack and distribute your blockchain application as a module

import { Container } from "@arkecosystem/core-interfaces";
import { LogManager } from "@arkecosystem/core-logger";
import { defaults } from "./defaults";
import { PinoLogger } from "./driver";

export const plugin: Container.PluginDescriptor = {
  pkg: require("../package.json"),
  defaults,
  alias: "logger",
  extends: "@arkecosystem/core-logger",
  async register(container: Container.IContainer, options) {
    const logManager: LogManager = container.resolvePlugin("log-manager");
    await logManager.makeDriver(new PinoLogger(options));

    return logManager.driver();
  }
};

Full Tutorial:

Next Steps: Part 2

Part two of this Blockchain Application Development series will cover introduction to developing custom transaction types with our Generic Transaction Interface (GTI). The basic premise of GTI is to provide an easy way to implement and include new transaction types in your blockchain without the need to modify more complex parts of the Core. It can be as simple as including pre-defined templates depending on the use case of the blockchain or re-using already present types and modify their parameters to introduce new ones. Developing custom transaction types enables you to add your own custom logic and data, validate it via existing consensus mechanisms and store it on-chain.

Read our new 2019 , Follow us on social media ( | | ), join our community ( | ) and stay tuned to our blog on and on .