DEV Community: Mark Santiago

Agile Project Management in Software Development Teams

Mark Santiago — Thu, 23 Oct 2025 07:26:49 +0000

Introduction

In today’s rapidly evolving software development landscape, traditional project management models often struggle to keep pace with shifting priorities, emerging technologies, and increasingly dynamic stakeholder expectations. Agile project management has emerged as a powerful alternative—offering flexibility, collaboration, and continuous improvement as core values.

Agile’s strength lies in its adaptability. In a world where market conditions, technologies, and customer needs can pivot overnight, Agile allows development teams to respond effectively without losing momentum. By emphasizing iterative progress, stakeholder engagement, and team collaboration, Agile ensures that software is not only built faster but is also more aligned with user needs and business goals.

This article explores how Agile project management enhances performance within medium-sized software development teams. We will examine its methodologies, practical applications, and the specific advantages it offers teams that must remain adaptive, efficient, and forward-thinking in an increasingly complex software environment.

Understanding Agile in Software Development Project Management

Agile project management originated in the software engineering domain as a response to rigid, documentation-heavy processes that often hindered innovation. Instead of large, inflexible project plans, Agile focuses on developing software in small, manageable increments—each iteration producing a functional version of the product.

At its core, Agile promotes continuous improvement, transparency, and collaboration between all stakeholders. It encourages teams to embrace change as a natural and beneficial part of the development process. For medium-sized teams, this approach is particularly valuable: it creates an operational rhythm that balances flexibility with control, allowing teams to pivot quickly while maintaining a clear direction.

Whether the goal is to build a new application, upgrade existing infrastructure, or sustain legacy systems, Agile provides a framework that helps teams manage complexity and uncertainty with confidence.

Agile Methodologies in Practice
Agile is a philosophy supported by several methodologies, each offering unique benefits. The two most prevalent in software development are Scrum and Kanban.

Scrum structures work into fixed-length iterations known as sprints, typically lasting one to four weeks. During each sprint, the team commits to completing specific deliverables. Regular touchpoints—such as daily stand-ups, sprint planning meetings, and retrospectives—ensure alignment, continuous learning, and accountability. Scrum is an excellent choice for teams that prefer a well-defined process and predictable delivery cycles.

Kanban, by contrast, emphasizes flexibility and visual workflow management. Through a Kanban board that displays each stage of work (e.g., to-do, in progress, done), teams gain immediate insight into task status, enabling them to identify bottlenecks and optimize throughput. Kanban suits environments that require constant prioritization and a balanced flow of new and ongoing work.

Both methodologies share core Agile principles: visibility, communication, and adaptability. When applied effectively, they empower medium-sized teams to balance multiple deliverables, adjust swiftly to evolving requirements, and maintain project stability.

The Benefits of Agile Project Management for Medium-Sized Teams

Medium-sized software development teams—often managing several concurrent projects—stand to benefit greatly from Agile’s iterative, feedback-driven approach. Its practical advantages are numerous:

Enhanced Software Quality
Agile promotes continuous testing, integration, and review, enabling teams to identify and fix issues early. Regular quality assurance efforts throughout the development cycle ensure that the final product meets usability, security, and performance standards before release. This proactive focus on quality not only prevents costly rework but strengthens user confidence in the final product.
Greater Flexibility and Responsiveness
Because Agile welcomes change, teams can adjust priorities and scope even late in development. This responsiveness is critical for medium-sized teams working in dynamic industries, where client feedback and emerging technologies frequently reshape project goals. Agile provides a structured way to adapt—without derailing timelines or outcomes.
Improved Team Collaboration
Agile fosters open communication and shared accountability. Through daily interactions, sprint reviews, and retrospectives, developers, designers, testers, and stakeholders remain connected to a common vision. This transparency strengthens team cohesion, promotes diversity of thought, and accelerates problem-solving.
Predictable Delivery and Transparency
Agile’s time-boxed sprints and clear backlog prioritization make progress measurable and predictable. Teams and stakeholders gain visibility into what is being developed, when it will be delivered, and how changes affect overall timelines. This consistency builds trust and makes long-term planning more reliable.
Effective Risk Mitigation
By delivering in small increments, Agile greatly reduces project risk. Early feedback reveals potential flaws before they scale, and regular retrospectives allow continuous process improvements. For medium-sized teams with limited resources, this adaptive risk control is essential for maintaining stability and ensuring successful project outcomes.

Agile’s Role in Medium-Sized Teams: Bridging Strategy and Execution

Medium-sized teams often fall between the high agility of small startups and the structural complexity of large organizations. They face significant challenges—balancing innovation with governance, and adaptability with coordination. Agile provides the connective tissue between strategic vision and technical execution.

To maximize its impact, Agile must be tailored to team dynamics. Scaled frameworks such as SAFe (Scaled Agile Framework) or LeSS (Large-Scale Scrum) can help align multiple teams working toward shared objectives. Meanwhile, clear role definitions—Product Owner, Scrum Master, and Development Team—ensure accountability and prevent overlaps.

In practice, this alignment allows medium-sized teams to maintain the speed and flexibility of smaller units while operating with the structure and discipline needed to handle complex, multi-stakeholder projects.

Conclusion

In the modern software landscape, agility is not a luxury but a necessity. For medium-sized development teams, Agile project management provides a practical, human-centered framework that harmonizes innovation, quality, and adaptability. It empowers teams to collaborate effectively, respond to change with confidence, and deliver solutions that meet both customer needs and business goals.

Whether building new products or enhancing existing ones, Agile transforms the way teams approach software development—replacing rigidity with responsiveness, and uncertainty with continuous improvement. By embracing Agile principles, medium-sized software teams can cultivate a sustainable culture of excellence, where productivity, collaboration, and customer value thrive together.

Automated Server Provisioning: A DevOps Framework for Enterprise Scale

Mark Santiago — Wed, 08 Oct 2025 18:28:29 +0000

🧭 Business Goal

Reduce server provisioning time and configuration errors by 75% for enterprise IT teams — enabling rapid scaling of cloud infrastructure while maintaining compliance, consistency, and reliability across more than 10,000 nodes.

🔍 Problem Identification & Scope

Pain Points

Manual provisioning required over 2 hours per machine (OS install, package setup, security configuration).
Configuration drift led to production outages (e.g., mismatched firewall rules).
Audit failures occurred due to undocumented or manual changes.

Objective

Automate server provisioning and enforce standardized configurations using version-controlled YAML playbooks, ensuring repeatable, compliant infrastructure across all environments.

⚙️ Technical Implementation Phases

Phase 1: Configuration Standardization

YAML Template Design

Configurations were modularized into reusable roles for maintainability.

# web-server.yml
roles:
  - common:  
      packages: [nginx, nodejs]  
      firewall:  
        ports: [80, 443]
  - security:  
      users:
        - name: admin  
          sudo: true

✅ Validation

Schema checks via yamllint and custom Python scripts ensured structural integrity of YAML playbooks.

🗂️ Version Control

infra-configs: Main repository for YAML playbooks.
env-specific branches: Separate branches for dev, stage, and prod environments.
- Example: The dev branch allows SSH access from a wider range of IPs for testing.

⚙️ Phase 2: Ansible Automation Development

Playbook Design

Idempotent Tasks:

Ensured repeatable and predictable execution for:

Installing packages
Managing users
Deploying TLS certificates

Modular Roles:

Example: A logging role deployed Fluentd and integrated with AWS CloudWatch.

Error Handling:

Retries for transient failures (e.g., package repository timeouts).
Slack notifications for critical task failures.

Dynamic Inventory

AWS EC2 Integration: Automatically discovered instances via tags (e.g., env:prod).
Custom On-Prem Mapping: Python scripts mapped YAML configurations to local IP ranges.

🚀 Phase 3: CI/CD Pipeline Integration

Jenkins Workflow

Triggers:

Git webhooks on main branch commits
Scheduled daily compliance runs

Pipeline Stages:

Lint YAML files
Dry-run Ansible playbooks
Deploy to dev and stage servers
Manual approval gate for prod

Rollback Mechanism:

If a production deployment fails, Jenkins automatically triggers a Git revert and reapplies the last stable configuration.

🧩 Phase 4: Deployment & Validation

Target Environments

Cloud (AWS/GCP): Auto-scaling groups execute Ansible during instance launch.
On-Prem: PXE boot + Kickstart files trigger Ansible post-OS installation.

Compliance Checks

InSpec was used to validate post-deployment configurations.

Example:

describe port(22) do  
  its('addresses') { should include '10.0.0.0/8' }  
end

This ensured that all deployed servers adhered to defined security and compliance policies.

📈 Phase 5: Monitoring & Reporting

Dashboards

Grafana: Visualized server setup time and playbook success rates.
Splunk: Audited Ansible logs to detect unauthorized or manual changes.

Alerting

Prometheus: Triggered alerts when configuration drift was detected (e.g., unexpected package versions).

🧰 Tech Stack

Category	Tools
Automation	Ansible, Python
CI/CD	Jenkins, Git
Monitoring	Prometheus, Grafana, InSpec
Cloud	AWS EC2, CloudWatch

📊 Results & Impact

Metric	Manual Process	Automated Tool
Setup Time/Server	2.3 hours	0.5 hours (-78%)
Configuration Errors	12% of servers	0.8%
Audit Pass Rate	65%	98%

Cost Savings: $420K/year in reduced labor for a 5,000-server fleet.
Scalability: Deployed 1,000+ identical development servers in 8 hours during a cloud migration.

💡 Lessons Learned

Idempotency Matters

