DEV Community: Keshav Sharma

The Crypto Invoicing Problem Nobody Talks About — And Why We Built Settlematic

Keshav Sharma — Sat, 20 Jun 2026 22:12:56 +0000

For all the innovation happening in crypto, one of the most important business workflows remains surprisingly broken: invoicing.

Over the last few years, cryptocurrencies and stablecoins have transformed how money moves across borders. Businesses can now receive payments globally within minutes, freelancers can work with clients anywhere in the world, and SaaS companies can reach customers without relying entirely on traditional banking infrastructure.

Yet despite these advancements, the process of invoicing and collecting payments in crypto remains far more complicated than it should be.

Most businesses accepting cryptocurrency today are still relying on a patchwork of spreadsheets, wallet addresses, manual reconciliation, and disconnected tools. The blockchain may be programmable money, but the invoicing experience often feels stuck in the early days of the internet.

At Settlematic, we believe crypto payments should be as simple, professional, and automated as traditional invoicing—while preserving all the advantages that blockchain technology brings.

This article explores the challenges businesses face when invoicing in crypto, why existing solutions fall short, and how Settlematic is building the infrastructure needed for the next generation of global commerce.

The Hidden Complexity of Crypto Invoicing

On the surface, accepting cryptocurrency seems simple.

A business generates a wallet address.

The customer sends funds.

Payment received.

Problem solved.

Unfortunately, reality is much messier.

As soon as businesses begin processing more than a handful of transactions, operational complexity starts to grow rapidly.

Consider a company that sends 100 invoices every month.

Questions immediately begin to emerge:

Which payment belongs to which invoice?
What happens if a customer pays using a different token?
What happens if they make multiple payments?
How do you manage recurring invoices?
How do finance teams track outstanding balances?
How do you calculate discounts and penalties?
How do you automate revenue sharing?
How do you generate tax reports?

Most crypto payment tools solve only a small portion of this workflow.

The result is a growing administrative burden that becomes increasingly difficult to manage as businesses scale.

Why Wallet Addresses Are Not Invoices

One of the biggest misconceptions in crypto payments is that a wallet address is equivalent to an invoice.

It isn't.

A wallet address simply tells someone where funds should be sent.

An invoice provides context.

An invoice answers questions such as:

Who is paying?
What are they paying for?
When is payment due?
Has the payment been completed?
Is the invoice partially paid?
Are there late fees?
Are there discounts?
What accounting records should be created?

Traditional businesses have spent decades refining invoicing processes because they are essential for managing cash flow.

Crypto businesses deserve the same level of sophistication.

The Multi-Token Reality

One challenge unique to crypto is the existence of multiple assets.

Imagine issuing a $1,000 invoice.

One customer holds USDT.

Another holds USDC.

A third holds ETH.

A fourth holds MATIC.

A fifth holds a mix of all four.

Most existing systems force the customer to swap assets before paying.

This introduces:

Additional fees
Extra steps
Friction
Delays
Failed payments

In many cases, customers simply postpone payment because the process becomes inconvenient.

Businesses lose time.

Customers experience frustration.

Nobody wins.

Partial Payments Shouldn't Be A Problem

Traditional invoicing systems have supported partial payments for years.

Crypto invoicing platforms often struggle with this.

Imagine a customer owes $5,000.

Instead of paying in one transaction, they send:

$2,000 in USDT
$1,500 in USDC
$1,500 in ETH

From the customer's perspective, the invoice has been fully paid.

From the business perspective, however, reconciliation can become a nightmare.

Someone has to manually verify each transaction and determine whether the invoice balance has been settled.

This is exactly the type of operational work that software should eliminate.

With Settlematic, invoices can be paid through multiple transactions and even multiple supported cryptocurrencies.

The platform automatically tracks every payment, reconciles balances, and marks invoices as completed once payment obligations have been fulfilled.

The customer gets flexibility.

The business gets automation.

The Problem With Shared Wallet Addresses

Many businesses receive all payments into a single wallet.

This seems convenient initially.

However, as transaction volume grows, tracking becomes increasingly difficult.

A finance team may receive hundreds or thousands of incoming transactions.

Determining which transaction corresponds to which invoice becomes a manual exercise involving blockchain explorers, spreadsheets, and accounting systems.

This process consumes valuable time and introduces opportunities for human error.

Settlematic addresses this by generating dedicated payment addresses for invoices, allowing every payment to be tracked and associated with the correct transaction context.

The result is cleaner accounting and dramatically simpler reconciliation.

Automating Treasury Management

