DEV Community: Janith Disanayake

Simple Steps to Deploy Smart Contract

Janith Disanayake — Fri, 19 Dec 2025 11:43:05 +0000

Tools & Softwares:

VS Code / Cursor
NodeJS (22.10.0 or a later LTS version)

Accounts:

Prerequisites

node --version
npx --version

Overview

.
├── artifacts
│   ├── artifacts.d.ts
│   ├── build-info
│   │   ├── solc-0_8_28-5d5e77a08f43f8366c520176a292b83d65132357.json
│   │   └── solc-0_8_28-5d5e77a08f43f8366c520176a292b83d65132357.output.json
│   └── contracts
│       └── Counter.sol
│           ├── artifacts.d.ts
│           └── Counter.json
├── cache
│   ├── build-info
│   ├── compile-cache.json
│   └── test-artifacts
│       ├── build-info
│       │   ├── solc-0_8_28-58a47ee13fa4eb204cf4c42c730b3f2707de3d94.json
│       │   └── solc-0_8_28-58a47ee13fa4eb204cf4c42c730b3f2707de3d94.output.json
│       └── contracts
│           └── Counter.t.sol
│               └── CounterTest.json
├── contracts
│   ├── Counter.sol
│   └── Counter.t.sol
├── coverage
│   ├── data
│   │   └── solidity
│   │       └── a23a0f3b-7ab8-4f87-8e19-8279db5ae7a4.json
│   └── lcov.info
├── hardhat.config.ts
├── ignition
│   ├── deployments
│   │   ├── chain-1
│   │   │   ├── artifacts
│   │   │   │   └── CounterModule#Counter.json
│   │   │   ├── build-info
│   │   │   │   └── solc-0_8_28-5d5e77a08f43f8366c520176a292b83d65132357.json
│   │   │   └── journal.jsonl
│   │   ├── chain-11155111
│   │   │   ├── artifacts
│   │   │   │   └── CounterModule#Counter.json
│   │   │   ├── build-info
│   │   │   │   └── solc-0_8_28-5d5e77a08f43f8366c520176a292b83d65132357.json
│   │   │   ├── deployed_addresses.json
│   │   │   └── journal.jsonl
│   │   └── chain-31337
│   │       ├── artifacts
│   │       │   └── CounterModule#Counter.json
│   │       ├── build-info
│   │       │   └── solc-0_8_28-5d5e77a08f43f8366c520176a292b83d65132357.json
│   │       ├── deployed_addresses.json
│   │       └── journal.jsonl
│   └── modules
│       └── Counter.ts
├── package-lock.json
├── package.json
├── README.md
├── test
│   └── Counter.ts
└── tsconfig.json

Project creation

mkdir hardhat-tutorial
cd hardhat-tutorial
npx hardhat --init

Writing a smart contract

contracts/Counter.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;

contract Counter {
  uint public x;

  event Increment(uint by);

  function inc() public {
    x += 1; 
    emit Increment(1);
  }

  function incBy(uint by) public {
    require(by > 0, "incBy: increment should be positive");
    x += by;
    emit Increment(by);
  }
}
// Random number to make this contract file unique: 185640209

♾️ Compile the project

npx hardhat build

Test writing

contracts/Couter.t.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;

import { Counter } from "./Counter.sol";

contract CounterTest {
  Counter counter;

  function setUp() public {
    counter = new Counter();
  }

  function test_InitialValueIsZero() public view {
    require(counter.x() == 0, "x should start at 0");
  }

  function test_IncIncreasesByOne() public {
    counter.inc();
    require(counter.x() == 1, "inc should increase x by 1");
  }

  function test_IncByIncreasesByGivenAmount() public {
    counter.incBy(3);
    require(counter.x() == 3, "incBy should increase x by the given amount");
  }
}

🧪 Testing

npx hardhat test
npx hardhat test solidity

Use Hardhat

👷 Install

npm add --save-dev @nomicfoundation/hardhat-toolbox-viem @nomicfoundation/hardhat-ignition viem

➕ Add to hardhat config

hardhat.config.ts

import hardhatToolboxViemPlugin from "@nomicfoundation/hardhat-toolbox-viem";
import { defineConfig } from "hardhat/config";

export default defineConfig({
   plugins: [hardhatToolboxViemPlugin],
  solidity: {
    version: "0.8.28",
  },
});

Writing a test

test/Counter.ts

import assert from "node:assert/strict";
import { describe, it } from "node:test";

import { network } from "hardhat";