Every Ansible task must be repeatable without unintended side effects (e.g., appending to files multiple times).

Git Hygiene

Enforced pull request reviews for all YAML changes to protect production stability.

Cultural Adoption

Empowering teams to own playbooks fostered accountability and faster iteration cycles.

How to Use ChatGPT to Build AI Voice Agents Effectively

Mark Santiago — Wed, 08 Oct 2025 16:58:02 +0000

AI voice agent platforms are evolving at lightning speed. While ChatGPT can be an incredibly powerful assistant during development, relying solely on it can sometimes lead to outdated or incorrect implementations.

Following inaccurate or stale information can be frustrating and time-consuming.

This guide provides practical tips and best practices for using ChatGPT to build reliable AI voice agents, ensuring accuracy, efficiency, and alignment with the latest documentation.

Scope

AI voice agent development is a fast-moving field. ChatGPT can serve as a co-developer that helps design conversation logic, debug integrations, and optimize prompts — but it’s not a replacement for official documentation.

This article outlines how to strategically use ChatGPT to assist with each phase of the voice agent lifecycle while avoiding pitfalls caused by outdated information.

Background

A typical AI voice agent lifecycle includes three main stages:

Create
Test
Deploy

Among these, the Create phase is where ChatGPT is most useful — helping design the agent’s behavior, conversation flow, and integrations with backend systems.

Core Components of AI Voice Agents

Building a successful AI voice agent involves several interconnected parts:

Conversation Flow
- Prompt Writing (supported by all platforms)
- Conversational Pathways (natively supported by tools like Bland and Retell)
Function Calling
- In-call Behavior
- Post-call Analysis
Call Transfer
Settings Configuration

(e.g., backchannel setup, fallback responses, or environment settings)

Key Challenges

Developers often face a few recurring issues when building AI voice agents:

1. Fragmented Workflows

Integrating multiple systems — prompts, flows, and automation — into a cohesive pipeline can be tricky, especially when AI outputs aren’t deterministic.

2. Testing Frustrations

AI models may produce slightly different responses each time, making it hard to debug or replicate issues consistently.

3. Keeping Up With Platform Changes

AI voice platforms like Bland and Retell evolve quickly. The most common frustration is when ChatGPT references outdated API docs or schema formats.

Important Tips for Using ChatGPT Effectively

ChatGPT can be your best assistant for idea generation, flow design, and debugging, but you must pair it with official platform documentation for accuracy.

1. Conversation Flow Design

There are two main approaches to designing AI voice agent conversations:

(1) Prompt Writing

ChatGPT is excellent at helping you draft and refine prompts.

Start by outlining the main conversation goals or call structure. Then, paste that into ChatGPT and ask it to:

Rewrite the prompt naturally and clearly
Add context awareness and user intent handling
Include fallback or escalation phrases

Once finalized, copy the prompt directly into your AI voice platform.

✅ Tip: This method works best for single-prompt or light-flow agents.

(2) Conversation Flow Mapping

For more complex, multi-turn conversations, platforms like Bland and Retell allow you to define structured conversation flows.

Since these formats change often, always provide ChatGPT with the latest documentation URL and say:

“Follow the latest Bland/Retell conversation flow format to build or fix this section.”

This ensures ChatGPT references the most recent syntax and conventions.

2. Function Calling and Integrations

Function calling connects your agent to external systems or automations (e.g., N8N, Make, or custom webhooks).

There are two layers here:

Voice Agent Setup (trigger functions during calls)
Automation Platform Setup (handle webhooks or API responses)

Best Practice: Test with cURL

Before connecting automations, test your webhook manually:

curl -X POST https://your-automation-url.com/webhook -d '{"message": "test"}'

You can ask ChatGPT to generate the correct curl command for your use case.
This helps you debug integration errors more precisely before embedding the function inside your voice agent.

3. Call Transfer

Call transfer logic is usually configured via the platform’s dashboard.
ChatGPT can still assist by:

Explaining the transfer setup process
Writing user-facing transition prompts
Troubleshooting SIP or API call routing issues

By referencing documentation directly, ChatGPT can walk you through the steps for your specific platform.

4. Settings Configuration

For advanced configurations such as backchanneling, fallbacks, or environment tuning, ChatGPT can:

Generate configuration templates
Suggest error-handling patterns
Validate setup instructions from documentation

When asking for help, specify your platform and say:

“Please reference the latest documentation for [platform name] to configure [feature].”

Conclusion

ChatGPT is a powerful co-developer in building AI voice agents, particularly during the design and setup phases.
However, its value depends on how strategically it’s used.

Key Takeaways

Combine ChatGPT’s reasoning skills with official documentation.
Use it for prompt design, conversation flow planning, and integration testing.
Validate all configurations (e.g., webhooks, APIs) manually before deployment.

By following these principles, you can leverage ChatGPT not just as a chatbot — but as a creative, technical accelerator that helps you build smarter, more human-like AI voice agents faster.

Required Skills to Master as a Project Manager

Mark Santiago — Tue, 16 Sep 2025 18:00:30 +0000

After years of managing projects across different industries and team sizes, I've learned that successful project management isn't just about following a methodology or using the right tools. It's about developing a comprehensive skill set that combines technical expertise, leadership capabilities, and emotional intelligence. Based on extensive research and real-world experience, here are the essential skills every project manager needs to master.

The Foundation: Core Leadership Skills

Strategic Leadership

The most effective project managers I've worked with don't just execute plans—they think strategically. They understand how their project fits into the bigger business picture and can communicate that vision to their teams. This means being able to translate high-level business objectives into actionable project goals and ensuring everyone understands the "why" behind their work.

Communication Excellence

Let's be honest—project managers spend about 90% of their time communicating. Whether it's running stakeholder meetings, writing status updates, or having difficult conversations about scope creep, your ability to communicate clearly and effectively can make or break a project. I've seen too many technically brilliant projects fail because of poor communication.

The key is learning to speak the language of different stakeholders. When talking to executives, focus on business impact and ROI. With technical teams, dive into the details and constraints. With clients, emphasize value and outcomes. It's not about dumbing things down—it's about meeting people where they are.

Team Leadership and Mentoring

Great project managers don't just manage tasks; they develop people. I've found that teams perform better when they feel supported, challenged, and valued. This means taking time to understand each team member's strengths, providing constructive feedback, and creating opportunities for growth.

The best project managers I know act as mentors, sharing their knowledge and experience while helping team members develop their own project management skills. This investment in people pays dividends in project success and team morale.

The Technical Core: Project Management Fundamentals

Project Planning and Scoping

This is where many projects go wrong from the start. Effective project planning isn't just about creating a timeline—it's about understanding the full scope, identifying dependencies, and setting realistic expectations. I've learned that spending extra time upfront on planning saves countless hours of rework later.

A solid project plan should include clear objectives, success metrics, stakeholder roles, budget constraints, key milestones, and a communication strategy. But here's the thing—your plan is a living document. The ability to adapt and adjust while maintaining project integrity is crucial.

Risk Management

Every project has risks, and the best project managers are those who can anticipate and mitigate them before they become problems. This isn't about being pessimistic—it's about being prepared. I've developed a habit of asking "What could go wrong?" early and often, and then creating contingency plans.

The most common risks I've encountered include scope creep, resource constraints, timeline delays, and stakeholder misalignment. Having mitigation strategies ready for these scenarios can mean the difference between project success and failure.

Agile and Hybrid Methodologies

The project management landscape has evolved significantly. While traditional waterfall approaches still have their place, most organizations now require project managers who can work with Agile methodologies and hybrid approaches. This flexibility allows teams to respond quickly to changes while maintaining structure and accountability.

I've found that the most successful project managers understand when to apply different methodologies based on project type, team dynamics, and organizational culture. It's not about being dogmatic about one approach—it's about choosing the right tool for the job.

The Human Element: Soft Skills That Matter

Stakeholder Engagement

Managing stakeholders is an art form. You're dealing with people who have different priorities, communication styles, and levels of project involvement. The key is understanding what each stakeholder needs and how to keep them engaged throughout the project lifecycle.

I've learned that stakeholder management isn't just about keeping people informed—it's about building relationships, managing expectations, and sometimes having difficult conversations about trade-offs. The ability to navigate these relationships while keeping the project on track is invaluable.

Problem Solving and Critical Thinking

Projects rarely go exactly as planned, and the ability to think critically and solve problems quickly is essential. This means analyzing situations objectively, considering multiple solutions, and making decisions based on data rather than emotions.

I've found that the best problem solvers are those who can step back from the immediate issue and see the bigger picture. They ask the right questions, gather relevant information, and consider the long-term implications of their decisions.

Adaptability and Change Management

Change is constant in project management. Requirements shift, priorities change, and unexpected challenges arise. The most successful project managers are those who can adapt quickly while maintaining project momentum.

This also includes managing organizational change. When implementing new processes or tools, project managers need to help their teams transition smoothly. This requires patience, clear communication, and a focus on the benefits of change.

The Technical Toolkit: Tools and Technologies

Project Management Software Proficiency

Modern project management tools have evolved significantly from the complex systems of the past. Today's tools are designed to be intuitive and flexible, but they still require time to master. Whether you're using Asana, Microsoft Project, Jira, or another platform, understanding how to leverage these tools effectively can significantly improve your project outcomes.

Data Analysis and Reporting

Project managers need to be comfortable with data. This includes tracking project metrics, analyzing trends, and creating meaningful reports for stakeholders. The ability to translate raw data into actionable insights is crucial for project success and continuous improvement.

