How Crypto Bridges Work: Lock, Mint, Burn

A crypto bridge is a mechanism that lets a token or data move from one blockchain to another. The name suggests a physical connection, but the actual process is more like a careful accounting trick. The bridge does not send your original asset anywhere. Instead, it holds or destroys the original and creates a representation of it on the destination chain. Understanding exactly what happens to your original asset is the key to understanding bridge risk.

Bridges are the single largest category of loss in crypto by value stolen. That is not because every bridge is poorly built, but because the bridge is a concentration point: it holds large amounts of locked collateral, and its logic must be correct on both chains and in the connection between them. A single bug in that logic can drain everything.

What a Bridge Actually Does

When you bridge a token, the bridge software performs three steps, in order:

1. Lock or burn the original on the source chain.
2. Signal the destination chain that the original is locked or burned.
3. Mint a representation on the destination chain.

The representation is often called a “wrapped” token. It is a new token contract on the destination chain that is supposed to be backed 1:1 by the locked original. The wrapped token has its own address, its own supply, and its own rules.

The critical point: the wrapped token is not the same asset as the original. It is an IOU from the bridge. Its value depends on the bridge being able to return the original when you bridge back.

Three Ways to Handle the Original

Bridges differ in what they do with the original asset. This choice determines the trust model and the risk.

Each method has a different failure mode. Lock-and-mint bridges can be drained if the lock contract is hacked. Burn-and-mint bridges rely on the bridge correctly proving the burn; if that proof is forged, tokens can be minted out of thin air. Custodial bridges fail if the custodian is hacked, goes bankrupt, or simply refuses to return the original.

The Lock-and-Mint Process in Detail

Most DeFi bridges use lock-and-mint. Here is what happens step by step:

1. You approve the bridge contract to spend your token.
2. You call the bridge’s deposit function with the amount and destination address.
3. The bridge contract locks your tokens in its own address (or a vault).
4. The bridge emits an event or sends a message to the destination chain.
5. A relayer (or validator) picks up that message and submits it to the destination chain.
6. The destination contract mints wrapped tokens to your address there.

To bridge back, you reverse the process: burn the wrapped token on the destination chain, and the bridge unlocks the original on the source chain.

The security of this process depends on who controls the relayer or validator. If a bridge uses a small set of trusted validators, those validators can collude to steal funds. If it uses a decentralized network, the risk is lower but still present.

Why Bridges Are a Prime Target for Attacks

Bridges hold large amounts of value in one place. That makes them attractive targets. But the deeper reason bridges get hacked is that they are complex. A bridge must:

• Correctly parse messages from the source chain.
• Validate signatures or proofs.
• Handle edge cases like reorgs (temporary chain reorganizations).
• Ensure that the mint and burn are atomic (cannot be done twice).

A bug in any of these can be exploited. For example, if the bridge does not properly verify that a message came from the source chain, an attacker can forge a message to mint tokens without locking anything. If the bridge does not handle reorgs, an attacker can deposit, wait for a reorg, and then withdraw again.

The largest bridge hacks have involved:

• Weak validator sets – a small group of signers that could be compromised.
• Signature verification flaws – the bridge accepted fake proofs.
• Logic bugs in the token contract – the wrapped token itself had a vulnerability.

What People Get Wrong About Bridges

A common mistake is to think that a bridge is a single smart contract. In reality, a bridge is a system of multiple contracts, off-chain relayers, and sometimes a separate validator network. The user only sees the front end, but the risk is distributed across all components.

Another misdiagnosis is that “the bridge was hacked” means the blockchain was hacked. Usually, the underlying blockchains (like Ethereum or Solana) are not compromised. The bridge’s own code or infrastructure was. That is why a bridge can be drained while the chains themselves continue to work normally.

People also assume that a wrapped token is identical to the original. It is not. A wrapped token is a separate asset with its own market price, which can deviate from the original. If the bridge becomes illiquid or is hacked, the wrapped token can trade at a discount or become worthless.

These mistakes are natural because the user interface hides the complexity. The bridge shows a simple “swap” screen, and the user never sees the locked vault or the validator signatures. But the risk is real.

How to Assess a Bridge’s Risk

Before using a bridge, consider these factors:

• Who controls the bridge? A bridge run by a single company is a custodial risk. A bridge with a decentralized validator set is different.
• Is the bridge code audited? Audits reduce risk but do not eliminate it. Many hacked bridges were audited.
• How long has the bridge been live? Older bridges have been tested more, but they can still be hacked.
• What is the total value locked? A bridge with a huge TVL is a bigger target.
• What happens if the bridge fails? Can you get your original back? For lock-and-mint, if the bridge is hacked, the original is gone.

There is no such thing as a “safe” bridge. Every bridge involves trade-offs between decentralization, speed, and cost. The safest approach is to use the smallest bridge necessary, for the shortest time, with an amount you can afford to lose.

Commands and Tools for Investigating a Bridge

If you want to see what a bridge actually does, you can inspect its smart contracts on a block explorer. For example, on Etherscan, you can view the contract’s source code and its transactions. Here are some commands that help:

# Get the balance of a bridge contract on Ethereum (using cast)
cast balance 0x1234... # replace with bridge address

# Get the total supply of a wrapped token (using cast)
cast call 0xWrappedToken "totalSupply()(uint256)"

# Get the number of validators for a bridge (if it has a registry)
cast call 0xBridge "validatorCount()(uint256)"

These commands return raw numbers. The balance shows how much is locked. The total supply shows how many wrapped tokens exist. The validator count shows how decentralized the bridge is. If the balance is much larger than the supply, or vice versa, that is a red flag.

The Bottom Line on Bridge Mechanics

A bridge is not a pipe. It is a ledger. The original asset is locked, burned, or held by a custodian, and a representation is created elsewhere. The security of that representation depends entirely on the bridge’s design and operation. Bridges have been the largest source of crypto losses because they concentrate value and complexity in one place. Understanding what happens to your original asset is the first step to using a bridge with open eyes.