Forem: susheel kumar

Stop Building Auth From Scratch — Meet authwall: The Plug-and-Play Auth System for Express

susheel kumar — Tue, 12 May 2026 11:54:56 +0000

The Problem

Every Node.js developer knows the drill. You're building an Express app, and suddenly you need:

User authentication
Role-based access control
Admin panels
Audit logs
Rate limiting
2FA support

That's days of coding, testing, and debugging security vulnerabilities.

The Solution

Meet authwall — a complete, production-ready authentication system that drops into any Express + MongoDB app in 60 seconds.

// That's literally it
const { authwall } = require('authwall');
authwall(app, { config: { jwt: { secret: process.env.JWT_SECRET } } });

What You Get Out of the Box

Feature	Status
Email OTP login	✅
JWT authentication	✅
Role-based access (RBAC)	✅
Full admin REST API	✅
User suspension/banning	✅
Two-factor authentication (TOTP)	✅
Audit logs with request IDs	✅
Rate limiting	✅
CSV user export	✅
Bulk operations	✅
Impersonation mode	✅
Event system for webhooks	✅

Why Developers Love It

"I was about to spend 3 days building auth. authwall took 10 minutes." — Senior Backend Engineer

"The audit logs alone saved us during a security compliance audit." — CTO, SaaS Startup

"Finally, an auth package that doesn't force its own user model." — Full-stack Developer

Quick Start

npm install authwall

const express = require('express');
const mongoose = require('mongoose');
const { authwall } = require('authwall');

const app = express();
app.use(express.json());

mongoose.connect('mongodb://localhost:27017/myapp');

authwall(app, {
  seed: true,
  config: {
    jwt: { secret: process.env.JWT_SECRET },
    email: {
      from: 'noreply@myapp.com',
      transport: { host: 'smtp.gmail.com', port: 587, auth: {...} }
    }
  }
});

app.listen(3000);

That's it. You now have:

POST /api/auth/otp/send — send login code
POST /api/auth/otp/verify — verify & get JWT
GET /api/auth/me — get current user
GET /api/admin/users — list all users
POST /api/admin/users/:id/suspend — suspend a user
...and 25+ more endpoints

Real-World Example

Want to let admins suspend bad actors?

# Admin logs in
curl -X POST /api/auth/otp/send -d '{"email":"admin@company.com"}'
curl -X POST /api/auth/otp/verify -d '{"email":"admin@company.com","code":"123456"}'
# → Returns JWT token

# Suspend a problematic user
curl -X POST /api/admin/users/user_123/suspend \
  -H "Authorization: Bearer <token>"

Want to know when users log in?

const { events, EVENTS } = require('authwall');

events.on(EVENTS.LOGIN_SUCCESS, (data) => {
  console.log(`✅ ${data.email} logged in from ${data.ip}`);
  // Send to Slack, DataDog, webhook, etc.
});

Works With Your Existing User Model

// Your existing User schema
const userSchema = new mongoose.Schema({
  name: String,
  email: String,
  subscriptionTier: String
});

// Just add authwall fields
const { addUserAdminFields } = require('authwall');
addUserAdminFields(userSchema); // Adds roles, status, 2FA fields

authwall(app, { getUserModel: () => mongoose.model('User', userSchema) });

Security Built-In

No default JWT secrets — you must provide one
Rate limiting on OTP endpoints — prevents brute force
Admin self-protection — can't suspend/delete themselves
Audit logs with request IDs — trace every admin action
Session termination — revoke all user sessions with one call

What's Coming

[ ] Social logins (Google, GitHub)
[ ] Password-based authentication
[ ] WebAuthn/Passkeys support
[ ] OpenAPI/Swagger generation

Get Started Today

npm install authwall

📖 Full Documentation

🐛 Report Issues

⭐ Star on GitHub

About the Author

Susheel Kumar — Full-stack developer building tools that make developers' lives easier.

📧 susheelhbti@gmail.com — Open for freelance & full-time opportunities.

📘 Complete User Guide

Getting Started with authwall

Installation
Basic Setup
Configuration
Authentication Flow
Admin Operations
Role-Based Access Control
Two-Factor Authentication
Event System
Production Deployment
Troubleshooting

1. Installation

npm install authwall

Requirements:

Node.js ≥ 18
Express ≥ 4
Mongoose ≥ 8
MongoDB running instance

2. Basic Setup

Minimal Working Example

Create app.js:

const express = require('express');
const mongoose = require('mongoose');
const { authwall } = require('authwall');

const app = express();
app.use(express.json());

// Connect to MongoDB
mongoose.connect('mongodb://localhost:27017/myapp');

// Initialize authwall
authwall(app, {
  seed: true,  // Creates default roles: admin, user, moderator
  config: {
    jwt: {
      secret: process.env.JWT_SECRET || 'your-super-secret-key-change-this',
    },
    email: {
      from: 'noreply@yourapp.com',
      transport: {
        host: 'smtp.gmail.com',
        port: 587,
        secure: false,
        auth: {
          user: process.env.EMAIL_USER,
          pass: process.env.EMAIL_PASS,
        },
      },
    },
  },
});

app.listen(3000, () => {
  console.log('Server running on http://localhost:3000');
});

Environment Variables (.env)

# Required
JWT_SECRET=your-super-secret-jwt-key-min-32-chars

# Email configuration
EMAIL_USER=your-email@gmail.com
EMAIL_PASS=your-app-password

# Optional
CORS_ORIGIN=https://yourapp.com
PORT=3000
MONGODB_URI=mongodb://localhost:27017/myapp

3. Configuration

Full Configuration Options

authwall(app, {
  // Seed default roles on startup
  seed: true,

  // Auto-clean expired OTPs every 15min
  cleanupCron: true,

  // Use your own User model (optional)
  getUserModel: () => require('./models/User'),

  config: {
    // Route prefix for all endpoints
    routePrefix: '/api',

    // Global middleware before auth routes
    routeMiddleware: [logger, cors],

    // OTP settings
    otp: {
      expiresInMinutes: 5,
      maxAttempts: 3,
      rateLimitCount: 3,
      rateLimitMinutes: 5,
      codeLength: 6,
    },

    // JWT settings
    jwt: {
      secret: process.env.JWT_SECRET,  // Required
      expiresIn: '7d',  // 7 days
    },

    // Role defaults
    defaultRoleSlug: 'user',
    adminRoleSlug: 'admin',

    // Auto-register new users on OTP verify
    autoRegister: true,

    // Pagination default
    perPage: 15,

    // Rate limiting
    rateLimit: {
      windowMs: 15 * 60 * 1000,  // 15 minutes
      max: 5,  // max OTP attempts
    },

    // CORS
    cors: {
      enabled: true,
      origin: process.env.CORS_ORIGIN || '*',
      credentials: true,
    },

    // Email
    email: {
      from: 'noreply@yourapp.com',
      transport: { /* nodemailer config */ },
    },
  },
});