Budget and Cost Management

Financial acumen is often overlooked in project management, but it's essential. Understanding how to create realistic budgets, track expenses, and manage costs throughout the project lifecycle can mean the difference between project success and failure.

The Integration: Bringing It All Together

Time Management and Organization

With multiple projects, stakeholders, and deadlines to manage, organization is critical. This isn't just about keeping your own tasks organized—it's about creating systems that help your entire team stay focused and productive.

I've found that the most effective project managers are those who can prioritize effectively, delegate appropriately, and maintain visibility into all aspects of their projects. This requires both personal discipline and the right tools and processes.

Customer Service Orientation

Even if you're not working directly with external customers, every project has stakeholders who need to be satisfied. This means approaching each project from the perspective of meeting stakeholder needs and delivering value.

The best project managers I know are those who can balance competing demands while keeping the end user or customer in mind. They understand that project success isn't just about meeting technical requirements—it's about delivering something that truly serves its intended purpose.

Continuous Development: The Path Forward

Mastering these skills isn't a one-time achievement—it's an ongoing process. The project management field continues to evolve, with new methodologies, tools, and best practices emerging regularly. The most successful project managers are those who commit to continuous learning and improvement.

This might mean attending industry conferences, pursuing certifications, joining professional associations, or simply seeking out new challenges and experiences. The key is maintaining a growth mindset and being open to new approaches and ideas.

Conclusion

Project management is a complex discipline that requires a diverse skill set. While technical knowledge and tool proficiency are important, the most successful project managers are those who can combine these capabilities with strong leadership, communication, and interpersonal skills.

The good news is that these skills can be developed over time. Start by focusing on the areas where you feel least confident, seek out opportunities for hands-on experience, and don't be afraid to learn from both successes and failures. Remember, every project is an opportunity to grow and improve your skills.

The demand for skilled project managers continues to grow, and organizations are looking for professionals who can bring both technical expertise and leadership capabilities to their projects. By developing these essential skills, you'll not only improve your project outcomes but also advance your career in this dynamic and rewarding field.

Revenue Sharing Model: A Powerful Marketing Strategy for Token Presales

Mark Santiago — Sat, 26 Jul 2025 16:16:11 +0000

Introduction

Launching a successful token presale is not just about having a great product or tokenomics—it’s also about building momentum, trust, and community engagement. One of the most effective ways to achieve this is by leveraging a revenue sharing model as part of your presale marketing strategy. This approach incentivizes community members, influencers, and promoters to actively participate in and promote your presale, creating a win-win scenario for all parties involved.

What is a Revenue Sharing Model in Presales?

A revenue sharing model in the context of a token presale is a system where a portion of the funds raised (or tokens sold) is distributed as rewards to promoters or referrers who help bring in new investors. This model transforms your community into an active marketing force, aligning their interests with the success of your presale.

How It Works

Promoter Registration: Community members or influencers register as promoters and receive unique referral codes or links.
Referral Tracking: When new investors participate in the presale using a promoter’s code, the system tracks these referrals.
Reward Distribution: After the presale round ends, a predefined percentage of the raised funds (in stablecoins or tokens) is distributed to promoters based on the contributions of their referred users.
Transparency: All transactions and reward calculations are handled by smart contracts, ensuring fairness and transparency.

Why Use Revenue Sharing for Presale Marketing?

1. Incentivized Word-of-Mouth

People are more likely to promote your project if they have a direct financial incentive. Revenue sharing turns every promoter into a stakeholder, motivating them to reach out to their networks and communities.

2. Network Effects

As more promoters join and share your presale, your reach grows exponentially. This organic growth is often more effective and authentic than paid advertising.

3. Community Engagement

Rewarding promoters fosters a sense of ownership and loyalty. Engaged community members are more likely to support your project long-term, not just during the presale.

4. Cost-Effective Marketing

Instead of spending large sums on traditional marketing, you only pay for actual results—i.e., successful referrals that lead to investments.

5. Transparency and Trust

Smart contract-based revenue sharing ensures that rewards are distributed fairly and automatically, building trust among participants.

Key Components of a Revenue Sharing Presale

While implementations may vary, a typical revenue sharing presale includes:

Promoter Registration: A process for users to sign up as promoters and receive unique codes.
Referral Tracking: Mechanisms to track which investors used which promoter’s code.
Reward Calculation: Logic to determine the share of revenue each promoter earns, often as a percentage of the referred investment.
Reward Claiming: A transparent, on-chain process for promoters to claim their rewards after the presale round ends.
Bonus for Referred Users: Optionally, referred users may also receive a bonus, further incentivizing participation.

Example Workflow

+-------------------------+
| 1. Project Launches     |
|    Presale              |
+-----------+-------------+
            |
            v
+-------------------------+
| 2. Promoters Register   |
|    & Get Referral Codes |
+-----------+-------------+
            |
            v
+-------------------------+
| 3. Promoters Share      |
|    Codes with Community |
+-----------+-------------+
            |
            v
+-------------------------+
| 4. Investors Join       |
|    Presale Using Codes  |
+-----------+-------------+
            |
            v
+-------------------------+
| 5. Smart Contract       |
|    Tracks Referrals     |
+-----------+-------------+
            |
            v
+-------------------------+
| 6. Presale Ends         |
+-----------+-------------+
            |
            v
+-------------------------+
| 7. Promoters Claim      |
|    Revenue Share        |
+-----------+-------------+
            |
            v
+-------------------------+
| 8. Referred Users       |
|    Claim Bonuses        |
|    (Optional)           |
+-------------------------+

Best Practices

Set Clear Rules: Define the percentage of revenue shared, eligibility, and claiming process upfront.
Prevent Abuse: Implement checks to prevent self-referrals or circular referrals.
Promote Transparency: Make referral and reward data publicly viewable (e.g., via a dashboard).
Engage Promoters: Provide marketing materials and support to help promoters succeed.

Conclusion

A revenue sharing model is a powerful, community-driven marketing strategy for token presales. By aligning the interests of your project and its supporters, you can amplify your reach, build trust, and drive greater participation in your presale. As the blockchain space becomes more competitive, leveraging such innovative strategies can make the difference between a good presale and a great one.

Note.

If you wanna implement this revenue sharing model in your token presale, please contact to Mark Santiago and check the github repos

Thanks.
Happy Coding.

How to write solana wallet tracking telegram bot

Mark Santiago — Sat, 01 Mar 2025 14:11:03 +0000

A comprehensive guide to building a professional Solana wallet tracking system that monitors transactions and delivers real-time notifications through Telegram.

Introduction

In the fast-moving world of Solana trading, staying informed about wallet activities is crucial. This guide will walk you through creating a sophisticated wallet tracking bot that monitors transactions and sends detailed notifications via Telegram.

System Architecture

The system consists of three main components:

Helius RPC for transaction monitoring
MongoDB for data storage
Telegram Bot for notifications

Step-by-Step Guide

1. Setting Up Your Telegram Bot

First, we'll create and configure your Telegram bot for notifications.

Creating your own Telegram bot

Open Telegram and search for the @botfather.
Send /newbot command
Name your bot (Example: "super_wallet_tracking_bot")
Save your bot token

Configuring Chat IDs

Now we named our bot and get bot token, we need to get our chat ID.

To get your chat ID:

Add your bot to your channel
Send a message
Access: https://api.telegram.org/bot/getUpdates
Extract the chat_id from the response

Or you can use this script to get your chat ID:

import TelegramBot from "node-telegram-bot-api";
import dotenv from "dotenv";

dotenv.config();

const TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN!;

const bot = new TelegramBot(TELEGRAM_BOT_TOKEN, { polling: true });

bot.on("message", (msg) => {
  console.log("New chat ID:", msg.chat.id);

  TELEGRAM_CHAT_ID = msg.chat.id.toString();
});

Environment Configuration

Add these to your .env file:

TELEGRAM_BOT_NAME = "super_wallet_tracking_bot"
TELEGRAM_BOT_TOKEN = "YOUR_BOT_TOKEN"
TELEGRAM_CHAT_ID = "YOUR_CHAT_ID"

Once we set environment variables, create a telegram.ts file and write the following code to send messsages to Telegram:

import TelegramBot from "node-telegram-bot-api";
import dotenv from "dotenv";

dotenv.config();

const TELEGRAM_CHAT_ID = process.env.TELEGRAM_CHAT_ID!;

const bot = new TelegramBot(TELEGRAM_BOT_TOKEN, { polling: false });

export const sendTelegramMessage = async (message: string) => {
  try {
    await bot.sendMessage(TELEGRAM_CHAT_ID, message, {
      parse_mode: "HTML",
      disable_web_page_preview: true,
    });
  } catch (error) {
    console.error("Failed to send Telegram message:", error);
  }
};

2.Integrating Helius RPC

Helius provides reliable RPC endpoints for Solana transaction monitoring.

Setup Steps:

Get your Helius API key from Helius Dashboard
Configure RPC endpoints in .env:

RPC_URL = "https://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY"
WSS_URL = "wss://mainnet.helius-rpc.com/?api-key=YOUR_API_KEY"

3. Database Configuration and connection to MongoDB

We use MongoDB for storing transaction history and analysis.

Configuration:

MONGODB_URI = "mongodb://localhost:27017/solana_wallet_tracking"

Create db.ts file, and write the following code:

import mongoose from "mongoose";

export const connectDB = async (mongodb_url: string) => {
  await mongoose.connect(mongodb_url);
  console.log("📦 MongoDB Connected");
};

4. Wallet Monitoring