Receiving funds is only the first step.

Businesses also need to decide what happens next.

In many organizations, incoming funds must be distributed across multiple wallets, departments, partners, or operational accounts.

Without automation, teams perform these transfers manually.

Manual treasury management creates operational risk and consumes time.

This challenge inspired one of Settlematic's most powerful capabilities: Conversion Flows.

Using configurable workflows, businesses can automatically define how incoming funds should be handled.

For example:

80% to treasury wallet
20% to operational wallet

Or:

50% to partner wallet
30% to reserve wallet
20% to tax wallet

The allocation happens automatically according to predefined rules.

No spreadsheets.

No manual transfers.

No repetitive operational work.

Introducing Auto Sweep

One issue frequently encountered by businesses using dedicated invoice addresses is wallet management.

If every invoice generates a new address, funds become distributed across many wallets.

Managing those balances manually becomes inefficient.

Settlematic solves this through Auto Sweep.

Once invoice payments are confirmed, assets can be automatically transferred to designated destination wallets.

Businesses retain the organizational advantages of dedicated invoice addresses while maintaining centralized custody of funds.

The experience becomes seamless.

Smart Invoices For Modern Businesses

Traditional invoices are static documents.

Real-world business relationships are dynamic.

Many companies incentivize early payments.

Others apply late payment penalties.

Historically, these calculations have required manual intervention.

Settlematic introduces Smart Invoices that automatically adapt based on payment timing.

Businesses can configure:

Early payment discounts
Late payment fees
Dynamic invoice calculations

The platform automatically adjusts invoice values according to predefined business rules.

This creates a more intelligent and automated accounts receivable process.

Recurring Revenue Deserves Better Infrastructure

Subscription businesses are becoming increasingly common across the crypto economy.

DAOs, SaaS platforms, agencies, service providers, and consulting firms often operate on recurring billing cycles.

Yet recurring crypto invoicing remains surprisingly underdeveloped.

Many businesses still create recurring invoices manually every month.

This approach doesn't scale.

Settlematic enables automated recurring invoicing workflows that generate and distribute invoices according to predefined schedules.

Businesses can focus on growth instead of administrative tasks.

Professional Payment Experiences Matter

First impressions matter.

A customer receiving a random wallet address in a message does not inspire confidence.

Businesses need professional payment experiences that reinforce trust and brand identity.

Settlematic provides hosted invoice payment pages with custom branding capabilities.

Businesses can:

Upload logos
Configure brand colors
Create consistent customer experiences
Present professional payment interfaces

The result is a significantly improved customer experience that aligns with modern business expectations.

APIs, Webhooks, And Automation

Modern businesses rarely operate using a single piece of software.

They rely on interconnected systems.

CRMs.

Accounting platforms.

ERP systems.

Analytics tools.

Payment infrastructure.

Automation therefore becomes essential.

Settlematic includes APIs and webhooks that allow organizations to integrate invoicing workflows directly into existing systems.

Businesses can:

Create invoices programmatically
Receive payment notifications
Synchronize accounting data
Build custom workflows
Automate reporting

The platform becomes an infrastructure layer rather than simply another standalone application.

AI-Native Financial Operations

Artificial intelligence is rapidly changing how businesses operate.

The next generation of financial software will not be built around forms and dashboards alone.

It will be conversational.

It will be automated.

It will be AI-native.

This is why Settlematic includes support for AI-driven interactions through its MCP capabilities.

Businesses can interact with invoice data using AI assistants.

Imagine asking:

"Create an invoice for Client A."

"Show overdue invoices."

"Generate tax reports."

"Send payment reminders."

"Show revenue by month."

Instead of navigating multiple screens, users can perform tasks through natural language interactions.

This is where financial operations are heading.

We believe crypto invoicing should be ready for that future today.

Tax Reporting Cannot Be An Afterthought

One of the largest barriers to crypto adoption for businesses is compliance.

Receiving payments is easy.

Maintaining accurate records is harder.

Generating reports for accounting and tax purposes is even harder.

Without proper tooling, businesses often rely on manual exports and spreadsheets.

Settlematic includes foundational tax reporting capabilities that help organizations maintain cleaner records and improve financial visibility.

As regulatory environments continue to evolve globally, reporting infrastructure will become increasingly important.

Building The Future Of Crypto Commerce

The long-term vision behind Settlematic extends beyond invoicing.

We believe businesses need an operating system for crypto receivables.

A platform that handles:

Invoice generation
Payment collection
Reconciliation
Treasury automation
Revenue distribution
Reporting
Compliance
AI-powered workflows