4. Authentication Flow

Step 1: Send OTP

POST /api/auth/otp/send
Content-Type: application/json

{
  "email": "user@example.com"
}

Response:

{
  "success": true,
  "message": "OTP sent successfully",
  "expires_in_minutes": 5
}

Step 2: Verify OTP

POST /api/auth/otp/verify
Content-Type: application/json

{
  "email": "user@example.com",
  "code": "123456"
}

Response:

{
  "success": true,
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "user": {
    "_id": "65abc123...",
    "email": "user@example.com",
    "role": "user",
    "status": "active"
  }
}

Step 3: Use JWT Token

GET /api/auth/me
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...

Step 4: Logout

POST /api/auth/logout
Authorization: Bearer <token>

5. Admin Operations

First Admin Setup

The first user who logs in with autoRegister: true gets the user role. To create an admin:

Option 1: Via MongoDB directly

// Run in MongoDB shell or Compass
db.users.updateOne(
  { email: "admin@example.com" },
  { $set: { role: "admin", status: "active" } }
)

Option 2: Create admin programmatically

const User = mongoose.model('User');
await User.create({
  email: 'admin@example.com',
  role: 'admin',
  status: 'active'
});

Admin API Endpoints

List Users with Filters

GET /api/admin/users
Authorization: Bearer <admin-token>

# With filters
GET /api/admin/users?status=suspended&role=user&search=john&page=2&sort_by=createdAt_desc

Get User Details

GET /api/admin/users/:userId

Suspend User

POST /api/admin/users/:userId/suspend
Authorization: Bearer <admin-token>

# Optional body
{
  "reason": "Violated terms of service"
}

Temporary Ban

POST /api/admin/users/:userId/temporary-ban
{
  "duration_hours": 24,
  "reason": "Spamming"
}

Force Password Reset

POST /api/admin/users/:userId/force-password-reset
# Sends email to user with reset link

Impersonate User

POST /api/admin/users/:userId/impersonate
# Returns a special JWT that acts as the target user

# Stop impersonation
POST /api/admin/users/stop-impersonation

Terminate All Sessions

POST /api/admin/users/:userId/terminate-sessions
# Revokes all refresh tokens for this user

Bulk Operations

# Bulk suspend
POST /api/admin/users/bulk/suspend
{
  "user_ids": ["id1", "id2", "id3"]
}

# Bulk assign role
POST /api/admin/users/bulk/assign-role
{
  "user_ids": ["id1", "id2"],
  "role": "moderator"
}

Export Users to CSV

GET /api/admin/users/export
Authorization: Bearer <admin-token>
# Downloads CSV with all user data

View Audit Logs

GET /api/admin/admin-logs
# Shows all admin actions with timestamps, IPs, request IDs

Statistics

GET /api/admin/statistics

Response:

{
  "total_users": 1542,
  "active_users": 1289,
  "suspended_users": 42,
  "admins": 3,
  "users_by_role": {
    "admin": 3,
    "moderator": 12,
    "user": 1527
  },
  "users_by_status": {
    "active": 1289,
    "suspended": 42,
    "banned": 211
  }
}

6. Role-Based Access Control

Default Roles

Role	Permissions
`admin`	Full access to all admin endpoints
`moderator`	Can view users, suspend/unsuspend, but cannot delete or access sensitive settings
`user`	Can only access their own profile

Creating Custom Roles

const Role = mongoose.model('Role');

await Role.create({
  name: 'Content Manager',
  slug: 'content-manager',
  permissions: [
    'users:read',
    'posts:create',
    'posts:edit',
    'posts:delete'
  ]
});

Protecting Routes with Middleware

const { makeAuthMiddleware, makeRoleMiddleware } = require('authwall');

const auth = makeAuthMiddleware(config, () => User);
const requireModerator = makeRoleMiddleware('moderator');
const requireAdmin = makeRoleMiddleware('admin');

// Public route
app.get('/api/public', (req, res) => {...});

// Any authenticated user
app.get('/api/profile', auth, (req, res) => {
  res.json(req.user);
});

// Moderator only
app.post('/api/moderate/comment', auth, requireModerator, handler);

// Admin only
app.delete('/api/admin/users/:id', auth, requireAdmin, handler);

7. Two-Factor Authentication

Enabling 2FA for a User

const { generateTOTPSecret } = require('authwall');

// Generate secret and QR code
const { secret, qrCodeUrl } = await generateTOTPSecret(user.email);

// Store secret temporarily or with user
user.twoFactorSecret = secret;
await user.save();

// Send QR code to user (via email or display in UI)

Verifying 2FA During Login

Step 1: Normal OTP verification

POST /api/auth/otp/verify
{
  "email": "user@example.com",
  "code": "123456"
}

If 2FA is enabled, response:

{
  "requires_2fa": true,
  "otp_id": "otp_session_123",
  "message": "Two-factor authentication required."
}

Step 2: Submit TOTP code

POST /api/auth/otp/verify
{
  "otp_id": "otp_session_123",
  "code": "123456",
  "totp_token": "654321"
}

Or use backup code:

{
  "otp_id": "otp_session_123",
  "code": "123456",
  "backup_code": "ABCD-EFGH-IJKL-MNOP"
}

Disabling 2FA (Admin)

POST /api/admin/users/:userId/remove-2fa
Authorization: Bearer <admin-token>

8. Event System

Available Events

const { events, EVENTS } = require('authwall');

// Authentication events
events.on(EVENTS.LOGIN_SUCCESS, (data) => {
  // data: { userId, email, ip, userAgent, timestamp }
});

events.on(EVENTS.LOGIN_FAILED, (data) => {
  // data: { email, ip, reason }
});

events.on(EVENTS.OTP_SENT, (data) => {
  // data: { email, expiresIn }
});

// User management events
events.on(EVENTS.USER_CREATED, (data) => {
  // data: { user, createdBy }
});

events.on(EVENTS.USER_SUSPENDED, (data) => {
  // data: { userId, email, reason, suspendedBy }
});

// Admin events
events.on(EVENTS.ADMIN_ACTION, (data) => {
  // data: { adminId, action, target, ip, requestId }
});

// 2FA events
events.on(EVENTS.TFA_ENABLED, (data) => {
  // data: { userId, email }
});

events.on(EVENTS.TFA_FAILED, (data) => {
  // data: { userId, email, ip, attemptCount }
});

Real-World Examples

Send Slack Alert on Suspicious Activity:

const { events, EVENTS } = require('authwall');
const axios = require('axios');