Configure the wallet address you want to monitor:

WALLET_ADDRESS = "YOUR_WALLET_ADDRESS"

5. Solana Connection Setup with Helius RPC

We need to establish communication with the Solana blockchain through Helius RPC endpoints.

Create connection.ts file, and write the following code:

import { Connection } from "@solana/web3.js";
import dotenv from "dotenv";

dotenv.config();

const RPC_URL = process.env.RPC_URL!;
const WSS_URL = process.env.WSS_URL!;

if (!RPC_URL || !WSS_URL) {
  throw new Error(
    "RPC_URL and WSS_URL must be defined in environment variables"
  );
}

export const connection = new Connection(RPC_URL, { wsEndpoint: WSS_URL });

This creates a Connection instance that provides:

HTTP-based RPC calls for transaction queries
WebSocket connection for real-time transaction monitoring
Automatic reconnection handling
Connection state management

6. Transaction Analysis

The system monitors:

Transaction signatures
Token transfers
Buy/Sell operations
Amount changes
Timestamps

We need to get transaction data from Helius RPC and processes this data and analyze signature in detail :

Create trading.ts file, and write the following code:

import { NATIVE_MINT } from "@solana/spl-token";
import { LAMPORTS_PER_SOL, PublicKey } from "@solana/web3.js";

import { sendTelegramMessage } from "./telegram.js";
import { Trading } from "./models/Trading.js";
import { formatCryptoAddress } from "./lib/format.js";

import { connection } from "./config.js";

const explorerUrl = "https://solscan.io/tx/";
const walletUrl = `https://solscan.io/account/`;

export const subscribeTrading = (key: string) => {
    const anaylzeSignature = async (log: any) => {
      txn = await connection.getParsedTransaction(signature, {
             maxSupportedTransactionVersion: 0,
            commitment: "confirmed",
          });

      if (!txn) {
        console.log(`Failed to fetch transaction after ${attempt} attempts`);
        return;
      }

      // process transaction to get relevant information

      console.log("preTokenBalances", preTokenBalances);
      console.log("postTokenBalances", postTokenBalances);
      console.log("loaced addresses", innerInstructions);

      const message = `
        🔔 <b>New Transaction Detected!</b>

        👛 <b>Wallet:</b> <a href="${walletUrl + signer}">${formatCryptoAddress(signer)}</a>

        💰 <b>Sol Amount:</b> ${solAmount > 0 ? "📥 SELL" : "📤 BUY"} ${Math.abs(solAmount).(3)} SOL

        💸 <b>PNL for this Token:</b> ${totalPNL.toFixed(3)} SOL

        🚀 <b>Token:</b> <a href="${walletUrl + tokenAddress}">${tokenInfo}</a>

        🔗 <a href="${explorerUrl + signature}">View Transaction</a>

        ⏰ ${new Date().toLocaleString()}
        `;

      await sendTelegramMessage(message); 
    }

  return connection.onLogs(new PublicKey(key), anaylzeSignature, "processed");
}

Conclusion

This Solana wallet tracking bot provides a robust solution for monitoring wallet activities with real-time Telegram notifications. By following this guide and implementing the provided configurations, you can create a powerful tool for tracking Solana transactions and maintaining awareness of your wallet activities.

The system's modular architecture allows for easy maintenance and future enhancements while providing reliable transaction monitoring and notification delivery.

Remember to regularly monitor your API usage and maintain your database to ensure optimal performance of your tracking system.

Contact Information

Gmail: marksantiago0929@gmail.com
GitHub: MARK
LinkedIn: Mark Santiago
Telegram: @marksantiago02
Twitter: @MarkSantiago02

How to write dynamic staking smart contract step by step in practice

Mark Santiago — Sat, 14 Dec 2024 13:53:53 +0000

Introduction

In the ever-expanding landscape of decentralized finance (DeFi), staking has emerged as a popular mechanism for users to earn rewards by participating in network security and governance. Unlike traditional financial systems, staking allows cryptocurrency holders to lock up their assets to support blockchain operations, all while earning passive income. However, the conventional staking model often comes with restrictions, such as lock-in periods and fixed reward structures that can limit user flexibility and engagement.

This article provides a detailed, hands-on guide to implementing dynamic staking smart contracts on Ethereum. We'll walk through building a production-ready staking system that enables real-time reward calculations and flexible withdrawals.
This article is the implementation of the Basic understanding of Dynamic Staking.
By following this step-by-step tutorial, you'll learn how to:

Create an upgradeable staking contract with role-based access control
Implement share-based reward calculations for precise token distribution
Build flexible deposit and withdrawal mechanisms without lock-in periods
Add essential security features and administrative controls
Handle real-time reward tracking and distribution

Whether you're building a DeFi protocol or enhancing an existing platform, this practical guide will equip you with the technical knowledge to implement a robust dynamic staking system. The code examples and implementation patterns shown here are battle-tested and ready for production use, helping you create staking mechanisms that truly serve the needs of modern DeFi users.

Let's dive into the technical implementation and understand how each component works together to create a flexible and secure dynamic staking system.

Implementation Details

Let's break down the key components of the dynamic staking contract:

1. Contract Structure and Inheritance