Crypto has already transformed how value moves across the internet.

The next challenge is making those payment flows operationally efficient for businesses.

That is the problem we are focused on solving.

Final Thoughts

The crypto industry has built incredible innovations around trading, custody, staking, and decentralized finance.

Yet everyday business operations still lack the infrastructure that traditional companies take for granted.

Invoicing may not be the most glamorous problem in crypto.

But it is one of the most important.

Because businesses do not grow through speculation.

They grow through revenue.

They grow through customers.

They grow through getting paid.

At Settlematic, our mission is simple:

Make crypto invoicing as professional, automated, and scalable as modern businesses expect it to be.

And in doing so, help accelerate the adoption of crypto as a legitimate payment method for businesses around the world.

Stellar360: The Ultimate Stellar Wallet, Exchange, Payment Gateway, and Faucet with Integrated Staking

Keshav Sharma — Sun, 18 Aug 2024 20:52:00 +0000

This is a submission for the Build Better on Stellar: Smart Contract Challenge : Build a dApp

What I Built

Stellar360: A Comprehensive Stellar WebApp with Wallet, Exchange, Staking, Payment Gateway, and Faucet Functionality

Stellar360 is a sophisticated web application developed using Next.js, Node.js, and PostgreSQL, designed to offer an all-in-one solution for Stellar-based transactions.

The platform features:

Wallet Functionality: Users can register, and upon successful registration, a wallet is automatically created. The wallet supports custom tokens—STLLRUSDC, STLLRUSDT, STLLRBTC, and STLLRCSH—allowing users to view and manage their balances.

Token Faucet: Users can utilize the faucet to add tokens to their wallet and check their balances in real-time.

Token Exchange: Users can exchange one token for another seamlessly within the app.

Staking: The app supports staking of tokens with flexible time periods (7, 15, 30, 60, and 90 days). A custom smart contract, built using Soroban Stellar, manages the staking process and credits the tokens back to users' wallets at the end of the staking period. A master wallet is used to distribute the earned tokens to users.

Payment Gateway: Users can generate multiple child wallets for their websites. These wallets facilitate payments from customers, with successful transactions triggering WebSocket notifications to complete orders. Each customer gets a unique wallet for processing payments.

Paymaster Contract: To ensure smooth transactions, a paymaster contract is implemented to cover transaction fees in XLM. This contract enhances user experience by making transactions frictionless and cost-effective.

Automated Trustlines: Trustlines for the custom tokens are automatically created, ensuring seamless and successful transactions.

Whole code can be checked by referring the github links, Below are some code snippets which are the backbone contracts for this project -

Paymaster contract
The paymaster contract on Stellar is designed to pay for the transaction fees (in XLM) for users who do not have XLM in their accounts. The contract will also support whitelisting of addresses that are authorized to use the paymaster's services.

Features:

Pay for Transaction Fees: The paymaster covers the XLM fees for transactions initiated by whitelisted addresses.
Whitelist Management: Admin can add or remove addresses from the whitelist.

Components:

Paymaster Contract: Manages the payment of transaction fees.
Whitelist Management: Allows adding/removing addresses to/from the whitelist.

use soroban_sdk::{contractimpl, Address, Env, Symbol, Vec};

pub struct Paymaster;

#[contractimpl]
impl Paymaster {
    // Initialize the contract with an admin address
    pub fn initialize(env: Env, admin: Address) {
        let whitelist = Vec::new();
        env.storage().set(&Symbol::from("admin"), &admin);
        env.storage().set(&Symbol::from("whitelist"), &whitelist);
    }

    // Add an address to the whitelist
    pub fn add_to_whitelist(env: Env, address: Address) {
        let admin = env.storage().get::<Address>(&Symbol::from("admin")).unwrap();
        if env.caller() != admin {
            panic!("Only admin can add to whitelist");
        }

        let mut whitelist: Vec<Address> = env.storage().get(&Symbol::from("whitelist")).unwrap();
        if !whitelist.contains(&address) {
            whitelist.push(address);
            env.storage().set(&Symbol::from("whitelist"), &whitelist);
        }
    }

    // Remove an address from the whitelist
    pub fn remove_from_whitelist(env: Env, address: Address) {
        let admin = env.storage().get::<Address>(&Symbol::from("admin")).unwrap();
        if env.caller() != admin {
            panic!("Only admin can remove from whitelist");
        }

        let mut whitelist: Vec<Address> = env.storage().get(&Symbol::from("whitelist")).unwrap();
        whitelist.retain(|a| a != &address);
        env.storage().set(&Symbol::from("whitelist"), &whitelist);
    }

