> Tell me about the company bridge and stablecoins
short version: bridge is a (now stripe-owned) stablecoin infra company: apis to accept/send stablecoins, custody wallets, issue white-label stablecoins (and its own “usdb”), and even spin up visa cards that spend from a stablecoin balance. it’s basically “stripe, but with stablecoins as the rail.” (Stripe, bridge.xyz, apidocs.bridge.xyz)
details, bc you probably want the receipts:
who/what: founded 2022 by zach abrams + sean yu (ex square/coinbase/airbnb/brex). stripe closed the acquisition on feb 4, 2025. branding is still “bridge,” but it’s a stripe company rn. (TechCrunch, bridge.xyz, Stripe)
what it ships: “orchestration” apis to move/store/accept stablecoins; “issuance” apis to create your own branded stablecoin or use bridge’s usdb; custodial wallets; and “cards” to issue visa cards that draw on stablecoin balances. (bridge.xyz)
cards x visa: on apr 30, 2025 visa + bridge launched stablecoin-linked card issuing so devs can programmatically issue cards in multiple countries via one api. (Visa Investor Relations, Stripe)
usdb (their coin): dollar-pegged, marketed as 1:1 backed by cash + short-duration money market funds at blackrock; pitch includes sharing the reserve yield with builders/users (vs issuer keeping it all). afaict, that’s the differentiator vs usdc/usdt. (bridge.xyz, Ledger Insights)
live usage: e.g., neobank slash just launched “usdsl” on bridge for global b2b payments (goal: faster settlement, lower fx). (CoinDesk, Yahoo Finance)
context on stablecoins (super quick):
fiat-backed (usdt, usdc, pyusd, etc.) = tokens redeemable for dollars held as cash/treasuries; used for cross-border and 24/7 settlement. bridge plugs into this stack and also issues its own. (Circle)
why anyone cares rn: costs + speed vs switf/ach, and global coverage. even tradfi is leaning in (visa partnership; stripe rolling stablecoin accounts to 100+ countries). (Stripe, Bloomberg.com)
caveats / risk notes (bc be real):
“1:1 backing” and “yield-sharing” are claims—read the docs + legal fine print; reserve structure, segregation, and who actually custodies the funds matter. bridge says reserves are in segregated, bankruptcy-remote accounts with regulated institutions, but disclosures aren’t as battle-tested as usdc’s transparency stack. (apidocs.bridge.xyz, Circle)
regulation is in flux country-by-country; product availability and compliance obligations will vary (money transmission, securities if yield is shared, etc.). idk your jurisdiction, so confirm before you ship.
tl;dr: if you’re building with stablecoins, bridge gives you a one-stop api: on/off-ramps, wallets, issuance (incl. usdb), and spend via visa—now with stripe’s distribution. if you want chains/fees/regions they support rn, say the word and i’ll pull the exact matrix. (bridge.xyz, Stripe)
> How are stablecoins different from Fiat? Is stablecoins another layer, something like compilers that match c code to specific machine code? The local Fiat will be c code, the stablecoins will be assembly and the machine code will be a Fiat of different currency?
short answer: stablecoins aren’t new money; they’re a new RAIL + FORMAT for old money. they wrap fiat (usually usd) into a blockchain-native IOU so it can move/settle 24/7 with code.
what that means, concretely:
issuer: fiat (cash/base money) = central bank liability; bank deposit = commercial bank liability; stablecoin = private issuer (or protocol) liability. different legal umbrellas, different recourse.
settlement: cash = physical handoff; bank deposit = private bank ledgers + rtgs/ach/swift; stablecoin = public chains (eth/solana/etc.). same dollars, different plumbing.
convertibility: bank deposits ↔ cash at par (modulo bank failure); stablecoin ↔ fiat at par only if issuer/redeemers actually honor it. pegs are claims, not laws.
risk stack: fiat (sovereign, inflation); deposits (bank/insurer risk); stablecoins (issuer reserve quality, redemption gates, chain/bridge risk, smart-contract bugs, regs). this is where things break first (see ust/terra; overcollateralized ones survive better; fully-reserved fiat ones act like e-money).
features: programmability + composability (contracts can hold/spend them), global reach, finality mins not days; privacy is pseudonymous not cash-anonymous; compliance varies by venue.
your compiler analogy (cute) but off by a layer:
think in three axes: SEMANTICS (economic unit: usd/eur/inr), ENCODING (how the claim is represented: cash note, bank ledger entry, blockchain token), TRANSPORT (which rails move it: rtgs/ach/swift vs ethereum/solana).
stablecoins change ENCODING + TRANSPORT, not SEMANTICS. a usdc is still “usd semantics,” just token-encoded and chain-transported.
fx (usd→inr) is a SEPARATE translation step done by a market maker/exchange; the chain doesn’t magically compile usd into inr. you still need a counterparty and a price.
if you must force a cs metaphor:
semantics = c the language (usd as the unit of account)
encoding = object file format (bank ledger vs token)
transport = linker/loader + bus (ach/swift vs blockchain)
fx = transpiler to a different language (usd→inr via a market/exchange)
stablecoins aren’t “assembly” for fiat; they’re more like “the same program packaged as a wasm module so it runs anywhere.”
types, bc taxonomy matters:
fiat-backed custodial (usdc, pyusd, etc.): reserves = cash/treasuries; redeemable if kyc’d; lowest volatility; issuer/blacklist risk.
crypto-backed overcollateralized (dai in practice): on-chain collateral >100%; peg via incentives; carries on-chain liquidity risk.
algorithmic/seigniorage (terra/ust et al.): peg via reflexivity; historically fragile. proceed with… lmao no.
tl;dr: stablecoins = tokenized fiat claims with public, programmable settlement. not new currency, just a different wrapper and pipe. useful for speed/composability; still subject to issuer + market + chain risk.
> Give me an example of a transaction done through stablecoins. Add as much detail as possible and mention where the real “value” of the money resides at each step
here’s a concrete, end-to-end example with maximal guts. scenario: you (payer) in india pay a freelancer in nigeria 1,000 usdc on solana, then they off-ramp to ngn. i’ll track “who owes what to whom” at every hop (aka where the real value sits).
object: usdc = a digital IOU from the issuer for 1 usd per token.
backing: issuer holds fiat reserves (cash/treasuries) at custodians; the tokens are its liability, reserves are its asset.
key idea: chains record who holds the IOU; the IOU’s value lives in the issuer’s reserves.
action: you move inr from your bank to a regulated crypto on-ramp/exchange.
ledger moves:
your bank deposit (inr) ↓; your bank’s liability to you shrinks.
on-ramp’s bank deposit (inr) ↑; the on-ramp now owes you a balance in its system.
where the value is rn: at the on-ramp’s bank (a commercial bank deposit asset the on-ramp holds).
action: inside the on-ramp, you trade inr → usdc at the quoted inr/usdc rate (fx + spread + fee).
what actually happens under the hood (typical paths):
simplest: the on-ramp already has inventory of usdc in a hot wallet. they credit your exchange account 1,000 usdc and debit their inventory 1,000.
or: a market maker sells you usdc and later redeems or mints with the issuer to balance their book.
where the value is rn:
your “1,000 usdc” is now an issuer liability owed to the on-ramp’s omnibus wallet on-chain.
the economic backing sits in the issuer’s reserves (cash/treasuries), not at the on-ramp. the on-ramp just controls the claim for you.
action: you provide your solana address; the on-ramp submits a token transfer: on-ramp-wallet → your-wallet, 1,000 usdc. network fee paid in a dust amount of sol. finality in seconds.
chain effect: ownership of those exact token units flips to keys you control.
where the value is rn: still the issuer’s reserves. only the pointer (who can redeem the IOU) changed.
action: you push 1,000 usdc on solana to their address. they see it confirmed in a few secs.
settlement semantics: this is final at the chain level (subject to chain guarantees); there’s no correspondent bank, no cut-off windows.
where the value is rn: still in issuer reserves; now the freelancer controls the redemption claim via their keys.
if they hold usdc, nothing redeems. the IOU persists, backed by issuer reserves.
value rn: issuer reserves; the risk stack = issuer/asset risk + chain blacklisting/smart-contract risk.
action (custodial off-ramp): freelancer deposits 1,000 usdc to a local exchange in nigeria.
chain: their wallet → exchange wallet (1,000 usdc).
kyc/aml checks happen here.
the exchange sells usdc → ngn:
internally, either a market maker buys the 1,000 usdc (paying ngn) or the exchange itself takes the other side.
to square books, the buyer can redeem with the issuer (burn 1,000 usdc, receive ~$1,000 usd to their bank) or keep the usdc as inventory for future sellers.
payout: exchange credits freelancer’s ngn balance, then sends a local bank transfer.
where the value is rn (stepwise):
when exchange receives tokens: issuer reserves back the IOU; exchange controls it.
if redemption happens: issuer destroys 1,000 usdc and wires usd to the redeemer’s bank → now the value sits as a commercial bank usd deposit owned by the market maker/exchange.
fx usd→ngn occurs via banking/forex rails; the counterparty’s ngn bank deposit funds the freelancer’s payout.
after local transfer clears, the freelancer ends with a commercial bank deposit (ngn) at their bank.
net: the tokenized claim is extinguished (if redeemed); the “value” has migrated from issuer reserves → redeemer’s usd deposit → ngn deposit at the freelancer’s bank.
assume:
on-ramp fee 0.50% on fiat buy, spread 0.20% (effective 0.70%).
solana transfer fees ≈ negligible for this size.
off-ramp fee 1.00% + fx spread 0.40% on usd→ngn.
if you intend to deliver exactly 1,000 usdc to the freelancer, you’d buy a bit more to cover on-chain dust, but ignoring dust:
you pay: inr for 1,007.07 usdc gross, the on-ramp clips 0.70% → 1,000 usdc net to your wallet.
you send: 1,000 usdc to freelancer (fee ~$0.00x).
they off-ramp: 1,000 × (1 − 1.00% − 0.40%) = 985.9 usd-equiv worth of ngn hits their bank (at whatever fx rate).
moral: most friction is on/off ramps + fx, not the chain.
your bank/on-ramp: transfer limits, blocked deposits → value stuck as your bank deposit or on-ramp deposit.
issuer: freeze/blacklist or redemption gates → value still in issuer reserves, but your ability to realize it is impaired.
chain: outages/bugs don’t erase reserves, but delay control changes. value remains in reserves while ownership can’t update.
off-ramp/fx: local controls, illiquid books → value trapped as usdc at exchange or as usd at a correspondent bank waiting for fx.
unit of account: usd (semantic layer) never changed.
encoding/transport:
bank world: commercial bank deposits (inr/usd/ngn) on private ledgers.
crypto world: usdc tokens on a public ledger.
“real value” at each step:
before buy → your bank deposit (inr)
after buy, before withdraw → issuer reserves back the usdc; exchange controls the claim
after withdraw / after you pay → issuer reserves, with you/freelancer controlling the claim
after off-ramp redemption → usd bank deposit of the redeemer
after fx + payout → freelancer’s ngn bank deposit
stablecoins don’t mint new value; they let you re-encode and teleport a fiat claim across an open settlement rail, then decode it back into local deposits. everything else is fees, risk, and latency.
> Where in this flow are transactions cheaper or being made easy compared to Fiat to Fiat transactions? Because ultimately it is a Fiat to Fiat transaction
short version: the savings aren’t at the endpoints (fiat→on-ramp and off-ramp→fiat); they’re in the MIDDLE (the “teleport” leg) and in OPS (automation, 24/7, fewer hops). it’s still fiat→fiat overall, but the center of the pipeline gets way cheaper/faster and that often dominates.
where it’s cheaper/easier vs bank-only rails:
cost: cents to fractions of a cent per tx on fast chains vs $10–$50 wire fees or ~2–3% card rails.
speed: seconds/minutes, 24/7/365, no cutoffs or “banking hours.”
fewer intermediaries: no correspondent chain, so fewer tolls and fewer failure modes (fewer returns/compliance holds).
push, final-ish: no chargebacks. for b2b/creator payouts, that replaces card interchange + chargeback risk with near-zero network fees.
no pre-funding nostro/vostro, no “float stuck over the weekend.”
example opportunity cost: $100k delayed 2 business days at 5% annual cost of capital ≈ $27 saved per transfer simply by shaving latency. tiny per tx, material at scale.
programmable: webhooks/scripts settle + post to your ledger instantly; no csv wrangling or opaque bank refs.
composability: escrow, split-payments, streaming pay, conditional release — all “one tx,” which subs out legal/escrow/admin fees you’d otherwise pay.
where it’s NOT cheaper (be real):
great domestic rails (upi in india, sepa instant in eu): bank transfer is ~free and instant; stablecoins add on/off-ramp fees for no gain.
weak/expensive off-ramps or illiquid local fx: you’ll eat 1–3% on the way out; then the advantage of a near-free middle hop shrinks or flips.
compliance friction: if your counterparties can’t/won’t kyc at exchanges, you’ll pay an aggregator to mediate (fees creep back in).
how to think about total cost (rough mental model):
total = on-ramp fee + chain fee + off-ramp fee + fx spread ± slippage + your time/ops cost − working-capital saved
best case (both sides willing to hold/spend stablecoin; no off-ramp): ~0.0x% + seconds.
typical cross-border with healthy ramps: ~1–3% all-in and same-day, vs wires/remitters that land ~2–5% and 1–3 biz days (or cards at 2–4% + fx).
worst case (bad off-ramp, tight regs): >3–5% and lots of friction; just use bank rails.
mapping to the earlier india→nigeria example:
cheaper/easier: step 3–4 (on-chain transfer + finality). that’s where you win on fees/speed and ops.
break-even/depends: step 2 + 6 (on/off-ramps + fx). if those ramps are competitive, you still net ahead; if not, they eat the savings.
“where the value lives” doesn’t change this: it sits in the issuer’s reserves during the middle hop; you’re optimizing the transport/ops, not conjuring new value.
tl;dr: stablecoins don’t change the unit (usd/inr/etc.); they change the ENCODING + TRANSPORT. savings come from a near-free, 24/7 middle leg and programmable ops. if your ramps/fx are decent or you can stay on-chain end-to-end, you win; if your ramps are trash, you don’t. afaict that’s the honest cut.