describe("Counter", async function () {
  const { viem } = await network.connect();
  const publicClient = await viem.getPublicClient();

  it("The sum of the Increment events should match the current value", async function () {
    const counter = await viem.deployContract("Counter");
    const deploymentBlockNumber = await publicClient.getBlockNumber();

    // run a series of increments
    for (let i = 1n; i <= 10n; i++) {
      await counter.write.incBy([i]);
    }

    const events = await publicClient.getContractEvents({
      address: counter.address,
      abi: counter.abi,
      eventName: "Increment",
      fromBlock: deploymentBlockNumber,
      strict: true,
    });

    // check that the aggregated events match the current value
    let total = 0n;
    for (const event of events) {
      total += event.args.by;
    }

    assert.equal(total, await counter.read.x());
  });
});

🏃‍♂️ Run the test

npx hardhat test nodejs

Deploy locally

ignition/modules/Counter.ts

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";

export default buildModule("CounterModule", (m) => {
  const counter = m.contract("Counter");

  m.call(counter, "incBy", [5n]);

  return { counter };
});

🧪 Try

npx hardhat ignition deploy ignition/modules/Counter.ts

🚀 Run the local network

npx hardhat node

🚀 Deploy Contract locally

npx hardhat ignition deploy ignition/modules/Counter.ts --network localhost

Deploy live

Prerequisites

Create Alchemy Account
Create Meta Mask Account
Install dotenv npm install dotenv

Code

hardhat.config.ts

import hardhatToolboxViemPlugin from "@nomicfoundation/hardhat-toolbox-viem";

import { defineConfig } from "hardhat/config";
import dotenv from "dotenv";

dotenv.config();

export default defineConfig({
  plugins: [hardhatToolboxViemPlugin],
  solidity: {
    version: "0.8.28",
  },
  networks: {
    sepolia: {
      type: "http",
      url: process.env.SEPOLIA_RPC_URL || "",
      accounts: process.env.SEPOLIA_PRIVATE_KEY ? [process.env.SEPOLIA_PRIVATE_KEY] : [],
    },
  },
});

🏃‍♂️ Run

npx hardhat ignition deploy ignition/modules/Counter.ts --network sepolia

Check with you Contract address

https://sepolia.etherscan.io/

What LLM Contains

Janith Disanayake — Sun, 03 Aug 2025 06:26:52 +0000

Downloading a model from Ollama or similar platforms (like Hugging Face, TensorFlow Hub, etc.) gives you access to more than just a file labeled “model.” These packages contain several components that allow the model to be executed, fine-tuned, or embedded in applications.

Let’s break it down into a clear structure, so you can understand, dissect, and even modify the model effectively.

🔹 1) What You Get When You Download a Model

A typical downloaded model (especially from Ollama, Hugging Face, etc.) consists of the following main components:

✅ A. Model Weights (Parameters)

Usually large binary files (e.g., .bin, .pt, .safetensors, .ckpt).

These contain the actual learned values (neurons, weights, biases) from training.

Cannot run the model without this.

Example:

pytorch_model.bin – For PyTorch
ggml-model-q4_0.bin – Quantized weights used in Ollama and llama.cpp

✅ B. Model Architecture / Config File

Defines the structure of the model (number of layers, hidden units, attention heads, etc.).

Often in a .json or .yaml file.

Example:

config.json – Specifies transformer type, vocabulary size, hidden dimensions, etc.

✅ C. Tokenizer Files

Preprocessing logic that turns text into tokens and vice versa.

Includes vocabulary (vocab.json), merges (merges.txt), or tokenizer config.

Example:

tokenizer.json
vocab.txt
merges.txt
tokenizer_config.json

✅ D. Generation Scripts or Runners

Python or binary files that allow you to run the model (with inference loops, prompts, sampling settings, etc.).

Ollama wraps this in a unified runtime using Modelfile and its CLI.

In frameworks like Hugging Face:

run_generation.py
model.py

✅ E. Quantization Information (Optional)

If you're using a quantized model (like from llama.cpp or ggml), there may be metadata about how the weights are compressed.

Affects performance and memory usage.

✅ F. Prompt Templates / System Instructions (Optional in LLMs)

Ollama models often include template prompts (like system, user, assistant roles).

These guide how prompts are injected before inference.

🔹 2) How You Can Divide and Understand It

Component	Purpose	Editable?	Tool Used
Model Weights	Learned knowledge of the model	❌ Not easily editable	Python, `llama.cpp`, Ollama
Config/Architecture	Structure of the neural network	✅ Yes	Text editor
Tokenizer	Converts words into model-readable format	✅ Yes	Hugging Face, `tiktoken`
Prompt Templates	Controls the input prompt formatting	✅ Yes	`Modelfile` in Ollama
Quantization Info	Enables smaller model sizes and faster runs	✅ Yes (with tools)	`llama.cpp`, `ggml`