contract Staking is
    Initializable,
    UUPSUpgradeable,
    AccessControlUpgradeable,
    PausableUpgradeable
{
    using EnumerableSet for EnumerableSet.AddressSet;

The contract inherits from:

Initializable: For upgradeable contract initialization
UUPSUpgradeable: For upgrade functionality
AccessControlUpgradeable: For role-based access control
PausableUpgradeable: For emergency pause functionality

2. State Variables and Data Structures

struct Stake {
    uint256 stakedMRKST;
    uint256 shares;
}

IERC20 private MRKST;
EnumerableSet.AddressSet private stakeholders;
uint256 private totalStakes;
uint256 private totalShares;
mapping(address => Stake) private stakeholderToStake;

3. Key Functions

Initialization

function initialize(
    address admin1,
    address admin2,
    address _MRKST
) public initializer {
    AccessControlUpgradeable.__AccessControl_init();
    PausableUpgradeable.__Pausable_init();
    ADMIN_ROLE = keccak256("ADMIN_ROLE");
    _setupRole(ADMIN_ROLE, admin1);
    _setupRole(ADMIN_ROLE, admin2);
    MRKST = IERC20(_MRKST);
    base = 10**18;
}

This function initializes the contracts. It

Sets up the initial contract state
Assigns two administrators for enhanced security
Links the staking token contract
Establishes the base unit (10^18) for precise calculations
Initializes access control and pause functionality

Staking Implementation

function createStake(uint256 stakeAmount) public whenNotPaused isInitialRatioSet {
    uint256 shares = (stakeAmount * totalShares) / MRKST.balanceOf(address(this));

    require(MRKST.transferFrom(msg.sender, address(this), stakeAmount), "MRKST transfer failed");

    stakeholders.add(msg.sender);
    stakeholderToStake[msg.sender].stakedMRKST += stakeAmount;
    stakeholderToStake[msg.sender].shares += shares;
    totalStakes += stakeAmount;
    totalShares += shares;
}

This function

Accepts user deposits
Calculates shares based on current token/share ratio
Transfers tokens from user to contract
Records stake details in storage
Updates global totals
Adds user to stakeholder list

Withdrawal Implementation

function removeStake(uint256 stakeAmount) public whenNotPaused {
    uint256 stakeholderStake = stakeholderToStake[msg.sender].stakedMRKST;
    uint256 stakeholderShares = stakeholderToStake[msg.sender].shares;

    require(stakeholderStake >= stakeAmount, "Not enough staked!");

    uint256 sharesToWithdraw = (stakeAmount * stakeholderShares) / stakeholderStake;
    uint256 rewards = calculateRewards(stakeAmount, stakeholderStake, stakeholderShares);

    updateStakeAndShares(msg.sender, stakeAmount, sharesToWithdraw);
    transferRewards(msg.sender, stakeAmount, rewards);
}

This function

Processes withdrawal requests
Calculates earned rewards
Determines shares to burn
Updates user's stake balance
Transfers principal plus rewards
Removes user from stakeholder list if fully withdrawn

Reward Calculation

function rewardOf(address stakeholder) public view returns (uint256) {
    uint256 stakeholderStake = stakeholderToStake[stakeholder].stakedMRKST;
    uint256 stakeholderShares = stakeholderToStake[stakeholder].shares;

    if (stakeholderShares == 0) {
      return 0;
    }

    uint256 stakedRatio = (stakeholderStake * base) / stakeholderShares;
    uint256 currentRatio = (MRKST.balanceOf(address(this)) * base) /
      totalShares;

    if (currentRatio <= stakedRatio) {
      return 0;
    }

    uint256 rewards = (stakeholderShares * (currentRatio - stakedRatio)) / base;

    return rewards;
  }

This function

Calculates total pending rewards for a stakeholder
Uses ratio comparison between initial stake and current value
Accounts for all accumulated rewards
Returns total claimable reward amount

Reward Distribution

function rewardForStake(address stakeholder, uint256 stakeAmount)
    public
    view
    returns (uint256)
  {
    uint256 stakeholderStake = stakeholderToStake[stakeholder].stakedMRKST;
    uint256 stakeholderShares = stakeholderToStake[stakeholder].shares;

    require(stakeholderStake >= stakeAmount, "Not enough staked!");

    uint256 stakedRatio = (stakeholderStake * base) / stakeholderShares;
    uint256 currentRatio = (MRKST.balanceOf(address(this)) * base) /
      totalShares;
    uint256 sharesToWithdraw = (stakeAmount * stakeholderShares) /
      stakeholderStake;

    if (currentRatio <= stakedRatio) {
      return 0;
    }

    uint256 rewards = (sharesToWithdraw * (currentRatio - stakedRatio)) / base;

    return rewards;
  }

This function

Calculates rewards for partial withdrawal
Determines proportional share of rewards
Validates withdrawal amount
Returns specific reward amount for requested withdrawal

Refund Locking Implementation

  function refundLockedStake(uint256 from, uint256 to) public hasAdminRole {
    require(to <= stakeholders.length(), "Invalid `to` param");
    uint256 s;

    for (s = from; s < to; s += 1) {
      totalStakes -= stakeholderToStake[stakeholders.at(s)].stakedMRKST;

      require(
        MRKST.transfer(
          stakeholders.at(s),
          stakeholderToStake[stakeholders.at(s)].stakedMRKST
        ),
        "MRKST transfer failed"
      );

      stakeholderToStake[stakeholders.at(s)].stakedMRKST = 0;
    }
  }

This function

Emergency withdrawal mechanism
Processes refunds in batches
Returns original stake amounts
Clears stake records

Conclusion

This dynamic staking implementation provides a flexible and secure way to manage token staking with real-time reward calculations. The share-based system ensures fair distribution of rewards while maintaining precision in calculations.

Future Possibilities

Multiple token support
Tiered reward systems
Governance integration
Advanced reward strategies
Enhanced analytics and reporting

This implementation serves as a robust foundation for building more sophisticated staking mechanisms in DeFi applications.

For more detailed information, please refer to the source code.

Thank you! Happy coding! 😍

Basic understanding of Dynamic Staking

Mark Santiago — Sat, 07 Dec 2024 17:27:32 +0000

Introduction

This article explores the concept of staking and delves into the mechanism and example workflow of innovative dynamic staking. I will guide you basic knowledge of dynamic staking that offers stakeholders the freedom to withdraw their assets at any time while earning rewards calculated in real-time based on their contributions. By understanding the mechanics of dynamic staking, you can create more flexible and user-friendly DeFi applications that cater to the evolving needs of the crypto community.

What is Staking?

Staking is a process used in various blockchain networks, particularly those that operate on a proof-of-stake (PoS) consensus mechanism. In simple terms, staking allows users to lock up a certain amount of cryptocurrency in a wallet to support the operations of a blockchain network. In return for their contribution, stakeholders earn rewards, typically in the form of additional tokens.

The primary purpose of staking is to enhance network security and efficiency. By staking their tokens, participants help validate transactions and maintain the integrity of the blockchain. The more tokens a user stakes, the higher their chances of being selected to validate a block and earn rewards.

General Staking Mechanism

In traditional staking models, users commit their tokens for a predetermined period, often referred to as a "lock-in" period. During this time, they cannot access or withdraw their staked tokens. The rewards are usually calculated based on the amount of tokens staked and the duration of the staking period.

Here’s a simplified workflow of how traditional staking works:

User Participation: A user decides to stake a certain amount of cryptocurrency.
Locking Tokens: The user locks their tokens in a staking contract for a fixed period.
Earning Rewards: Throughout the staking period, the user earns rewards based on their staked amount.
Withdrawal: At the end of the staking period, the user can withdraw their original tokens along with any earned rewards.

While this approach provides predictable rewards, it also comes with drawbacks, such as the inability to access funds during the lock-in period and the potential for missed opportunities if market conditions change.

Dynamic Staking: A New Approach

Dynamic staking introduces a more flexible and responsive model for staking that addresses some of the limitations of traditional staking. Instead of requiring users to lock their tokens for a specific period, dynamic staking allows stakeholders to withdraw their tokens at any time while still earning rewards based on their contributions.

Key Features of Dynamic Staking

No Lock-in Period: Stakeholders can remove their staked tokens whenever they want, providing liquidity and flexibility.
Dynamic APY Calculation: The Annual Percentage Yield (APY) is calculated based on real-time data, including the number of stakeholders, their staked amounts, and the total rewards accumulated in the staking contract.
Share-Based Rewards: Instead of a fixed reward per staked token, rewards are distributed based on the number of shares each stakeholder holds, which reflects their proportional contribution to the staking pool.

Example workflow of Dynamic Staking

Before diving into the code, let's understand the key concepts of the dynamic staking mechanism:

MRK is the token used in the staking system. It represents the currency that stakeholders can stake to earn rewards.
Shares represent each stakeholder's claim to the total pool of STK in the staking contract. Shares are proportional to the amount of STK staked.
Rewards are additional STK tokens deposited into the staking contract, typically as a form of incentive for stakeholders to participate.
Alice, Bob, Charlie, and Dave are stakeholders who participate in the dynamic staking system in this example scenario.
They can stake, claim, unstake MRK tokens
The MRK/share ratio is a proportional ratio that represents the amount of MRK available in the contract per share owned by the stakeholders. This ratio determines how much MRK a stakeholder receives when they withdraw their shares. It changes as stakeholders deposit more MRK or as rewards are added to the contract, affecting each stakeholder's payout.

Now, let's walk through a simplified example of how dynamic staking works:

Initial State: The MRK/share ratio begins at 1:1.
Alice, Bob and Charlie stakes 500, 1000, 500 MRK tokens. In return, they receive 500, 1000, 500 shares respectively.
Action 1: 100 MRK Token is deposited into the staking contract as rewards.
Updated State: The MRK/share ratio increases to 1.05, calculated as follows:

    Total MRK = 500 (Alice) + 1000 (Bob) + 500 (Charlie) + 100 (reward) = 2100 MRK
    MRK/Share Ratio = 2100 MRK / 2000 shares = 1.05

Action 2: Alice and Bob claims rewards, so they will receive 25, 50 MRK tokens respectively.

    Alice's Claim Amount = (500 MRK * 0.05) = 25 MRK
    Alice's remaining shares = 500 - 25 / 1.05 = 476.19 shares
    Bob's Claim Amount = (1000 MRK * 0.05) = 50 MRK
    Bob's remaining shares = 1000 - 50 / 1.05 = 952.38 shares
    Charlie's remaining shares = 500 shares

    Remaining Total MRK tokens  = 2100 - (25 + 50) = 2025 MRK
    Remaining Shares = 476.19 + 952.38 + 500 = 1928.57 shares
    MRK/Share Ratio = 2025 MRK / 1928.57 shares = 1.05

As you can see, MRK/Share Ratio remains constant at 1.05 because no new rewards are added to the contract.

Action 3: Dave stakes 500 MRK tokens and his shares will be 500 / 1.05 = 476.19 shares.

So remaining total MRK tokens = 2025 + 500 = 2525 MRK, and remaining shares = 1928.57 + 476.19 = 2404.76 shares

Action 4: Charlie claims 250 MRK tokens. He receives 12.5 MRKs. Charlie's remaining shares = 500 - 12.5 / 1.05 = 488.10 shares Remaining MRK tokens = 2525 - 12.5 = 2512.5 MRK, remaining shares = 2404.76 - 12.5 / 1.05 = 2392.86 shares

Still MRK/Share Ratio remains constant at 1.05 because no new rewards are added to the contract.

Action 5: Dave stakes another 500 MRK tokens, so his shares will be 476.19 + 500 / 1.05 = 952.38 shares and total MRK tokens are 2512.5 + 500 = 3012.5 MRK, and total shares are 2392.86 + 500 / 1.05 = 2869.05 shares
Action 6: Another reward of 100 MRK is deposited into the staking contract.
Then the MRK/share ratio is updated to 1.08485, calculated as follows:

 MRK/Share Ratio = (3012.5 + 100) MRK / 2869.05 shares = 1.08485

And they now have 476.19, 952.38, 488.10, 952.38 shares respectively.
So they will receive approx. 516, 1038, 528, 1038 MRK tokens respectively when they withdraw their whole staked MRK tokens and their rewards will be 16.5, 33, 17.5, 33 MRK tokens respectively.

Conclusion

Dynamic staking represents a significant evolution in the staking landscape, providing users with the flexibility to manage their investments while still benefiting from rewards. By calculating rewards based on real-time data and allowing for immediate withdrawals, this model enhances user experience and engagement.

Thanks.
Happy coding.

How to Write a Token Price Oracle Smart Contract

Mark Santiago — Sun, 01 Dec 2024 07:14:12 +0000

Introduction

In the rapidly evolving DeFi ecosystem, accurate and reliable token price data is fundamental for various applications like lending protocols, automated trading systems, and yield farming strategies. Token price oracles serve as the critical infrastructure that enables these protocols to access real-time price information directly from the blockchain.

This article shows you how to build a robust token price oracle smart contract that leverages Uniswap V2's liquidity pools to derive token prices. By understanding and implementing this oracle system, developers can create DeFi applications that make informed decisions based on current market conditions.

Key benefits of building a token price oracle:

Real-time price discovery from decentralized exchanges
On-chain price verification
Integration capability with any DeFi protocol
Support for multiple tokens through batch queries
Cost-effective price fetching through view functions
Throughout this guide, we'll explore a practical implementation that showcases:

How to interact with Uniswap V2 contracts

Methods for accurate price calculations
Handling different token decimals
Batch processing for multiple tokens
Event emission for price tracking

Okay, now let's dive into the technical implementation and understand how each component works together to create a reliable price oracle system.

How to Implement Price Oracle Smart Contract Step by Step

We are going to use Uniswap V2's liquidity pools to fetch token prices.

This approach offers several advantages:

Decentralization: Uniswap V2 is a decentralized exchange, ensuring that price data is not controlled by a single entity.
Liquidity: Uniswap V2 pools provide liquidity for various tokens, allowing for a wide range of price data.
Flexibility: Uniswap V2 supports multiple tokens, enabling the oracle to fetch prices for multiple tokens simultaneously.

We need to import required interfaces like IUniswapV2Pair, IUniswapV2Factory, and IERC20.
And define the contract's state variables, events.

Key functions

1. Getting Pair Address

function getPairAddress(address tokenA, address tokenB) public view returns (address) {
    return IUniswapV2Factory(UNISWAP_V2_FACTORY_ADDRESS).getPair(tokenA, tokenB);
}

This function retrieves the liquidity pair address for any token pair from Uniswap V2.

2. Token Price Calculation

    function getTokenPrice(address token) public returns (uint256 tokenPrice, uint256 ethPrice, string memory symbol) {
        address pairAddress = getPairAddress(token, WETH);
        require(pairAddress != address(0), "Pair not found");

        IUniswapV2Pair pairContract = IUniswapV2Pair(pairAddress);

        (uint112 reserve0, uint112 reserve1, ) = pairContract.getReserves();
        address token0 = pairContract.token0();

        uint8 tokenDecimals = IERC20(token).decimals();
        symbol = IERC20(token).symbol();

        if (token0 == WETH) {
            ethPrice = (reserve0 * (10 ** tokenDecimals)) / reserve1;
            tokenPrice = (reserve1 * (10 ** 18)) / reserve0;
        } else {
            ethPrice = (reserve1 * (10 ** tokenDecimals)) / reserve0;
            tokenPrice = (reserve0 * (10 ** 18)) / reserve1;
        }

        emit PriceUpdated(token, tokenPrice, ethPrice, symbol);
    }

First we get the pair address for the token pair.
And if the pair is not found, it throws an error.

The price calculation logic handles two scenarios:

If WETH is token0:

if (token0 == WETH) {
    ethPrice = (reserve0 * (10 ** tokenDecimals)) / reserve1;
    tokenPrice = (reserve1 * (10 ** 18)) / reserve0;
}

If WETH is token1:

else {
    ethPrice = (reserve1 * (10 ** tokenDecimals)) / reserve0;
    tokenPrice = (reserve0 * (10 ** 18)) / reserve1;
}

3. Batch Price Fetching

function getMultipleTokenPrices(address[] calldata tokens) external returns (
    uint256[] memory tokenPrices,
    uint256[] memory ethPrices,
    string[] memory symbols
)

This function efficiently fetches prices for multiple tokens in a single transaction.

Usage Example

We can use this price oracle contract in other smart contract and also frontend for getting real time token price.

Usage in other solidity Smart contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "./UniswapV2PriceOracle.sol";

contract PriceConsumer {
    UniswapV2PriceOracle public oracle;

    constructor(address _oracle) {
        oracle = UniswapV2PriceOracle(_oracle);
    }

    function getTokenPriceInETH(address token, uint256 amount) external view returns (uint256) {
        return oracle.getTokenValueInETH(token, amount);
    }

    function checkPriceImpact(address token, uint256 amount) external view returns (uint256) {
        return oracle.getPriceImpact(token, amount);
    }
}

Frontend Implementation with ethers.js

import { ethers } from 'ethers';
import { useState, useEffect } from 'react';

const PriceTracker = () => {
    const [price, setPrice] = useState<string>('0');
    const [priceImpact, setPriceImpact] = useState<string>('0');

    const ORACLE_ADDRESS = "YOUR_ORACLE_ADDRESS";
    const TOKEN_ADDRESS = "YOUR_TOKEN_ADDRESS";

    useEffect(() => {
        const provider = new ethers.providers.Web3Provider(window.ethereum);
        const oracle = new ethers.Contract(ORACLE_ADDRESS, oracleABI, provider);

        const fetchPrices = async () => {
            const amount = ethers.utils.parseEther("1");

            // Get token price
            const tokenPrice = await oracle.getTokenValueInETH(
                TOKEN_ADDRESS, 
                amount
            );
            setPrice(ethers.utils.formatEther(tokenPrice));

            // Get price impact
            const impact = await oracle.getPriceImpact(
                TOKEN_ADDRESS,
                amount
            );
            setPriceImpact(ethers.utils.formatUnits(impact, 2));
        };

        fetchPrices();

        // Listen for price updates
oracle.on("PriceUpdated", (token, ethPrice, tokenPrice, symbol) => {
    if(token === TOKEN_ADDRESS) {
        setPrice(ethers.utils.formatEther(ethPrice));
        setTokenPrice(ethers.utils.formatEther(tokenPrice));
        setSymbol(symbol);
    } else {
        // Track other token updates
        setOtherTokenPrices(prev => ({
            ...prev,
            [token]: {
                ethPrice: ethers.utils.formatEther(ethPrice),
                tokenPrice: ethers.utils.formatEther(tokenPrice),
                symbol
            }
        }));

        // Optionally notify about other token updates
        console.log(`Price updated for ${symbol}: ${ethers.utils.formatEther(ethPrice)} ETH`);
    }
});

        return () => {
            oracle.removeAllListeners();
        };
    }, []);

    return (
        <div>
            <h2>Token Price: {price} ETH</h2>
            <h3>Price Impact: {priceImpact}%</h3>
        </div>
    );
};

export default PriceTracker;

This implementation provides a reliable way to fetch token prices directly from Uniswap V2 liquidity pools, making it suitable for various DeFi applications requiring on-chain price data

Conclusion

The implementation of a token price oracle smart contract demonstrates the power and flexibility of on-chain price discovery through Uniswap V2 liquidity pools.

Future Possibilities

Integration with additional DEX protocols
Implementation of time-weighted average prices (TWAP)
Price feed aggregation from multiple sources
Enhanced security features and price manipulation protection

This oracle implementation serves as a robust starting point for developers building DeFi applications that require reliable, on-chain price data. By understanding and implementing these concepts, developers can create more sophisticated and reliable DeFi protocols.

How to write smart contract for NFT marketplace

Mark Santiago — Sat, 23 Nov 2024 18:27:01 +0000

Introduction

This technical guide will give you a comprehensive guide to building a complete NFT marketplace ecosystem using Solidity and Openzeppelin.
Our marketplace features a native token, NFT creation with customizable royalties, and secure trading mechanisms.

Technical Stack

Solidity ^0.8.27
OpenZeppelin Contracts
Hardhat Development Environment
TypeScript
Ethers.js

Contract Structure

The project is structured into three main contracts:

Platform Token (NYWToken.sol)
NFT Contract (NYWNFT.sol)
Marketplace Contract (NYWMarketplace.sol)

1. Platform Token Implementation (NYWToken.sol)

The foundation of our marketplace starts with implementing the platform's native token.

This NYWToken contract is a simple ERC20 token implementation.
It inherits from the OpenZeppelin ERC20 contract and initializes the token with a supply of 1 billion tokens.

Key Features:

Token Supply: 1 billion tokens
Token Standard: ERC20 compliance
Decimals: 18 decimal places for maximum divisibility
Initial Distribution: All tokens minted to contract deployer

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract NYWToken is ERC20 {
    uint256 initialSupply = 10 ** 9;

    constructor() ERC20("NYWToken", "NYW") {
        _mint(msg.sender, initialSupply * 10 ** decimals());
    }
}

2. NFT Contract Implementation

The NYWNFT contract handles creating and burning NYW NFT token, and royalty management.
This contract inherits from the OpenZeppelin ERC721 contract, which provides the necessary functionality for creating and managing NFTs.

Key Functions:

createNYW(): Creates new NFTs with customizable royalties
burnNYW(): Removes NFTs from circulation
getCreator(): Updates metadata URI
getRoyalty(): Returns royalty configuration

Here is a detailed implementation of the NYWNFT contract:

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract NYWNFT is ERC721URIStorage, Ownable {
    uint256 private _tokenId;

    mapping(uint256 => address) public creators;
    mapping(uint256 => uint256) public royalties;

    event NYWTokenCreated(
        address indexed creator,
        uint256 tokenId,
        uint256 royalty,
        string tokenURI
    );
    event NYWTokenBurned(address indexed burner, uint256 tokenId);

    constructor() ERC721("NYW NFT", "NYW") Ownable(msg.sender) {}

    function createNYW(
        string memory tokenURI,
        uint256 royalty
    ) external returns (uint256) {
        require(
            royalty >= 0 && royalty <= 30,
            "Royalty must be between 0 and 30"
        );
        _tokenId += 1;

        creators[_tokenId] = msg.sender;
        royalties[_tokenId] = royalty;
        _safeMint(msg.sender, _tokenId);
        _setTokenURI(_tokenId, tokenURI);
        _setApprovalForAll(msg.sender, address(this), true);

        emit NYWTokenCreated(msg.sender, _tokenId, royalty, tokenURI);

        return _tokenId;
    }

    function burnNYW(uint256 tokenId) external {
        require(
            msg.sender == ownerOf(tokenId),
            "Only the owner can burn the token"
        );

        _burn(tokenId);
        delete creators[tokenId];
        delete royalties[tokenId];

        emit NYWTokenBurned(msg.sender, tokenId);
    }

    function getCreator(uint256 tokenId) external view returns (address) {
        return creators[tokenId];
    }

    function getRoyalty(uint256 tokenId) external view returns (uint256) {
        return royalties[tokenId];
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721URIStorage)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }
}