events.on(EVENTS.LOGIN_FAILED, async (data) => {
  if (data.reason === 'too_many_attempts') {
    await axios.post(process.env.SLACK_WEBHOOK, {
      text: `🚨 Brute force attempt detected on ${data.email} from ${data.ip}`
    });
  }
});

Track User Metrics:

const metrics = {
  logins: 0,
  newUsers: 0,
  suspensions: 0
};

events.on(EVENTS.LOGIN_SUCCESS, () => metrics.logins++);
events.on(EVENTS.USER_CREATED, () => metrics.newUsers++);
events.on(EVENTS.USER_SUSPENDED, () => metrics.suspensions++);

// Expose metrics endpoint
app.get('/metrics', (req, res) => res.json(metrics));

Send Welcome Email:

events.on(EVENTS.USER_CREATED, async (data) => {
  await sendWelcomeEmail(data.user.email);
});

9. Production Deployment

Security Checklist

[ ] Set strong JWT_SECRET (32+ chars, random)
[ ] Enable HTTPS
[ ] Configure CORS properly (not * in production)
[ ] Set appropriate rate limits
[ ] Use environment variables for all secrets
[ ] Enable MongoDB authentication
[ ] Regularly backup audit logs
[ ] Monitor admin logs for suspicious activity

Multi-Server Setup (Load Balancing)

For multiple server instances, configure shared rate limiting with Redis:

npm install rate-limit-redis ioredis

const { rateLimit } = require('express-rate-limit');
const RedisStore = require('rate-limit-redis');
const Redis = require('ioredis');

const sharedLimiter = rateLimit({
  store: new RedisStore({
    client: new Redis(process.env.REDIS_URL)
  }),
  windowMs: 15 * 60 * 1000,
  max: 5
});

// Apply to authwall routes
authwall(app, {
  config: {
    rateLimit: sharedLimiter
  }
});

Performance Optimization

// Use indexes for large user bases
const User = mongoose.model('User');
User.createIndexes({ email: 1, status: 1, role: 1 });

// Enable Mongoose debug in development (not production)
mongoose.set('debug', process.env.NODE_ENV === 'development');

Monitoring with PM2

# ecosystem.config.js
module.exports = {
  apps: [{
    name: 'myapp',
    script: 'app.js',
    instances: 2,
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'production',
      JWT_SECRET: process.env.JWT_SECRET
    }
  }]
};

Docker Deployment

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
EXPOSE 3000
CMD ["node", "app.js"]

# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - MONGODB_URI=mongodb://mongodb:27017/myapp
      - JWT_SECRET=${JWT_SECRET}
    depends_on:
      - mongodb
  mongodb:
    image: mongo:6
    volumes:
      - mongodb_data:/data/db
volumes:
  mongodb_data:

10. Troubleshooting

Common Issues

Issue: "JWT secret is required"

# Set environment variable
export JWT_SECRET="your-strong-secret-here"
# Or in .env file
echo "JWT_SECRET=your-secret" >> .env

Issue: OTP emails not sending

// Test email configuration
const nodemailer = require('nodemailer');
const transporter = nodemailer.createTestAccount((err, account) => {
  console.log('Test account:', account);
});

Issue: User can't login after suspension

// Check user status
const user = await User.findOne({ email: 'user@example.com' });
console.log('Status:', user.status); // Should be 'active'
console.log('Suspended until:', user.suspendedUntil);

// Unsuspend manually
user.status = 'active';
user.suspendedUntil = null;
await user.save();

Issue: Rate limiting too aggressive

// Increase limits
authwall(app, {
  config: {
    rateLimit: {
      windowMs: 15 * 60 * 1000,
      max: 20  // Allow 20 attempts per 15 minutes
    }
  }
});

Issue: "User model not found"

// Register model before authwall
const User = mongoose.model('User', userSchema);
authwall(app, { getUserModel: () => User });

Debug Mode:

// Enable debug logging
process.env.DEBUG = 'authwall:*';
const { authwall } = require('authwall');

Support & Community

GitHub Issues: Report bugs
NPM Package: authwall
Author Email: susheelhbti@gmail.com

License

MIT © Susheel Kumar

Introducing payx3: The All-in-One SDK to Simplify Multi-Chain Crypto Payments

susheel kumar — Tue, 12 May 2026 01:13:37 +0000

In the rapidly evolving world of Web3, developers face a persistent headache: fragmentation. If you want to accept Bitcoin, you need one library. For Ethereum, another. For Solana, yet another. Managing multiple chains, tracking different token decimals, and monitoring transaction confirmations usually results in a bloated, unmaintainable codebase.

Enter payx3—a powerful, lightweight Multi-Chain Crypto Payment SDK designed to let you generate wallets and watch for incoming payments across almost any major chain with a single function call.

🚀 Why payx3?

The goal of payx3 is simple: Reduce the complexity of crypto integrations to zero. Whether you are building an e-commerce checkout, a donation platform, or a decentralized app, payx3 handles the heavy lifting of blockchain monitoring so you can focus on your product.

Key Features:

Universal Wallet Generation: Generate a single 12-word mnemonic and derive addresses for Bitcoin (Legacy, SegWit, Native SegWit), Solana, and all EVM chains (ETH, BNB, Polygon, etc.).
"Watch Everything" Mode: A single function to monitor BTC, ETH, SOL, and dozens of ERC-20 tokens simultaneously.
Decimal Perfection: No more math errors. payx3 automatically handles decimal conversions (like the 6-decimal USDT on Ethereum vs. 18-decimal on BNB Chain).
Real-time Callbacks: Get instant notifications when a payment is detected (onPayment) and when it is finalized on the block (onConfirmed).
REST API Ready: It comes with a built-in Express.js server example, allowing you to run your own payment gateway in minutes.

🛠 Quick Start

Getting started is as easy as installing the package:

npm install payx3

One Wallet, All the Chains

You don't need separate setups for different assets. Generate a master key and get all your addresses at once:

const { generateMnemonic, deriveAll } = require("payx3");

const mnemonic = generateMnemonic(128);
const wallet = await deriveAll(mnemonic);

console.log("BTC Address:", wallet.bitcoin[2].address); // Native SegWit
console.log("EVM Address:", wallet.evm.address);         // ETH, BNB, Polygon, etc.
console.log("SOL Address:", wallet.solana.address);

Monitoring Payments

Forget complex WebSockets or polling logic. Use watchAll to monitor every asset you care about across every supported chain in one go:

const { watchAll } = require("payx3");

watchAll({
  btcAddress: "bc1q...",
  evmAddress: "0x...",
  solAddress: "Azj...",
  infuraKey: "YOUR_INFURA_KEY",
  onPayment: (payment) => {
    console.log(`💸 Received ${payment.amount} ${payment.symbol} on ${payment.chain}!`);
  }
});