    // Check if an address is whitelisted
    pub fn is_whitelisted(env: Env, address: Address) -> bool {
        let whitelist: Vec<Address> = env.storage().get(&Symbol::from("whitelist")).unwrap();
        whitelist.contains(&address)
    }

    // Pay for transaction fees
    pub fn pay_transaction_fee(env: Env, source: Address, fee: u64) {
        if !Self::is_whitelisted(env.clone(), source.clone()) {
            panic!("Address not whitelisted");
        }

        // Here, you would include logic to cover the fee.
        // This typically involves interacting with Stellar to handle the fee.
        // For demonstration purposes, we'll print the action.
        println!("Paying {} XLM for transaction fee for {}", fee, source);
    }
}

Staking Contract

The contract allows users to stake tokens for predefined periods, earning rewards based on the duration of their stake.

Features

Staking Periods: Users can choose from five staking periods—7, 15, 30, 60, or 90 days.
Reward Percentages: The reward percentage increases with the length of the staking period—0.1%, 2%, 5%, 10%, or 15%.
Token Management: Users can stake tokens, and after the staking period ends, they can claim their tokens along with the rewards.

use soroban_sdk::{contractimpl, symbol, Address, Env, Symbol};

#[derive(Clone, Copy, Debug)]
pub enum StakingPeriod {
    SevenDays,
    FifteenDays,
    ThirtyDays,
    SixtyDays,
    NinetyDays,
}

#[derive(Clone, Copy, Debug)]
pub enum RewardPercentage {
    PointOnePercent,
    TwoPercent,
    FivePercent,
    TenPercent,
    FifteenPercent,
}

pub struct StakingContract;

#[contractimpl]
impl StakingContract {
    pub fn stake_tokens(env: Env, user: Address, amount: u64, period: StakingPeriod) {
        // Logic to handle token staking
        let current_time = env.ledger().now();
        let end_time = match period {
            StakingPeriod::SevenDays => current_time + 7 * 24 * 60 * 60,
            StakingPeriod::FifteenDays => current_time + 15 * 24 * 60 * 60,
            StakingPeriod::ThirtyDays => current_time + 30 * 24 * 60 * 60,
            StakingPeriod::SixtyDays => current_time + 60 * 24 * 60 * 60,
            StakingPeriod::NinetyDays => current_time + 90 * 24 * 60 * 60,
        };

        // Store staking information
        let staking_info = StakingInfo {
            amount,
            end_time,
            period,
        };

        // Here, you would typically store this information in a state variable
        // For demonstration, we will just print it
        env.log(&format!(
            "User: {:?}, Amount: {}, End Time: {}, Period: {:?}",
            user, amount, end_time, period
        ));
    }

    pub fn claim_rewards(env: Env, user: Address) {
        // Logic to calculate and distribute rewards
        // This would involve checking if the staking period is over
        // and calculating rewards based on the stored staking info

        // For demonstration, we will just print a message
        env.log(&format!("User: {:?} claiming rewards", user));
    }
}

#[derive(Clone, Debug)]
pub struct StakingInfo {
    amount: u64,
    end_time: u64,
    period: StakingPeriod,
}

Demo

You can explore the Stellar360 dApp through the following link: Live Demo

My Code

The source code for Stellar360 is available on GitHub:

Frontend Repository: Link to Frontend Repository
Backend Repository: Link to Backend Repository

Journey

Developing Stellar360 has been an exciting and challenging journey. The project began with the goal of creating a unified platform to manage and interact with Stellar assets, incorporating wallet, exchange, staking, and payment functionalities.

Implementation and Smart Contract Design:

Smart Contracts: We utilized Soroban Stellar to create a custom smart contract for managing staking, ensuring accurate token credits at the end of each staking period.
Paymaster Contract: The paymaster contract was designed to handle transaction fees, thus eliminating the need for users to hold XLM for transaction costs.

Motivation:

Our motivation was to simplify the user experience by integrating multiple features into a single platform, providing users with a seamless and efficient way to manage their Stellar assets.

Learning and Experience:

Throughout the development process, we deepened our understanding of Stellar’s ecosystem, smart contract capabilities, and efficient token management. We also gained insights into integrating various functionalities to enhance user experience.

Pride and Future Goals:
We are particularly proud of the seamless integration of diverse functionalities and the automation of trustline creation. Moving forward, we aim to refine the user experience further, gather user feedback, and explore additional enhancements based on real-world usage.