🔹 3) If You're Using Ollama

When you ollama pull llama3, for example, behind the scenes it downloads a model package that contains:

✅ A quantized binary model file (.bin)

✅ A Modelfile (like a Dockerfile for models)

✅ Prompt format templates (like system, user, etc.)

You can run

ollama show llama3

To inspect the components and configuration.

🔹 4) How to Empower Yourself

Here’s how you can gain deeper control:

Goal	What to Learn
Fine-tune a model	Hugging Face Transformers, PyTorch/TF basics
Quantize for performance	`ggml`, `llama.cpp`, `GPTQ`, `bitsandbytes`
Build custom prompts	Prompt engineering, prompt templates in Ollama
Modify architecture	Learn model config files (`config.json`)
Tokenizer tuning or replacement	`tokenizers` library, vocab files

🔹 Summary Diagram

Downloaded Model

    ┌──────────────────────┐
    │   Model Weights      │  (.bin, .pt, .safetensors)
    └──────────────────────┘
    ┌──────────────────────┐
    │ Config / Architecture│  (config.json)
    └──────────────────────┘
    ┌──────────────────────┐
    │ Tokenizer Files      │  (vocab.json, merges.txt)
    └──────────────────────┘
    ┌──────────────────────┐
    │ Prompt Templates     │  (system, user format)
    └──────────────────────┘
    ┌──────────────────────┐
    │ Runner / Wrapper     │  (Modelfile, Python scripts)
    └──────────────────────┘
    ┌──────────────────────┐
    │ Quantization Metadata│  (quant-info.json, ggml meta)
    └──────────────────────┘

Dumriya Live - AWS Oriented Full Stack Application Infrastructure Overview

Janith Disanayake — Sun, 22 Dec 2024 16:07:06 +0000

Introduction

This project is based on serverless architecture with lambda.
Backend of this application is develop with express js.
Based on MVC architecture with serverless framework
Used MongoDB online server as the database.

Services and Tools

Cloud Services

Lambda – Serverless computing service (AWS)
S3 – Object storage service (AWS)
API Gateway – Managed service for creating and managing APIs (AWS)
CloudFront – Content delivery network (CDN) (AWS)
ECR – Elastic Container Registry for Docker images (AWS)

Database

Atlas MongoDB – Cloud-based database service (MongoDB)

DevOps & CI/CD

Github Actions – CI/CD automation and workflows

Development Tools

NeoVim - Main Editor
Swagger UI – Tool for API documentation and interaction
JWT – Token-based authentication

Domain & DNS Services

Name.com – Domain registration and DNS services
Cloudflare – DNS Services

API

API Architecture

API gateway

To handle the load before reach the lambda and provide protection to the each and every endpoint.

Lambda function

Handing all the api that user sends
Uses container image to create the server
The image can runs on both lambda as well as normal server (You can configure to run on EC2 instance when setting up environment variable)
JavaScript is the programming language
Express JS is the framework
Implements with serverless-http package that helps to run on lambda

Main Endpoints

Schemas

Model	Description
Train	Representation of the train that is going through the track.
TrainInput	Input model for creating or updating train details.
TrainLive	Representation of the live train currently riding. Updated every 5 minutes by a specific Lambda function. Not updated by users or the train directly.
TrainLiveLog	Stores the data received from the train's IoT device.
Station	Representation of a station.
StationInput	Input model for creating or updating station details.
Route	Representation of the route or train track (the pathway of the train).
RouteInput	Input model for creating or updating route details.
Schedule	Representation of the schedule for when the train is set to run on a specific track at a specific time.
ScheduleInput	Input model for creating or updating schedule details.
Device	Sub-model representing the engine's device and the device authorized users have.
GeoLocation	Sub-model used to store location data. This model is shared by the station, route, and other models.

Frontend

Frontend Architecture

SvelteKit Overview

SvelteKit is a modern framework for building web applications using Svelte. It features file-based routing and server-side rendering, optimizing performance and user experience.

Package Configuration

Defines the project's dependencies and scripts:

Scripts: Key commands for development and testing, such as:
- dev: Starts the development server.
- build: Compiles the application for production.
- test: Runs unit and integration tests.
Dependencies:
- devDependencies: Tools needed during development, including SvelteKit, Vite, ESLint, and Prettier.
- dependencies: Essential for production, including dotenv for managing environment variables.

Integration with Dumriya-Live API