3. Marketplace Contract Implementation (NYWMarketplace.sol)

The NYWMarketplace contract manages listings, delisting and buying NFTs and withdrawing funds:

Key Functions:

listNFT(uint256 tokenId_, uint256 price_): Lists new NFT to marketplace for sale
delistNFT(uint256 tokenId_): Removes NFT from marketplace
buyNFT(uint256 tokenId_): Purchases NFT from marketplace
withdraw(): Withdraws funds from marketplace

    function listNFT(uint256 tokenId_, uint256 price_) external {
        // Check if the NFT is already listed
        require(!isExisting[tokenId_], "NFT is already listed");
        // Check if the NFT is owned by the caller
        require(
            nftContract.ownerOf(tokenId_) == msg.sender,
            "You are not the owner of the NFT"
        );

        //Define new NFTMarketItem
        NFTMarketItem memory newNFTMarketItem = NFTMarketItem(
            tokenId_,
            price_,
            nywContract.getRoyalty(tokenId_),
            payable(msg.sender),
            nywContract.getCreator(tokenId_),
            true
        );

        isExisting[tokenId_] = true;
        listedNFTs.push(newNFTMarketItem);
        tokenIdToNFTMarketItemId[tokenId_] = totalListedNFTs;
        totalListedNFTs++;

        emit NYWNFTListed(
            tokenId_,
            price_,
            nywContract.getRoyalty(tokenId_),
            nywContract.getCreator(tokenId_),
            msg.sender
        );
    }

    function delistNFT(uint256 tokenId_) external {
        require(isExisting[tokenId_], "NFT is not listed");
        uint256 nftMarketItemId = tokenIdToNFTMarketItemId[tokenId_];
        require(
            listedNFTs[nftMarketItemId].seller == msg.sender,
            "Only the seller can delist the NFT"
        );

        deleteNFTfromArray(tokenId_);
        emit NYWNFTDelisted(tokenId_);
    }

    function deleteNFTfromArray(uint256 tokenId_) public {
        uint256 nftMarketItemId = tokenIdToNFTMarketItemId[tokenId_];
        uint256 lastIndex = listedNFTs.length - 1;
        listedNFTs[nftMarketItemId] = listedNFTs[lastIndex];
        tokenIdToNFTMarketItemId[
            listedNFTs[lastIndex].tokenId
        ] = nftMarketItemId;
        listedNFTs.pop();
        totalListedNFTs--;
        delete tokenIdToNFTMarketItemId[tokenId_];
        isExisting[tokenId_] = false;
    }

    function buyNFT(uint256 tokenId_) public payable {
        require(isExisting[tokenId_], "NFT is not listed");
        uint256 _nftMarketItemId = tokenIdToNFTMarketItemId[tokenId_];
        NFTMarketItem memory _nftMarketItem = listedNFTs[_nftMarketItemId];
        require(!_nftMarketItem.isSold, "NFT is already sold");
        require(msg.value == _nftMarketItem.price, "Incorrect payment amount");

        // Calculate royalty amount
        uint256 _royaltyAmount = (_nftMarketItem.price *
            _nftMarketItem.royalty) / deno;
        // Calculate platform fee
        uint256 _platformFeeAmount = (_nftMarketItem.price * platformFee) /
            deno;
        // Calculate seller amount
        uint256 _sellerAmount = _nftMarketItem.price -
            _royaltyAmount -
            _platformFeeAmount;
        // Transfer funds to the seller
        payable(_nftMarketItem.seller).transfer(_sellerAmount);
        // Transfer royalty amount to the creator
        payable(_nftMarketItem.creator).transfer(_royaltyAmount);
        // Transfer platform fee amount to the platform
        payable(owner()).transfer(_platformFeeAmount);
        //Transfer NFT to the buyer
        nftContract.safeTransferFrom(
            _nftMarketItem.seller,
            msg.sender,
            _nftMarketItem.tokenId
        );

        _nftMarketItem.isSold = true;
        deleteNFTfromArray(tokenId_);
        emit NYWNFTBought(
            _nftMarketItem.tokenId,
            msg.sender,
            _nftMarketItem.seller,
            _nftMarketItem.price
        );
    }

    function withdraw() external onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "No funds to withdraw");
        payable(owner()).transfer(balance);
        emit NYWNFTWithdrawn(balance);
    }

