Applications

Accept crypto payments by minting a fresh deposit address per checkout. The address is generated on demand, watched in real time, and expires after the window you set (default 1 hour). The moment the buyer sends funds, we settle the checkout and fire your webhook so you can fulfill the order.

• One unique address per order — no address reuse, no manual reconciliation.
• Configurable expiry (60s to 24h). Late payments are recorded but not auto-settled.
• Real-time confirmation via Tatum subscription + your existing webhook.
• Underpayment / overpayment captured as their own statuses.
• Works on every chain we support (BTC, ETH, USDT-Tron, USDC-everywhere).

// Create a checkout when your customer clicks "Pay with crypto"
const r = await fetch('https://api.swydex.com/api/v1/payments/checkouts', {
  method: 'POST',
  headers: {
    'X-API-Key': API_KEY,
    'X-API-Secret': API_SECRET,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    externalId: 'order_12345',                 // your order id
    network: 'tron',                           // any supported chain
    asset: 'native',                           // 'native' or ERC-20 contract
    amountExpected: '5000000',                 // 5 USDT in base units
    expiresInSeconds: 3600,                    // 1 hour window
    successUrl: 'https://yourapp.com/orders/12345/paid',
    cancelUrl: 'https://yourapp.com/orders/12345/expired',
    metadata: { customerEmail: 'buyer@example.com' },
  }),
});
const { data } = await r.json();
// → { id, address, amountExpected, expiresAt, status: 'PENDING' }
// Show data.address to your buyer. We'll webhook you when paid.

One API call gives every user of your app their own deposit address on every chain you support. We hold the keys (encrypted under per-tenant KMS-wrapped keys), sweep deposits into your master wallet automatically, and refill gas as needed.

• Deterministic per-user addresses — same external ID always derives the same wallet.
• Auto-sweep into the tenant master with configurable thresholds.
• Gas-station refills slave wallets so withdrawals don't stall.
• KMS-wrapped per-tenant DEK; runtime is decrypt-only.

await fetch('https://api.swydex.com/api/v1/wallets', {
  method: 'POST',
  headers: { 'X-API-Key': '...', 'X-API-Secret': '...', 'Content-Type': 'application/json' },
  body: JSON.stringify({
    externalId: 'user_123',     // your user id — same value always returns the same address
    network: 'ethereum',
  }),
});

For customers who prefer self-custody, generate wallets where the user holds the private key. We provide the derivation, address, and on-chain monitoring — but never see the key material. Useful when regulation requires user-held custody, or for high-value vaults.

• Mnemonic returned ONCE on creation; SwyDex stores only the public xpub.
• Same on-chain monitoring + webhook firing as custodial wallets.
• Tenant can offer "managed" and "self-custody" side-by-side.

Quote and execute swaps for your users. Same-chain swaps route through the most cost-efficient venue we have liquidity on. Cross-chain swaps fall through to DEX aggregators (1inch, etc.) when no internal liquidity is available.

• Same-chain: USDC ↔ USDT, ETH ↔ stables, etc.
• Cross-chain: USDC on Ethereum → USDT on Tron in one quote.
• Slippage protection per quote, expiring after 30 seconds.

Built-in escrow trades, ad listings, and dispute resolution for offering peer-to-peer trading inside your product. Real-time chat over WebSockets. KYC-gated dispute escalation. Mature enough to run at production volumes.

• Escrow funded BEFORE buyer signals payment — protects sellers from bad-faith trades.
• Built-in dispute resolution with admin tooling.
• KYC requirement configurable per ad / per amount threshold.

Let your users launch their own ERC-20 or ERC-721 tokens through your product. They pick a template (Standard, Mintable, Burnable, NFT collection), fill in name/symbol/supply, and we handle compile + deploy + verify. Tenants set a commission fee per launch as part of their pricing.

• Pre-vetted OpenZeppelin-derived templates only — no untrusted bytecode.
• Pattern-based security checks block selfdestruct / tx.origin / delegatecall / inline assembly.
• Idempotent deploy via Idempotency-Key — safe to retry.
• Commission fee recorded per deploy for the tenant's billing reconciliation.

await fetch('https://api.swydex.com/api/v1/contracts/launch', {
  method: 'POST',
  headers: {
    'X-API-Key': '...',
    'X-API-Secret': '...',
    'Idempotency-Key': 'launch-batch-2026-04-25-001',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    templateId: 'ERC20',
    network: 'polygon',
    name: 'Acme Rewards',
    symbol: 'ACME',
    decimals: 18,
    initialSupply: '1000000000000000000000000', // 1M @ 18 decimals
    ownerAddress: '0xabc...',
    commissionFeeWei: '5000000000000000000',     // record-keeping; tenant collects out-of-band
    commissionCurrency: 'MATIC',
  }),
});

Your customers describe what they want in plain English; an AI assistant gathers requirements, drafts Solidity, runs security checks, and hands off to the same template-backed launcher. Best for "I want a token with these specific properties" UX without forcing the user to write code.

• Multi-turn conversation — assistant asks clarifying questions before drafting.
• Pattern-based safety checks block CRITICAL findings before deploy.
• Deploys via the pre-vetted template, NOT the AI source — disclosed in UI.
• Per-session cap (60 turns / 8KB per message) keeps spend predictable.

Hold customer crypto on their behalf, stake it via on-chain protocols, and distribute rewards back. SwyDex provides the wallet, balance accounting, and webhook layer; you write the staking-protocol-specific adapter (ETH validators, Solana stake accounts, etc.). Buildable on top of our chain abstraction; not shipped as a turn-key product yet.

• Customer balances tracked per asset + network.
• Wallet adapters for the major chains; staking adapters in roadmap.
• Audit trail per stake/unstake operation for end-of-year reporting.