The client-side application makes API calls to api.dumriya.live to fetch real-time data, enabling features like live updates, data visualization, or interactions based on the Dumriya-Live service.
The application uses environment variables (e.g., API_URL) to securely store and access the Dumriya-Live API endpoint and other sensitive information.

CICD Pipeline

Pipeline Diagram

CI/CD Workflow: Deploying a Dockerized AWS Lambda Function

Overview

This workflow automates the deployment of a Dockerized AWS Lambda function, triggered on pushes to the prod branch. It utilizes GitHub Actions, AWS services, and Docker to ensure a streamlined, secure, and reliable deployment process.

Key Features

GitHub Actions: Automates the CI/CD pipeline with a structured sequence triggered on prod branch updates.
Secure Credential Management: Leverages GitHub Secrets to securely store AWS credentials.
AWS Elastic Container Registry (ECR): Stores and manages Docker images for the Lambda function.
Docker Integration: Builds, tags, and pushes Docker images, ensuring consistent runtime environments.
AWS CLI: Authenticates and interacts with AWS services, such as logging in to ECR.
Region-Specific Deployment: Operates in the AWS us-east-1 region to ensure environment alignment.

Workflow Breakdown

1. Event Trigger

Condition: Activated by a push to the qa branch.

2. Steps in the Workflow

Checkout Code: Pulls the latest code from the repository using actions/checkout.
Set up Docker Buildx: Configures Docker Buildx for advanced build capabilities.
Configure AWS Credentials: Authenticates with AWS using secrets for AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, and the region us-east-1.
Log in to Amazon ECR: Logs into Amazon Elastic Container Registry (ECR) to allow image pushes.
Build Docker Image: Builds the Docker image with environment variables from secrets (ENVIRONMENT, SECRET_KEY, MONGODB_URI).
Tag Docker Image: Tags the built image as web-api:latest.
Push Docker Image to ECR: Pushes the tagged image to the specified ECR repository.
Update Lambda Function: Updates the AWS Lambda function with the new image from ECR.

Benefits

Automation: Reduces manual intervention by automating key stages like building and deploying Docker images.
Security: Protects sensitive credentials using GitHub Secrets and applies AWS best practices.
Consistency: Docker ensures predictable application behavior across environments.
Scalability: Supports easy scaling and adaptation to different environments or regions.

This workflow integrates essential tools and services to enable secure, fast, and reliable deployment of containerized AWS Lambda functions in production.

CI/CD Workflow: Build and Deploy to S3

Overview

This CI/CD workflow automates the process of building a Node.js project and deploying it to an Amazon S3 bucket. It is triggered by pushes to the prod branch (or a specified branch) and integrates GitHub Actions, AWS S3, and environment variables for a seamless deployment process.

Key Features

GitHub Actions: Automates the build and deployment pipeline with a defined sequence triggered on prod branch updates.
Secure Credential Management: Uses GitHub Secrets to securely store sensitive information, such as API keys and AWS credentials.
Node.js Environment: Sets up and manages the required Node.js runtime and dependencies.
Build Process:
- Utilizes environment variables such as MAP_API_KEY and API_URL during the build stage for dynamic configuration.
- Executes the project’s build script using npm run build.
AWS S3 Integration:
- Uses AWS CLI to sync the built files to the specified S3 bucket.
- Ensures efficient updates by removing outdated files with the --delete flag.

Workflow Breakdown

1. Event Trigger

Activated by a push to the prod branch (customizable for other branches).

2. Steps in the Workflow:

Checkout Code: Pulls the latest code from the repository using actions/checkout.
Set Up Node.js Environment: Configures the specified Node.js version (default is 18).
Install Dependencies: Installs project dependencies using npm install.
Build Project:
- Reads environment variables such as MAP_API_KEY and API_URL from GitHub Secrets.
- Builds the project using the npm run build command.
Deploy to S3:
- Authenticates with AWS using credentials from GitHub Secrets.
- Syncs the built project to the configured S3 bucket, ensuring an up-to-date deployment.

Benefits

Automation: Eliminates manual tasks for building and deploying the application, improving efficiency.
Security: Ensures sensitive credentials and environment variables are managed securely via GitHub Secrets.
Scalability: Easily adaptable to different S3 buckets, environments, or Node.js versions.
Reliability: Ensures consistency by using a defined build process and removing outdated files from S3.

This workflow provides a secure, automated, and efficient solution for building and deploying Node.js projects to Amazon S3, ensuring seamless updates and reliable performance in production.

References

Links for the applications

Repositories

Documents

Special Thanks

Nirangha DH (Lecturer)

Deploy Express JS container image on Lambda AWS

Janith Disanayake — Tue, 24 Sep 2024 22:17:00 +0000