Conclusion

Building a secure and efficient NFT marketplace requires careful implementation of multiple smart contracts working together. This guide covered the essential components: platform token, NFT contract, and marketplace functionality.

Understanding smart contracts for NFT marketplace

Mark Santiago — Sat, 23 Nov 2024 16:51:47 +0000

Introduction

Non-fungible tokens are making headlines in recent days. This hype started with the advent of blockchain networks that has been adopted by most industries. For quite a long time, we have discussed developing an NFT marketplace; now, it's time to focus on the legal things that surround the launch of NFT marketplaces. This article will give you a knowledge of NFT and smart contracts for developing a comprehensive NFT marketplace like Opensea.

What is a Non-Fungible Token(NFT)?

NFTs (non-fungible tokens) are unique cryptographic tokens that exist on a blockchain and cannot be replicated.
NFTs can represent digital or real-world items like artwork and real estate.
"Tokenizing" these real-world tangible assets makes buying, selling, and trading them more efficient while reducing the probability of fraud.
NFTs can represent individuals' identities, property rights, and more. Collectors and investors initially sought NFTs after the public became more aware of them, but their popularity has since waned.

What is an NFT Marketplace?

NFT marketplace is a digital platform where users can buy, sell, and trade non-fungible tokens (NFTs). It acts as intermediaries between creators and collectors, providing a space for these digital assets to be traded and exchanged.

Different Standards of NFT Smart Contract

Okay, now that you've got a general understanding of NFT and marketplace, its time to navigate to the different standards of NFT smart contracts. These are called Ethereum standards that are popular globally due to their provided benefits such as secure transactions, verify authentication, and more.

1. ERC 721 Standard

ERC-721 is known as an open standard found on Ethereum Blockchain and makes the NFTs work like one-of-its-kind while being perpetual on the Blockchain. It is the reason behind making NFTs difficult to replicate unique digital holding on the Ethereum Blockchain. It specifies the Smart Contract is working. Each ERC 721 can handle multiple tokens efficiently. The time token is transferred, you will require 2 important things including a Token ID, and a Smart Contract address. It defines the legitimacy of digital ownership and protects the NFT token from fraudulent activities.

2. ERC 1155 Standard

The solidity of the Smart Contract for NFTs will be bolstered further with the help of the ERC 1155 standard. It is considered a multi-token able to do multi-transactions. At a time, it has the capability to manage different tokens. With this token, a token ID will include its type, metadata, and supply. It will be useful for Smart Contracts to be semi-fungible, non-fungible as well as fungible. Hence, multiple tokens can be transferred in a single transaction.

Other than Ethereum, there are many Smart Contract Blockchains with NFT tools EOS, TRON, TEZOS, and Solarium. This NFTs standardization will be helpful to ensure the tokens’ interoperability. Here, these tokens will operate entirely different according to the Blockchain platforms they are implemented in.

Key Functions for NFT Smart Contract

An NFT smart contract, usually adhering to standards like ERC-721 or ERC-1155, contains functions related to the creation and management of NFTs.

1. Minting Functions:

mint(address to, uint256 tokenId): Creates a new NFT and assigns it to the specified address.
safeMint(address to, uint256 tokenId): Similar to mint, but checks that the recipient can receive NFTs.

2. Metadata Functions:

setBaseURI(string memory baseURI): Sets the base URI for metadata, allowing dynamic linking to metadata using token IDs.
tokenURI(uint256 tokenId): Returns the URI for a specific token, which points to its metadata (e.g., JSON file describing the NFT).

3. Ownership Functions:

ownerOf(uint256 tokenId): Returns the owner of a specific NFT.
balanceOf(address owner): Returns the number of NFTs owned by a specific address.

4. Transfer Functions:

transferFrom(address from, address to, uint256 tokenId): Transfers ownership of a specific NFT from one address to another.
safeTransferFrom(address from, address to, uint256 tokenId): Transfers an NFT and checks that the receiving address can handle it.

5. Approval Functions:

approve(address to, uint256 tokenId): Grants permission to another address to transfer the specified NFT.
setApprovalForAll(address operator, bool approved): Approves or revokes approval for an operator to transfer all of a user’s NFTs.

6. Several helper functions:

supportsInterface(bytes4 interfaceId): Checks if a contract implements a specific interface.
getCreator(uint256 tokenId): Returns the creator of a specific NFT.
getApproved(uint256 tokenId): Returns the address approved to transfer a specific NFT.
isApprovedForAll(address owner, address operator): Checks if an operator is approved to manage all of an owner’s NFTs.
function getRoyalty(uint256 tokenId): Returns the royalty fee for a specific NFT.

...

Key Functions for NFT Marketplace Smart Contract

An NFT marketplace smart contract facilitates buying, selling, and trading of NFTs.

1. Listing Functions:

listNFT(uint256 tokenId, uint256 price): Allows the owner of an NFT to list it for sale at a specified price.
cancelListing(uint256 tokenId): Allows the owner to cancel a listing before it is sold.

2. Buying Functions:

buyNFT(uint256 tokenId): Allows a user to purchase a listed NFT, transferring ownership and handling the payment.
getNFTPrice(uint256 tokenId): Returns the listing price for a specific NFT.

3. Bid Functions for auction-style selling of NFTs:

placeBid(uint256 tokenId, uint256 bidAmount): Allows users to place bids on NFTs.
acceptBid(uint256 tokenId, address bidder): Allows the owner to accept a bid, completing the sale.