📦 Supported Assets

Payx3 v2.0.0 supports a massive range of assets out of the box:

Native: BTC, ETH, BNB, MATIC, AVAX, SOL.
Layer 2s: Arbitrum (ARB), Optimism (OP).
Stablecoins: USDT, USDC, DAI.
DeFi & More: WBTC, LINK, UNI, AAVE, SHIB.
Custom Tokens: Watch any ERC-20 token by simply providing its contract address.

🔒 Security First

We know that in crypto, security is everything.

Read-Only Monitoring: The "watch" functions only require public addresses. You never need to expose your private keys to a live server to track payments.
Stateless: payx3 doesn't store your data. You control your mnemonic and your infrastructure.

💼 Open to Work

The creator of payx3, Susheel, is a blockchain enthusiast and developer currently open to new opportunities. If you’re looking for a freelancer or a full-time expert in Web3, Node.js, or Full-stack development, feel free to reach out!

Email: susheelhbti@gmail.com
NPM: payx3 on npm

Conclusion

Stop fighting with multiple libraries and inconsistent APIs. Whether you're a seasoned Web3 dev or just starting, payx3 provides the streamlined workflow you've been looking for.

Ready to build? Check out the (https://www.npmjs.com/package/payx3) and start accepting payments today!

payx3: Multi-Chain Crypto Payment SDK You've Been Waiting For

susheel kumar — Sun, 10 May 2026 13:35:58 +0000

The Problem

Every crypto payment integration follows the same painful pattern:

Read blockchain docs for each chain
Implement RPC calls
Handle WebSocket reconnections
Parse transaction data
Calculate correct decimals (looking at you, BSC USDT with 18 decimals while everyone else uses 6)
Build block explorer URLs
Write confirmation logic

And that's just one chain. What about the other 8 your client wants?

The Solution: payx3

const { watchAll } = require("payx3");

await watchAll({
  btcAddress: "bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq",
  evmAddress: "0xb2C65C9C98C2216099A37AF7FE12A93b8A37AFBd",
  solAddress: "CbWki5xkrnde7TYj11jDWNEJ3h7bRTmk5Q22uANNfEt",
  infuraKey: "YOUR_KEY",

  onPayment: (payment) => {
    console.log(`${payment.amount} ${payment.symbol} received on ${payment.chain}`);
    // Fires for EVERYTHING: BTC, ETH, BNB, SOL, USDT, USDC...
  },
});

One call. All chains. All tokens. Real-time.

What You Get

🔑 Wallet Generation

Generate a BIP-39 mnemonic and derive addresses for all supported chains simultaneously:

const { generateMnemonic, deriveAll } = require("payx3");

const mnemonic = generateMnemonic(128);  // 12 words
const wallet = await deriveAll(mnemonic);

console.log(wallet.bitcoin[2].address);  // bc1... Native SegWit
console.log(wallet.evm.address);         // 0x... For ETH, BNB, MATIC, AVAX, ARB, OP
console.log(wallet.solana.address);      // Solana address

👁️ Real-time Payment Watching

Chain	Native Token	Supported Tokens
Bitcoin	BTC	—
Ethereum	ETH	USDT, USDC, DAI, WBTC, WETH, LINK, UNI, AAVE, SHIB
BNB Chain	BNB	USDT, USDC, DAI, LINK
Polygon	MATIC	USDT, USDC, DAI, WBTC, WETH, LINK, UNI, AAVE
Avalanche	AVAX	USDT, USDC, DAI, WBTC, WETH, LINK, AAVE
Arbitrum	ETH	USDT, USDC, DAI, WBTC, WETH, LINK, UNI
Optimism	ETH	USDT, USDC, DAI, WBTC, WETH, LINK
Solana	SOL	Any SPL token

🎯 Watch Any Custom ERC-20

const { watchToken } = require("payx3");

watchToken({
  address: "0x...",
  infuraKey: "YOUR_KEY",
  chain: "ETH",
  contractAddress: "0x6982508145454Ce325dDbE47a25d4ec3d2311933",  // PEPE
  decimals: 18,
  symbol: "PEPE",
  name: "Pepe",
  onPayment: (p) => console.log(`${p.amount} PEPE received!`),
});

Payment Object

Every callback receives a consistent object regardless of chain:

{
  chain: "Ethereum",
  chainSymbol: "ETH",
  symbol: "USDT",
  name: "Tether USD",
  amount: "100.50",
  txHash: "0xa1b2c3...",
  status: "unconfirmed",      // or "confirmed"
  explorerUrl: "https://etherscan.io/tx/0xa1b2c3...",
  contract: "0xdAC17F...",    // null for native coins
  timestamp: 1715000000000,
  blockNumber: 19500000        // onConfirmed only
}

CLI Tool

No code? No problem. Install globally:

npm install -g payx3

Generate a wallet:

payx3 generate

Watch for payments using config.json:

{
  "infuraKey": "YOUR_INFURA_KEY",
  "addresses": {
    "BTC": "bc1q...",
    "EVM": "0x...",
    "SOL": "CbWk..."
  }
}

payx3 watch

Or watch specific addresses inline:

payx3 watch --btc bc1q... --evm 0x... --sol CbWk... --key YOUR_INFURA_KEY

REST API Server

Run as a full API server:

node examples/server.js
# Server running on http://localhost:3000

Endpoints

Method	Endpoint	Description
`POST`	`/wallet/create`	Generate wallet + addresses
`POST`	`/watch/btc`	Watch BTC address
`POST`	`/watch/eth`	Watch ETH
`POST`	`/watch/bnb`	Watch BNB
`POST`	`/watch/polygon`	Watch MATIC
`POST`	`/watch/avalanche`	Watch AVAX
`POST`	`/watch/arbitrum`	Watch ETH on Arbitrum
`POST`	`/watch/optimism`	Watch ETH on Optimism
`POST`	`/watch/sol`	Watch SOL + SPL tokens
`POST`	`/watch/usdt`	Watch USDT (any chain)
`POST`	`/watch/usdc`	Watch USDC (any chain)
`POST`	`/watch/token`	Watch any ERC-20
`POST`	`/watch/all`	Watch everything at once
`GET`	`/payments`	List all received payments
`DELETE`	`/watch/:id`	Stop a watcher

Real-World Examples

E-commerce Checkout

const { generateMnemonic, deriveAll, watchAll } = require("payx3");

async function createPaymentSession(orderId, amountUSD) {
  // Generate a fresh wallet for this order
  const mnemonic = generateMnemonic(128);
  const wallet = await deriveAll(mnemonic);

  // Store mnemonic temporarily (in DB with orderId)
  await db.saveOrderWallet(orderId, mnemonic);

  // Start watching
  watchAll({
    btcAddress: wallet.bitcoin[2].address,
    evmAddress: wallet.evm.address,
    solAddress: wallet.solana.address,
    infuraKey: process.env.INFURA_KEY,

    onPayment: async (payment) => {
      // Mark order as paid
      await db.updateOrderStatus(orderId, "paid", payment);

      // Send confirmation email
      await email.send(orderEmail, `Payment received: ${payment.amount} ${payment.symbol}`);

      // Trigger fulfillment webhook
      await axios.post(fulfillmentUrl, { orderId, payment });
    },
  });

  return {
    addresses: {
      BTC: wallet.bitcoin[2].address,
      EVM: wallet.evm.address,
      SOL: wallet.solana.address,
    },
  };
}

Subscription Payments

const { watchUSDC } = require("payx3");

// Watch for $50 USDC monthly subscription payments
watchUSDC({
  address: companyWallet,
  infuraKey: process.env.INFURA_KEY,
  chain: "ETH",

  onPayment: async (payment) => {
    if (parseFloat(payment.amount) >= 50) {
      // Find user by transaction sender
      const user = await db.findUserByAddress(payment.from);
      if (user) {
        // Extend subscription by 30 days
        await db.extendSubscription(user.id, 30);

        // Send receipt
        await email.send(user.email, `Subscription renewed — ${payment.amount} USDC`);
      }
    }
  },
});

Why payx3?

✅ No Private Keys Needed

You never share private keys. The library only reads blockchain data. Your funds stay where they belong.

✅ Automatic Decimal Handling

USDT has 6 decimals on Ethereum but 18 on BNB Chain. payx3 handles this automatically. You always get human-readable amounts.

✅ Built-in Reconnection

WebSockets disconnect? payx3 reconnects automatically. Your payment detection never stops.

✅ 0→1 in 5 Minutes

From npm install to watching payments on 8 chains. No blockchain experience required.

Installation

npm install payx3

Get a free Infura key: https://app.infura.io/register

GitHub & Documentation

github.com/susheelhbti/payx3

Full API documentation
Examples for every chain and token
REST API server example
MIT license — free for commercial use

Support the Project

If payx3 saves you development time, consider:

⭐ Starring the repo on GitHub

🐛 Reporting issues you find

🔧 Submitting PRs for new chains or tokens

💬 Sharing with other developers

About the Author

I'm Susheel, a blockchain developer available for freelance and full-time work.

Need a custom integration? Multi-chain payment system? Web3 infrastructure?

📧 susheelhbti@gmail.com

Introducing Sakshsky-Auth: Secure Passwordless Email Authentication for Node.js

susheel kumar — Sat, 12 Jul 2025 06:12:42 +0000

In today's fast-paced digital world, traditional password-based authentication is increasingly seen as a vulnerability—prone to breaches, phishing, and user frustration. Enter passwordless authentication, a modern approach that leverages secure, one-time verification methods like email codes. At Sakshsky, we're excited to release sakshsky-auth, a lightweight Node.js package designed to make implementing robust, tamper-resistant email-based authentication simple and secure.

Whether you're building a web app, API, or internal tool, sakshsky-auth handles the heavy lifting: generating verification codes, binding them to device fingerprints, and verifying incoming emails with built-in IMAP/POP3 monitoring. Let's dive into what makes this package a game-changer for developers prioritizing security without complexity.

Why Passwordless Authentication?

Passwords are a pain point. Users forget them, attackers crack them, and managing them securely requires hashing, salting, and constant updates. Passwordless systems, like those used by companies such as Slack or GitHub, shift the burden to trusted channels like email or biometrics.

Sakshsky-auth focuses on email verification, enhanced with device fingerprinting to prevent common attacks like code interception or replay. It's ideal for apps where email is a primary identifier, offering a seamless user experience: Enter your email, get a code, send it back, and you're in—no passwords required.

Key Features

Sakshsky-auth is built with security and ease-of-use in mind. Here's what sets it apart:

Passwordless Flow: Users initiate login with their email, receive a pre-filled verification email, and send it to complete auth.
Device Fingerprinting: Collects session data (IP, UA, browser, etc.) to create a unique "fingerprint" bound to the code, reducing cross-device tampering risks.
Tamper Detection: Uses salted SHA-256 hashes to verify email integrity—any alteration to the code or hash fails authentication.
Built-in Email Monitoring: Supports IMAP and POP3 for real-time or polled inbox checking, with auto-protocol detection.
Customizable Code Generation: Use the default UUID or provide your own generator for shorter/OTP-style codes.
MongoDB Integration: Stores temporary verification records via Mongoose for easy expiry and cleanup.
Socket.IO Support: Real-time notifications for successful verifications, perfect for live apps.

The package is modular, lightweight (under 50KB installed), and has no external runtime dependencies beyond what's needed for your stack.

How It Works Under the Hood

Initiation: On login request, the package generates a code, collects a device fingerprint, salts and hashes it, and prepares a pre-filled email (using mailto: for client-side compose).
Email Sending: The user sends the email with the code and hash.
Verification: The package monitors the inbox (IMAP/IDLE for real-time or POP3/polling), parses incoming emails, extracts code/hash, rebuilds the hash from stored data, and checks for matches. On success, it triggers a callback (e.g., Socket.IO emit) and deletes the record.
Security Checks: Expiry, sender match, and hash validation ensure safety.

This flow minimizes attack surfaces while keeping things user-friendly.

Installation and Quick Start

Get started in minutes:

npm install sakshsky-auth

In your Node.js app (e.g., Express):

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const mongoose = require('mongoose');
const path = require('path');
const { sakshskyInitLoginHandler, sakshskyStartAuthMonitor } = require('sakshsky-auth');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));