Introdction

If you want to build a application but you don't want to buy and maintain server the best option is Lambda. You still can use .zip file to create a Expressjs Lambda but that is not a best practice to do as a developer. In this scenario you can use Container Image to create a server.

Resources

Steps 📚

Create Express app

1) Create Directory for application

mkdir lambda-express
cd lambda-express

2) Initialization

npm init

3) Install Express

npm install express

4) Install serverless-http

npm install serverless-http

Application implementation

1) app.js file => (lambda-express/app.js)

const express = require('express');
const serverless = require('serverless-http');
const app = express();

app.use(express.json());

app.get('/', (req, res) => {
        console.log("/ endpoint is reached");
        res.send('Hello World!');
});

app.get('/hello', (req, res) => {
        console.log("/ endpoint is reached");
        res.send('Hello from Lambda!');
});

module.exports.handler = serverless(app);

2) package.json => (lambda-express/package.json)

{
  "name": "example",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node app.js"
  },
  "author": "janith",
  "license": "ISC",
  "description": "",
  "dependencies": {
    "express": "^4.19.2",
    "serverless-http": "^3.2.0"
  }
}

3) Check all the npm packages are available or not

npm ls

result

example@1.0.0 /home/janith/TEST/example
├── express@4.19.2
└── serverless-http@3.2.0

Create a docker image

1) Docker file

# Use the official AWS Lambda Node.js base image
FROM amazon/aws-lambda-nodejs

# Copy function code
COPY package*.json ${LAMBDA_TASK_ROOT}
COPY node_modules ${LAMBDA_TASK_ROOT}
COPY app.js ${LAMBDA_TASK_ROOT}
RUN npm install

# Command to run the Lambda function
CMD ["app.handler"]

2) Confirm installation

npm install

3) Build the Image

make sure you are in the same directory that Dockerfile file is located

docker build -t lambda-express:latest .

Upload Image to ECR

1) Create a ECR

ECR is Elastic Container Registory in AWS
go to ECR and create a private repository

2) Upload the Image that you build locally

go inside of the repository
click View push commands

3) Login first

aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 144901196852.dkr.ecr.us-east-1.amazonaws.com

4) Tag the image

you build the image previously no need to build it again if you use another name that different from this repostiry

docker tag lambda-express:latest 144901196852.dkr.ecr.us-east-1.amazonaws.com/lambda-express:latest

5) Push the image into ECR

docker push 144901196852.dkr.ecr.us-east-1.amazonaws.com/lambda-express:latest

Deploy Image on Lambda 🚀

1) Create a Lambda function

2) Select option as Container Image

3) Function Name

4) Container Image URI

Click Browse images
Select your private repository and Image that you created

5) Keep other settings as default and create the function

6) Goto configurations and create a Function URL

7) Make sure to select the Auth type as NONE

Congratulations 🎉 Just now you deployed your app

click your Function URL and enjoy

happy coding !

Deploy a Express JS app in Lambda AWS

Janith Disanayake — Sat, 31 Aug 2024 00:00:32 +0000

Introduction

Lambda is a AWS service that provides the server-less application that is easy to run application without maintaining server. It is not expensive and always free under 1000 000 requests. There is no need to use any other service in lambda you just can deploy with Function URL. In this demonstration I will provide the exact steps that you need to follow in order to deploy this application.

Steps 📚

Create a Node JS server

1) Create Directory for application

mkdir lambda-express
cd lambda-express

2) Initialization

npm init

3) Install Express

npm install express

Implementing application

This is a simple 'Hello World' application here is the code

1) Creating the file

touch index.js

2) Code of the application

const express = require('express')
const serverless = require('serverless-http')
const app = express()
const port = 3003

app.use(express.json());

app.get('/', (req, res) => {
    res.send('Hello World!');
});



if(process.env.ENVIRONMENT === "lambda") {
    module.exports.handler = serverless(app);
} else {
    app.listen(port, () => {
        console.log(`Example app listening on port ${port}`)
    });
}

3) Test it is running on port 3003

node index.js

Deploy on AWS 🚀

1) Create the .zip file

zip -r lambda.zip node_modules index.js package.json

you can use this command to create the zip file or you can download this file -> lambda.zip

2) Create a Lambda function

3) Set Environment Variable

4) Now your App is ready

You can click Function URL and check the applications is working

Considerations ❗❗

This lambda is open to public by Using Public URL
It might lead to a DDOS attach by someone else
If you want you can manage lambda by using AWS API Gateway

Congratulations 🎉 Just now you deployed your app

click your Function URL and enjoy

happy coding !