Metaverse Trading Ltd

Sardium · Live · In production

Accept crypto payments without touching the money.

Sardium is a white-label crypto checkout for merchants. Your customer pays by card or a local payment method through a licensed provider; the stablecoin lands in the customer's own self-custody wallet, and the customer signs and sends the payment to your wallet. No custody, no exchange account, no middleman to trust.

The name

Where money was invented.

The world's first coin was struck in Sardis, in Anatolia, around 600 BC, under the kings of Lydia. Sardium carries that inheritance into the digital age: take value at its source and move it, safely.

Kingdom of Lydia · ~600 BC

Lydian staters were struck from electrum, a natural alloy of gold and silver. Their value did not come from a promise written on them. It came from the metal itself, verifiable by anyone holding it.

That is the same property we build for: settlement you can verify yourself, rather than a balance somebody else asserts.

How it works

Three steps. Funds never rest with us.

STEP 01

Customer pays by card

The payment widget embeds in your site. The customer pays by card in a flow they already recognise.

STEP 02

A licensed provider converts

Fiat processing and identity verification (KYC) are handled entirely by licensed payment providers. The stablecoin goes to the customer's own self-custody wallet.

STEP 03

The customer signs, you get paid

The customer signs the payment from their own wallet and sends it to your self-custody wallet. Sardium servers never access the funds.

Why merchants pick it

The weight of real infrastructure, the ease of a snippet.

Non-custodial

We hold funds at no stage. Only the user controls their wallet and holds its keys; our servers never hold private keys.

White-label

Your colour, your brand. The widget looks like a part of your own site, not a third party bolted on.

Multi-chain

USDC and USDT across Polygon, Base, Arbitrum and Optimism.

Licensed providers

KYC for the card purchase is run by the licensed payment provider, under its own licence.

Fast integration

One key, one snippet. A working checkout in an afternoon rather than a quarter.

Verifiable

Every transfer is checkable on the chain and announced to your backend through a signed webhook.

Integration

As simple as an iframe.

Freeze the order on your server with your secret key and get a one-time token; your page embeds the widget with that token and your publishable key. The amount and the recipient never pass through the browser. Your backend only has to verify one signature.

server.ts
// 1. your server: freeze the order with your secret key
const r = await fetch('https://api.sardium.com/v1/checkout/intents', {
  method: 'POST',
  headers: { 'X-Api-Key': process.env.SARDIUM_SECRET_KEY!,
             'content-type': 'application/json' },
  body: JSON.stringify({
    chainId: 'polygon', tokenSymbol: 'USDC',
    amountRaw: '100000000',  // 100 USDC, 6 decimals
    orderId: 'ORD-100'
  })
});
const { data } = await r.json();
// data.token: one use, valid 30 minutes
checkout.html
<!-- 2. your page: the token names the order -->
<iframe
  src="https://app.sardium.com/?intent=TOKEN_FROM_YOUR_SERVER
       &key=pk_live_YOURKEY"
  width="100%" height="640"
  style="border:0"></iframe>
webhook.ts
import { createHmac, timingSafeEqual }
  from 'node:crypto';

// 3. your server: verify the signature, then credit
app.post('/sardium-webhook',
  express.raw({ type: '*/*' }),
  (req, res) => {
  const h = Object.fromEntries(
    (req.header('x-sardium-signature') ?? '')
      .split(',').map((p) => p.split('=')));
  const t = Number(h.t);
  const body = req.body.toString('utf8');
  const want = Buffer.from(createHmac('sha256',
    process.env.SARDIUM_WEBHOOK_SECRET!)
    .update(`${t}.${body}`).digest('hex'));
  const got = Buffer.from(h.v1 ?? '');
  const age = Date.now() / 1000 - t;
  if (!(Math.abs(age) <= 300)
      || got.length !== want.length
      || !timingSafeEqual(got, want))
    return res.sendStatus(401);
  const event = JSON.parse(body);
  // credit the order in event ↑
  res.sendStatus(200);
});

At a glance

The technical shape.

Status
Live, used by businesses.
Assets
USDC and USDT.
Chains
Polygon, Base, Arbitrum, Optimism.
Custody
None at any stage. The stablecoin goes to the customer's own self-custody wallet, and the customer signs the payment to a wallet you control.
Fiat & KYC
Handled by licensed payment providers.
Merchant callback
HMAC-SHA256 signed webhook, verified with one SDK call.
Source
Shared with merchants and auditors on request, including runbooks and the threat model.
Product site

Next step

Want it on your checkout?

Tell us what you sell and where you want the money to land. Full integration docs arrive with your access request.