// Connect to MongoDB
mongoose.connect('mongodb://localhost:27017/emailAuth');

// Define schemas
const verificationSchema = new mongoose.Schema({
  email: String,
  code: String,
  expiry: Date,
  socketId: String,
  hashedFingerprint: String,
  salt: String
});
const Verification = mongoose.model('Verification', verificationSchema);

// Login initiation route
app.post('/api/init-login', async (req, res) => {
  const serverEmail = 'verify@yourdomain.com'; // Your inbound email
  await sakshskyInitLoginHandler(req, res, serverEmail);
});

// Serve frontend
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// Dashboard (protect in production)
app.get('/dashboard', (req, res) => {
  res.send('Logged in!');
});

// Email config
const emailConfig = {
  host: 'imap.gmail.com',
  port: 993,
  user: 'your-inbox@gmail.com',
  pass: 'app-password'
};

// Start monitor
sakshskyStartAuthMonitor(emailConfig, (verification) => {
  io.to(verification.socketId).emit('verified', { email: verification.email });
});

server.listen(3000, () => console.log('Server on port 3000'));

Detailed Example: Copy-Paste and Run

To help you get started quickly, here's a complete, copy-pasteable example. This includes a basic Express server, MongoDB setup, and a simple frontend HTML file. Save the server code as server.js, the HTML as public/index.html, and run node server.js.

