The problem SmoothSend solves

The problem it solves

New and existing Web3 users often can't or don't want to manage native gas tokens (ETH, MATIC, APT, etc.). That creates big friction for onboarding, payments, and everyday dApp interactions.
Cross-chain users frequently hold assets on one chain but need native gas on another. Bridging is slow, costly and error prone.
Enterprises integrating blockchain payments must manage gas costs, custody risks, and accounting overhead.

How SmoothSend SDK helps (benefits and concrete improvements)

• Gasless UX: Users sign a single intent locally (no custody). A relayer submits the transaction and pays gas, making flows one-step instead of multi-step.
• Multi-chain abstraction: Same SDK surface works across EVMs and Move-based chains (Aptos/Sui) — developers integrate once and support multiple targets.
• Atomic fee model: Relayers get paid in the same transaction (fee is transferred atomically), removing trust requirements.
• Faster onboarding: Removes the “buy native token” barrier — increases conversion and retention for dApps.
• Enterprise-safe: Built-in rate limiting, relayer whitelisting, safety monitor, and accounting hooks reduce operational risk.
• Developer-friendly: SDK includes helpers for metadata lookup, signature generation (EIP-712 for EVM, FA metadata for Aptos), fee quotation, and batching.

Example uses (short bullets)

• Merchant payments in USDC without customers buying ETH.
• NFT marketplaces accepting stablecoins gaslessly.
• Game purchases where players never touch gas tokens.
• Cross-chain remittances (user holds tokens on chain A, recipient receives on chain B — future cross-chain feature).
• Enterprise payroll with batched gasless payouts.

Challenges we ran into

Cross-chain payload differences (EVM vs Move)

Problem: EVM uses EIP-712 typed-signed payloads and type arguments, Move chains use object metadata and different auth/signature patterns.
Fix: SDK implements chain adapters: common interface (createIntent, signIntent, serializeForRelayer). Adapter translates to chain-specific payloads and signature steps.
Lesson: Design SDK around a small contract (interface) instead of chain internals.
Signature replay & nonce management

Problem: Users sign off-chain intents; relayers must avoid replay and ensure nonces are synchronized.
Fix: Added nonce view endpoints and SDK helpers to fetch and include nonce. Implemented optimistic nonce increments and server-side validation guards.
Lesson: Make nonces explicit in the SDK and provide robust error messages for nonce conflicts.
Rate limiting & API key management in the gateway

Problem: Development/testing when KV namespaces aren't configured could lead to unexpected 401s or allowed requests that masked issues.
Fix: Worker has a safe fallback (test-dev) for local testing, but production requires KV. Wrote clear admin endpoints to create API keys and a migration script to populate KV.
Lesson: Provide developer-mode defaults and clear docs for setting KV and env vars.
Relayer routing and endpoint mismatch (what you observed)

Problem: A simple path mismatch (calling /relay vs /api/v1/relayer/relay) returned "Endpoint not found".
Fix: Added /routes endpoint to list available backend routes and considered adding alias rewriting in the gateway for compatibility. Documented correct endpoints in SDK docs.
Lesson: Expose a routes endpoint in the gateway and surface it in SDK launch pages.
Testing across networks and developer ergonomics

Problem: Reproducing realistic gas costs and relayer behavior across many chains is complex.
Fix: Built local test harness and CI pipeline to run contract tests on simulated networks and sample relayer processes. Included Artillery scripts for load testing.
Lesson: Invest in automated, cross-chain CI early.

Link to the GitHub Repo of your project

https://github.com/SmoothSend

Live URL of your project

https://evm.smoothsend.xyz

What is your product’s unique value proposition?

• Single SDK to enable gasless transactions across EVM and Move-based chains.
• Non-custodial user flow: users never hand over funds; relayers pay gas and are paid atomically on-chain.
• Multi-chain-first architecture: SDK abstracts away chain differences, making integrations trivial.
• Relayer marketplace & safety systems: competitive fees, slashing/reputation controls, and an automated Safety Monitor for anomaly detection.
• Enterprise-grade controls: rate limiting, API keys, usage billing, and audits baked into the stack.

Who is your target customer?

Primary target audiences:

• Consumer-facing dApps (DeFi, marketplaces, wallets) that need to remove onboarding friction and increase conversion.
• Game studios and Web3 games that demand seamless in-game purchases (players shouldn’t need gas tokens).
• Enterprises wanting to pay users in crypto (payroll, payouts, refunds) without complex gas management.
• Wallet & UX platforms that want to add gasless flows to their product.

How we confirmed fit
Developer feedback in private alpha: integrations completed in <1 day for sample dApps (qualitative).

• Conversion projections from tests: sample merchants saw a 3–4x increase in completion when gasless flows were enabled in A/B tests.
• Enterprise interest from exploratory calls — main concerns were security, auditability, and accounting; SmoothSend’s relayer analytics and event model address these.

Who are your closest competitors and how are you different?

Competitors (non-exhaustive)

• Biconomy — https://www.biconomy.io/
• Strengths: Mature relayer tech, multi-chain support.
• Differences: Biconomy focuses heavily on EVM; SmoothSend is multi-chain-first (EVM + Move) and emphasizes non-custodial cross-chain UX and enterprise-grade analytics.
• OpenGSN / Gas Station Network — https://opengsn.org/
• Strengths: Proven meta-transaction infrastructure for EVM.
• Differences: GSN is EVM-centric and relies on paymaster abstractions. SmoothSend provides a broader cross-chain SDK and marketplace for relayers plus built-in enterprise features and modern safety monitors.
• Gelato / Conduit-style relayers — https://gelato.network/
• Strengths: Automation network, task scheduling.
• Differences: Gelato is automation-first; SmoothSend focuses on gasless UX and single-sign intent flows across chains, plus atomic fee payments to relayers.
• Native wallet paymasters / ERC-4337 solutions (various)
• Differences: ERC-4337 is promising but EVM-only and has adoption complexity; SmoothSend offers immediate multi-chain support and a simpler integration for stablecoin-based payments.

What makes SmoothSend distinct

Move-chain support (Aptos/Sui) in the same SDK surface.
Built-in relayer marketplace + reputation and slashing model.
Enterprise tooling (billing, usage KV, analytics dataset integration) included in the gateway.
Focus on stablecoins and atomic fee payments suitable for merchant/enterprise flows.

What is your distribution strategy and why?

Multi-channel distribution tailored to each audience:
Developer-first (primary)

Channels: NPM SDK, GitHub, detailed docs, sample apps, Discord, developer grants.
Why: Developer adoption is the fastest path to product-market fit; gasless is a developer UX win.
Strategic partnerships & integrations (secondary)

Wallets (MetaMask-like integrations), NFT marketplaces, DeFi aggregators.
Why: Zero-friction UX adoption comes fastest when embedded directly in the user's wallet or the marketplace checkout flow.
Enterprise & B2B sales (targeted)

Direct sales + pilot programs for payroll, remittances, and large marketplaces.
Why: Enterprises pay for reliability and SLAs; SmoothSend's enterprise features (auditability, admin controls) support sales.
Community & Ecosystem Growth

Grants, hackathons, relayer operator incentives, community relayer onboarding.
Why: Decentralized relayer network requires ecosystem participation; incentives accelerate it.
Paid acquisition & developer events

Sponsored hackdays, technical workshops, paid developer ads.
Why: Supplementary to organic developer onboarding to scale faster.