4. Royalties and Payment Handling:

setRoyaltyPercentage(uint256 tokenId, uint256 percentage): Allows setting a royalty percentage for future sales of the NFT.
withdrawFunds(): Allows the contract owner to withdraw funds collected from sales.

5. Ownership Verification:

isOwner(uint256 tokenId): Returns whether the caller is the owner of the specified NFT.

Conclusion

The development of NFT marketplaces represents a significant advancement in digital asset trading, combining blockchain technology with unique digital ownership. Through the implementation of standardized smart contracts like ERC-721 and ERC-1155, these platforms provide secure, transparent, and efficient ways to create, buy, sell, and trade NFTs.

Key takeaways:

NFT smart contracts provide essential functions for minting, managing ownership, handling metadata, and facilitating transfers
Marketplace smart contracts enable crucial features like listing, buying, bidding, and royalty management
The combination of both contract types creates a robust ecosystem for NFT trading
Standardization through ERC protocols ensures interoperability and security

As the NFT space continues to evolve, understanding these fundamental components is crucial for developers looking to build secure and functional NFT marketplaces. The proper implementation of these smart contract functions creates a foundation for successful NFT platforms that can serve creators, collectors, and traders effectively.

I will provide you with the code for the NFT marketplace smart contract step by step in the next article.

How to write ERC20 Token Presale smart contract using Solidity and Hardhat

Mark Santiago — Thu, 21 Nov 2024 14:40:13 +0000

Introduction

This article will give you a knowledge of ERC20 token and how to write ERC20 Token Presale smart contract using Solidity and Hardhat.

Theory

What is an ERC20 Token?

ERC-20 is a technical standard; it is used for all smart contracts on the Ethereum blockchain for token implementation and provides a list of rules that all Ethereum-based tokens must follow.
You can check all the ERC20 functions before moving ahead.

What is an Initial Coin Offering (ICO)?

An Initial Coin Offering (ICO) is a fundraising mechanism in the cryptocurrency industry, akin to an Initial Public Offering (IPO) in the traditional financial sector.

Development of Smart Contracts

ERC20 token contract

Token Specification
- Token Name : MARK Token
- Token Symbol : MRK
- Token Decimal : 18
- Total Supply : 100,000,000,000
- Token Type : ERC20
Token Contract

We will use OpenZeppelin ERC20 contract to create our token and mint 100 billion tokens to the owner of the contract.

//SPDX-License-Identifier: MIT
pragma solidity ^0.8.27;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MKT is ERC20 {
    uint256 private _totalSupply = 100_000_000_000;

    constructor() ERC20("MARK Token", "MKT") {
        _mint(msg.sender, _totalSupply * 10 ** decimals());
    }
}

Token presale contract

Presale Specification
- Presale Supply : 10 billion (10%)
- Presale Period : 30 days
- Softcap : 300000 USDT
- Hardcap : 1000000 USDT
- Buy Token with ETH and USDT
Key functions
- Buy
- Round management
- Claim
- Withdraw
Implementation

We are going to use Chainlink Oracle to get the latest price of USDT and ETH. Alternatively you can use Uniswap or PancakeSwap to get the price of USDT and ETH.

Buy MARK Token with ETH

  function buy_with_eth()
        external
        payable
        nonReentrant
        whenNotPaused
        canPurchase(_msgSender(), msg.value)
        returns (bool)
    {

        uint256 amount_in_usdt = (msg.value * get_eth_in_usdt()) / 1e30;
        require(
            round_list[current_round_index].usdt_round_raised + amount_in_usdt <
                round_list[current_round_index].usdt_round_cap,
            "BUY ERROR : Too much money already deposited."
        );

        uint256 amount_in_tokens = (amount_in_usdt *
            round_list[current_round_index].usdt_to_token_rate) * 1e3;

        users_list[_msgSender()].usdt_deposited += amount_in_usdt;
        users_list[_msgSender()].tokens_amount += amount_in_tokens;

        round_list[current_round_index].usdt_round_raised += amount_in_usdt;

        (bool sent,) = round_list[current_round_index].wallet.call{value: msg.value}("");
        require(sent, "Failed to send Ether");

        emit Deposit(_msgSender(), 1, amount_in_usdt, amount_in_tokens);

        return true;
    }

First, the function has several checks through modifiers:

nonReentrant prevents reentrancy attacks
whenNotPaused ensures the contract isn't paused
canPurchase verifies the presale is active and valid purchase amount

Next, it calculates the USDT equivalent of sent ETH using Chainlink oracle price feeds

  function get_eth_in_usdt() internal view returns (uint256) {
        (, int256 price, , , ) = price_feed.latestRoundData();
        price = price * 1e10;
        return uint256(price);
    }

And checks if the purchase amount is within the round cap.

Next, it calculates token amount based on the USDT equivalent using the current round's exchange rate:

Next, it updates the states of the user and the round:

Records user's USDT deposit and token allocation
Updates the total USDT raised in current round
Transfers the ETH to the round's wallet address

Finally, it emits a Deposit event with purchase details and returns true for successful transaction.

Buy MARK token with USDT

Similar to the ETH purchase, we can define the buy function with USDT as follows. The only difference is that this handles direct USDT transfers instead of using price oracles for conversion.

 function buy_with_usdt(uint256 amount_)
        external
        nonReentrant
        whenNotPaused
        canPurchase(_msgSender(), amount_)
        returns (bool)
    {
        uint256 amount_in_usdt = amount_;
        require(
            round_list[current_round_index].usdt_round_raised + amount_in_usdt <
                round_list[current_round_index].usdt_round_cap,
            "BUY ERROR : Too much money already deposited."
        );

        uint256 allowance = usdt_interface.allowance(msg.sender, address(this));

        require(amount_ <= allowance, "BUY ERROR: Allowance is too small!");

        (bool success_receive, ) = address(usdt_interface).call(
            abi.encodeWithSignature(
                "transferFrom(address,address,uint256)",
                msg.sender,
                round_list[current_round_index].wallet,
                amount_in_usdt
            )
        );

        require(success_receive, "BUY ERROR: Transaction has failed!");

        uint256 amount_in_tokens = (amount_in_usdt *
            round_list[current_round_index].usdt_to_token_rate) * 1e3;

        users_list[_msgSender()].usdt_deposited += amount_in_usdt;
        users_list[_msgSender()].tokens_amount += amount_in_tokens;

        round_list[current_round_index].usdt_round_raised += amount_in_usdt;

        emit Deposit(_msgSender(), 3, amount_in_usdt, amount_in_tokens);

        return true;
    }

Claim Token

function claim_tokens() external returns (bool) {
        require(presale_ended, "CLAIM ERROR : Presale has not ended!");
        require(
            users_list[_msgSender()].tokens_amount != 0,
            "CLAIM ERROR : User already claimed tokens!"
        );
        require(
            !users_list[_msgSender()].has_claimed,
            "CLAIM ERROR : User already claimed tokens"
        );

        uint256 tokens_to_claim = users_list[_msgSender()].tokens_amount;
        users_list[_msgSender()].tokens_amount = 0;
        users_list[_msgSender()].has_claimed = true;

        (bool success, ) = address(token_interface).call(
            abi.encodeWithSignature(
                "transfer(address,uint256)",
                msg.sender,
                tokens_to_claim
            )
        );
        require(success, "CLAIM ERROR : Couldn't transfer tokens to client!");

        return true;
    }

This function

Checks if presale has ended
Verifies user has tokens to claim and hasn't claimed before
Retrieves and stores user's claimable token amount
Resets user's token balance to 0 and marks as claimed
Transfers tokens to user using the token contract interface
Returns true on successful claim

Withdraw Token

 function withdrawToken(address tokenContract, uint256 amount) external onlyOwner {
        IERC20(tokenContract).transfer(_msgSender(), amount);
    }

This function

Is restricted to contract owner only through onlyOwner modifier
Allows owner to withdraw any ERC20 token from the contract
Takes token contract address and amount as parameters
Transfers specified amount to the owner's address

Round Management

We also need to define functions to manage the rounds:

  function start_next_round(
        address payable wallet_,
        uint256 usdt_to_token_rate_,
        uint256 usdt_round_cap_
    ) external onlyOwner {
        current_round_index = current_round_index + 1;

        round_list.push(
            Round(wallet_, usdt_to_token_rate_, 0, usdt_round_cap_ * (10**6))
        );
    }

  function set_current_round(
        address payable wallet_,
        uint256 usdt_to_token_rate_,
        uint256 usdt_round_cap_
    ) external onlyOwner {
        round_list[current_round_index].wallet = wallet_;
        round_list[current_round_index]
            .usdt_to_token_rate = usdt_to_token_rate_;
        round_list[current_round_index].usdt_round_cap = usdt_round_cap_ * (10**6);
    }

  function get_current_round()
        external
        view
        returns (
            address,
            uint256,
            uint256,
            uint256
        )
    {
        return (
            round_list[current_round_index].wallet,
            round_list[current_round_index].usdt_to_token_rate,
            round_list[current_round_index].usdt_round_raised,
            round_list[current_round_index].usdt_round_cap
        );
    }

  function get_current_raised() external view returns (uint256) {
        return round_list[current_round_index].usdt_round_raised;
    }

Conclusion

This ERC20 token contract and Presale contract is a comprehensive and secure solution for conducting token presales. It provides features for managing presale rounds, depositing USDT, claiming tokens, withdrawing tokens, and managing rounds. The contract is designed to be flexible and customizable for different presale scenarios.