Server Code (server.js)

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const path = require('path');
const mongoose = require('mongoose');
const { sakshskyInitLoginHandler, sakshskyStartAuthMonitor } = require('sakshsky-auth');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

app.use(express.json());
app.use(express.urlencoded({ extended: true }));
app.use(express.static(path.join(__dirname, 'public')));

// Connect to MongoDB
mongoose.connect('mongodb://localhost:27017/emailAuth', { useNewUrlParser: true, useUnifiedTopology: true })
  .then(() => console.log('MongoDB connected'))
  .catch(err => console.error('MongoDB error:', err));

// Define verification schema
const verificationSchema = new mongoose.Schema({
  email: String,
  code: String,
  expiry: Date,
  socketId: String,
  hashedFingerprint: String,
  salt: String
});
const Verification = mongoose.model('Verification', verificationSchema);

// Login initiation route
app.post('/api/init-login', async (req, res) => {
  const serverEmail = 'your-server-email@example.com'; // Replace with your inbound email
  await sakshskyInitLoginHandler(req, res, serverEmail);
});

// Serve frontend
app.get('/', (req, res) => {
  res.sendFile(path.join(__dirname, 'public', 'index.html'));
});

// Dashboard example
app.get('/dashboard', (req, res) => {
  res.send('Welcome to the dashboard! You are logged in.');
});

// Email config (replace with your details)
const emailConfig = {
  host: 'imap.gmail.com',
  port: 993,
  user: 'your-inbox@gmail.com',
  pass: 'your-app-password' // Use Gmail app password
};

// Start auth monitor
sakshskyStartAuthMonitor(emailConfig, (verification) => {
  io.to(verification.socketId).emit('verified', { email: verification.email });
});

server.listen(3000, () => console.log('Server running on http://localhost:3000'));

Frontend Code (public/index.html)

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Sakshsky Auth Example</title>
  <script src="/socket.io/socket.io.js"></script>
</head>
<body>
  <h1>Passwordless Email Login</h1>
  <input type="email" id="email" placeholder="Your Email" required>
  <button onclick="initLogin()">Login</button>

  <script>
    const socket = io();
    function initLogin() {
      const email = document.getElementById('email').value;
      if (!email) return alert('Enter email');
      fetch('/api/init-login', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ email, socketId: socket.id })
      }).then(res => res.json()).then(data => {
        window.location.href = `mailto:${data.toEmail}?subject=${encodeURIComponent(data.subject)}&body=${encodeURIComponent(data.body)}`;
        socket.on('verified', (data) => {
          alert(`Logged in as ${data.email}`);
          window.location.href = '/dashboard';
        });
      }).catch(err => alert('Error'));
    }
  </script>
</body>
</html>

Run node server.js, visit http://localhost:3000, enter an email, send the pre-filled message, and watch for the verification alert!

Security Considerations

While robust, email auth has limitations (e.g., inbox compromise). Sakshsky-auth mitigates with hashes and fingerprints, but for high-stakes apps, combine with 2FA or WebAuthn. Always use HTTPS, rate-limit requests, and monitor for anomalies.

Future Plans

We're planning support for SMS fallback, WebAuthn integration, and customizable fingerprints. Feedback welcome on GitHub!

At Sakshsky, we're committed to secure, simple tools. Try sakshsky-auth today and let us know what you think!

Announcing Laravel API Resource Optimizer: Supercharge Your Laravel APIs

susheel kumar — Mon, 12 May 2025 08:51:31 +0000

I'm thrilled to introduce Laravel API Resource Optimizer, a new open-source package designed to make your Laravel APIs faster, lighter, and more flexible. Whether you're building a REST API for a mobile app, a SaaS platform, or a microservices architecture, this package streamlines API development by enhancing Laravel's built-in API Resource classes with powerful optimization features.

In this post, I'll walk you through what the package does, why it matters, and how you can start using it today to level up your Laravel APIs.

Why Laravel API Resource Optimizer?

Laravel's API Resources are fantastic for transforming Eloquent models into JSON responses, but they lack advanced optimization features out of the box. Developers often find themselves writing repetitive code to handle tasks like:

Allowing clients to request specific fields to reduce payload size.
Dynamically including related data without over-fetching.
Caching responses to improve performance.

The Laravel API Resource Optimizer package addresses these pain points by providing a drop-in solution that makes your APIs more efficient and developer-friendly. Built with performance and simplicity in mind, it’s compatible with Laravel 8.x, 9.x, and 10.x, and it’s ready to use in your next project.

Key Features

Here’s what makes this package stand out:

Sparse Fieldsets: Let clients request only the fields they need (e.g., GET /users?fields=id,name), reducing response sizes and improving performance.
Conditional Relationship Loading: Include related data on demand (e.g., GET /users?include=posts) to avoid unnecessary database queries.
Response Caching: Cache API responses with configurable TTL to minimize server load and speed up requests.
Schema Validation: Ensure requested fields and relationships are valid, enhancing security and reliability.
Rate-Limiting: Protect your API with built-in throttling to prevent abuse.

These features are designed to work seamlessly with Laravel’s ecosystem, leveraging familiar conventions and requiring minimal setup.

Getting Started

Installing and using the package is a breeze. Here’s a quick guide to get you up and running.

Installation

Install the package via Composer:

composer require sakshsky/laravel-api-optimizer

Optionally, publish the configuration file to customize settings:

php artisan vendor:publish --provider="Sakshsky\ApiOptimizer\ApiOptimizerServiceProvider"

The configuration file (config/api-optimizer.php) lets you tweak options like cache duration and default fields:

return [
    'cache_ttl' => 60, // Cache responses for 60 seconds
    'default_fields' => ['id', 'name'],
    'max_nesting_depth' => 3,
    'rate_limit' => '60,1', // 60 requests per minute
];

Creating an Optimized Resource

Extend the OptimizedResource class to define your API resource:

namespace App\Http\Resources;

use Sakshsky\ApiOptimizer\OptimizedResource;

class UserResource extends OptimizedResource
{
    protected $allowedFields = ['id', 'name', 'email', 'created_at'];
    protected $allowedIncludes = ['posts'];

    public function toArray($request)
    {
        return [
            'id' => $this->id,
            'name' => $this->name,
            'email' => $this->email,
            'created_at' => $this->created_at,
            'posts' => PostResource::collection($this->whenLoaded('posts')),
        ];
    }
}

Using in a Controller

Use the resource in your controller like any Laravel API Resource:

namespace App\Http\Controllers;

use App\Http\Resources\UserResource;
use App\Models\User;

class UserController extends Controller
{
    public function index()
    {
        $users = User::query()->paginate();
        return UserResource::collection($users);
    }
}

Example API Requests

Here’s what you can do with the package:

Fetch all fields:

   GET /api/users

   [
       {
           "id": 1,
           "name": "John Doe",
           "email": "john@example.com",
           "created_at": "2025-05-12T12:00:00Z"
       },
       ...
   ]

Request specific fields:

   GET /api/users?fields=id,name

   [
       {
           "id": 1,
           "name": "John Doe"
       },
       ...
   ]

Include relationships:

   GET /api/users?include=posts

   [
       {
           "id": 1,
           "name": "John Doe",
           "email": "john@example.com",
           "posts": [
               {
                   "id": 1,
                   "title": "My First Post"
               },
               ...
           ]
       },
       ...
   ]

Applying Middleware

The package includes an api-optimizer middleware to parse query parameters. Apply it to your routes:

Route::middleware('api-optimizer')->group(function () {
    Route::resource('users', UserController::class);
});

Why This Package Matters

In today’s API-driven world, performance and flexibility are critical. Clients—whether mobile apps or web frontends—expect fast, tailored responses. By supporting sparse fieldsets and conditional includes, Laravel API Resource Optimizer reduces payload sizes and database queries, leading to faster responses and lower server costs. The caching feature is a game-changer for high-traffic APIs, and the schema validation ensures your endpoints stay secure.

Plus, it’s built with Laravel’s developer experience in mind. You don’t need to rewrite your existing resources or learn a new paradigm—just extend OptimizedResource and start optimizing.

What’s Next?

This is just the beginning for Laravel API Resource Optimizer. Future updates may include:

GraphQL-like Query Support: Allow structured queries (e.g., ?query={id,name,posts{id,title}}) for even more flexibility.
Response Compression: Compress responses to further reduce payload sizes.
OpenAPI Integration: Generate Swagger documentation for optimized resources.
Multi-Tenancy Support: Optimize APIs for SaaS applications.

I’m excited to hear your feedback and ideas for new features. If you have suggestions, feel free to open an issue or submit a pull request!

Contribute and Connect

Laravel API Resource Optimizer is open-source under the MIT License, and contributions are welcome! Whether you’re fixing bugs, adding features, or improving documentation, your help will make this package even better.

GitHub: github.com/sakshsky/laravel-api-optimizer
Packagist: packagist.org/packages/sakshsky/laravel-api-optimizer
Issues: github.com/sakshsky/laravel-api-optimizer/issues
X: Follow me at @sakshsky for updates

To get started, check out the CONTRIBUTING.md file for guidelines.

Try It Today

Ready to supercharge your Laravel APIs? Install Laravel API Resource Optimizer and see the difference for yourself:

composer require sakshsky/laravel-api-optimizer

I can’t wait to see how you use this package in your projects. Share your experiences, success stories, or questions on X with the hashtag #LaravelApiOptimizer, or drop a comment below.

Happy coding, and let’s make Laravel APIs faster together!

If you enjoyed this post, please share it with the Laravel community and star the GitHub repository. Stay tuned for more updates!

Introducing Saksh Wallet: A Simple Wallet System for Laravel

susheel kumar — Mon, 12 May 2025 08:14:25 +0000

Are you building a Laravel application that needs to manage user wallets, handle transactions, or track balances across multiple currencies? Look no further! I’m thrilled to announce the release of sakshsky/saksh-wallet, a lightweight, open-source Laravel package designed to simplify wallet functionality with a clean and intuitive API. Whether you’re creating an e-commerce platform, a freelance marketplace, or a gaming app, Saksh Wallet has you covered.

In this post, I’ll walk you through what Saksh Wallet is, its key features, how to install and use it, and why it’s a great addition to your Laravel projects. Let’s dive in!

What is Saksh Wallet?

Saksh Wallet is a Laravel package that provides a robust and flexible wallet system for managing user transactions and balances. Built with Laravel 12 in mind, it leverages two database tables—wallet_transactions for transaction history and balances for current balances—to deliver a performant and scalable solution. The package is open-source, licensed under MIT, and available on Packagist at sakshsky/saksh-wallet.

Whether you need to credit funds, debit with fees, or retrieve balance summaries, Saksh Wallet offers a straightforward API that integrates seamlessly into your Laravel application.

Key Features

Saksh Wallet is designed to be simple yet powerful. Here’s what it offers:

Dual-Table Architecture: Uses wallet_transactions for tracking every credit and debit and balances for instant balance queries, ensuring performance and reliability.
Multi-Currency Support: Handle transactions in any currency (e.g., USD, EUR, GBP) with per-currency balance tracking.
Secure User Association: Links transactions and balances to users via user_id with foreign key constraints for data integrity.
Flexible Transactions: Supports credits, debits with optional fees, references, and descriptions for detailed transaction records.
Integrity Verification: Includes an Artisan command (saksh-wallet:verify) to check balance consistency against transaction history.
Comprehensive Tests: Comes with PHPUnit tests to ensure reliability and ease of contribution.
Open-Source Ready: Includes .gitignore, .gitattributes, CONTRIBUTING.md, and CHANGELOG.md for a complete package.

Whether you’re managing in-game currencies, processing payments, or tracking user funds, Saksh Wallet provides the tools you need with minimal setup.

Why Choose Saksh Wallet?

There are several wallet packages for Laravel, like bavix/laravel-wallet, but Saksh Wallet stands out for its simplicity and focus on core functionality. Here’s why it’s worth considering:

Lightweight: Minimal dependencies and a clean codebase make it easy to integrate and maintain.
Performant: The balances table ensures O(1) balance queries, ideal for high-traffic applications.
Developer-Friendly: Intuitive methods like addFunds, deductFunds, and getBalance make development a breeze.
Extensible: Built with Laravel conventions, it’s easy to extend for custom features like transaction reversals or payment gateway integration.
Open-Source: Licensed under MIT, it’s free to use and welcomes contributions from the community.

Installation

Getting started with Saksh Wallet is quick and easy. Follow these steps to add it to your Laravel 12 project:

Install via Composer:

   composer require sakshsky/saksh-wallet

Publish Migrations: The package includes a single migration to create the wallet_transactions and balances tables:

   php artisan vendor:publish --tag=saksh-wallet-migrations

Run Migrations: Apply the migrations to set up the database schema:

   php artisan migrate

That’s it! Your Laravel application is now ready to manage wallets.

Note: Ensure your users table exists (standard in Laravel) and contains at least one user, as the package uses user_id with foreign key constraints.

Usage

Saksh Wallet provides a simple API for managing wallet operations. Here’s how you can use it in your Laravel application:

Example: Controller Setup

Create a controller to handle wallet operations:

<?php

namespace App\Http\Controllers;

use Saksh\Wallet\Services\SakshWallet;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;

class WalletController extends Controller
{
    protected $wallet;

    public function __construct(SakshWallet $wallet)
    {
        $this->wallet = $wallet;
    }

    public function manageWallet(Request $request)
    {
        try {
            $userId = Auth::id();
            if (!$userId) {
                return response()->json(['error' => 'User not authenticated'], 401);
            }

            // Credit 500 USD
            $creditResult = $this->wallet->addFunds(
                $userId,
                500,
                'USD',
                'ref123',
                'Salary payment'
            );

            // Debit 200 USD with a 5 USD fee
            $debitResult = $this->wallet->deductFunds(
                $userId,
                200,
                'USD',
                'ref124',
                'Grocery shopping',
                5
            );

            // Get balance for USD
            $balance = $this->wallet->getBalance($userId, 'USD');

            // Get balance summary across all currencies
            $summary = $this->wallet->sakshGetBalanceSummary($userId);

            return response()->json([
                'credit' => $creditResult,
                'debit' => $debitResult,
                'balance' => $balance,
                'summary' => $summary,
            ]);
        } catch (\Exception $e) {
            return response()->json(['error' => $e->getMessage()], 400);
        }
    }
}

Define Routes

Add a route to access the wallet functionality (e.g., in routes/api.php):

use App\Http\Controllers\WalletController;

Route::get('/wallet', [WalletController::class, 'manageWallet'])->middleware('auth')->name('wallet.manage');

Example Output

Visiting /wallet (with an authenticated user) might return:

{
    "credit": "Credited 500 USD. New balance is 500",
    "debit": "Debited 200 USD. New balance is 295",
    "balance": {
        "user_id": 1,
        "currency": "USD",
        "balance": 295
    },
    "summary": {
        "user_id": 1,
        "balance": {
            "USD": 295
        }
    }
}

Verify Wallet Integrity

Run the included Artisan command to ensure balances match transaction history:

php artisan saksh-wallet:verify

This command checks for discrepancies and is useful for debugging or auditing.

Use Cases

Saksh Wallet is versatile and can be used in various scenarios:

E-commerce: Allow customers to maintain a wallet for quick checkouts or refunds.
Freelance Platforms: Manage payments to freelancers with platform fees.
Gaming Apps: Handle in-game currencies for purchases or rewards.
Financial Apps: Track user funds for budgeting or investment platforms.

The package’s multi-currency support makes it ideal for global applications, while its simple API ensures developers can integrate it quickly.

How Solidity Gas Saver Reduces Your Ethereum Costs 🚀

susheel kumar — Wed, 02 Apr 2025 08:26:03 +0000

Introduction

Gas fees are one of the biggest challenges for Ethereum developers. Every transaction consumes gas, and inefficient smart contracts can result in unnecessarily high fees. To solve this, I’ve built Solidity Gas Saver, an npm package that provides optimized Solidity contracts to help reduce gas costs while maintaining functionality.

Why Gas Optimization Matters

Ethereum operates on a gas-based fee model, where every computation, storage operation, and transaction costs gas. Optimizing Solidity code can:

Reduce contract execution costs
Lower user fees for dApps
Improve transaction speeds by minimizing computational overhead

How Solidity Gas Saver Works

The Solidity Gas Saver package includes several powerful contracts and libraries:

1️⃣ GasEfficientMath

This library optimizes arithmetic operations by utilizing unchecked Solidity blocks, reducing gas costs for operations like multiplication and addition.

uint256 result = GasEfficientMath.mul(5, 10); // More efficient than default Solidity math

2️⃣ BatchExecutor

BatchExecutor allows multiple contract calls to be executed in a single transaction, reducing redundant gas costs.

batchExecutor.execute([call1, call2, call3]);

3️⃣ GasOptimizedTokenTransfer

Token transfers can be optimized by reducing redundant operations, making ERC-20 transactions cheaper.

token.transferOptimized(recipient, amount);

How to Use Solidity Gas Saver

Install the Package

npm install solidity-gas-saver

Import and Use in Your Smart Contracts

import "solidity-gas-saver/contracts/GasEfficientMath.sol";

Deploy Optimized Contracts

npx hardhat run scripts/deploy.js --network goerli

Who Can Benefit?

DeFi Developers building gas-efficient protocols
dApp Creators looking to minimize costs for users
Smart Contract Developers who want optimized Solidity functions

Conclusion

The Solidity Gas Saver package is designed to help developers write more efficient smart contracts, reducing gas fees and improving overall performance. 🚀

👉 Try it now: Solidity Gas Saver on npm

Forem: susheel kumar

Stop Building Auth From Scratch — Meet authwall: The Plug-and-Play Auth System for Express

The Problem

The Solution

What You Get Out of the Box

Why Developers Love It

Quick Start

Real-World Example

Works With Your Existing User Model

Security Built-In

What's Coming

Get Started Today

About the Author

📘 Complete User Guide

Getting Started with authwall

Table of Contents

1. Installation

2. Basic Setup

Minimal Working Example

Environment Variables (.env)

3. Configuration

Full Configuration Options

4. Authentication Flow

Step 1: Send OTP

Step 2: Verify OTP

Step 3: Use JWT Token

Step 4: Logout

5. Admin Operations

First Admin Setup

Admin API Endpoints

List Users with Filters

Get User Details

Suspend User

Temporary Ban

Force Password Reset

Impersonate User

Terminate All Sessions

Bulk Operations

Export Users to CSV

View Audit Logs

Statistics

6. Role-Based Access Control

Default Roles

Creating Custom Roles

Protecting Routes with Middleware

7. Two-Factor Authentication

Enabling 2FA for a User

Verifying 2FA During Login

Disabling 2FA (Admin)

8. Event System

Available Events

Real-World Examples

9. Production Deployment

Security Checklist

Multi-Server Setup (Load Balancing)

Performance Optimization

Monitoring with PM2

Docker Deployment

10. Troubleshooting

Common Issues

Support & Community

License

Introducing **payx3**: The All-in-One SDK to Simplify Multi-Chain Crypto Payments

🚀 Why payx3?

Key Features:

🛠 Quick Start

One Wallet, All the Chains

Monitoring Payments

📦 Supported Assets

🔒 Security First

💼 Open to Work

Conclusion

payx3: Multi-Chain Crypto Payment SDK You've Been Waiting For

The Problem

The Solution: payx3

What You Get

🔑 Wallet Generation

👁️ Real-time Payment Watching

🎯 Watch Any Custom ERC-20

Payment Object

Introducing payx3: The All-in-One SDK to Simplify Multi-Chain Crypto Payments