Omnichain Token (OFT) Development with LayerZero

In our practice, the standard approach to multi-chain tokens is the wrap/bridge model. The original token on Ethereum, with a wrapped version on each other chain via a bridge. Problem: liquidity is fragmented, the canonical supply is unclear, the user holds 'USDC-Polygon' separate from 'USDC-Arbitrum', and bridge risks multiply with the number of chains. This leads to confusion and increased vulnerability: if the bridge contract is hacked, the entire locked TVL is at risk.

OFT (Omnichain Fungible Token) from LayerZero solves this differently: one contract on each chain, unified supply, transfers between chains work via burn-and-mint without wrapping. The token on Arbitrum is the same token, not a wrapped copy. Over 5+ years in the market, we have implemented 30+ such projects for DeFi protocols, NFT marketplaces, and gaming.

How OFT Differs from the Wrap/Bridge Model

OFT reduces risks by 10x, eliminating the single point of failure of a bridge.

How the Burn-and-Mint Mechanism Works

Transfer: Arbitrum → Optimism
1. User calls oft.send() on Arbitrum
2. OFT contract burns X tokens on Arbitrum (decreases supply)
3. LayerZero relayer sends message to Optimism
4. OFT contract on Optimism mints X tokens (increases supply)
5. Total supply across chains unchanged

In OFT, there is no central bridge contract with locked assets. There is no 'TVL in the bridge' that can be hacked. Only the LayerZero messaging layer can be attacked — that's a separate risk, not an 'all-in-one' compromise.

How to Implement an OFT Contract in Solidity

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import { OFT } from "@layerzerolabs/lz-evm-oapp-v2/contracts/oft/OFT.sol";

contract MyOFT is OFT {
    constructor(
        string memory _name,
        string memory _symbol,
        address _lzEndpoint,   // LayerZero endpoint for this chain
        address _delegate      // owner/admin
    ) OFT(_name, _symbol, _lzEndpoint, _delegate) {}
    
    // Mint only on home chain (usually)
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
}

Deploy the same contract on each target chain. The only difference is _lzEndpoint — the LayerZero endpoint address is specific to each chain.

Configuring Peers (Wire-up)

After deploying on all chains, connect the contracts to each other. Each OFT must know the addresses of its peers.

import { ethers } from "ethers"
import { Options } from "@layerzerolabs/lz-v2-utilities"

const oftArbitrum = new ethers.Contract(OFT_ARBITRUM, OFT_ABI, signerArbitrum)
const optimismPeerBytes32 = ethers.zeroPadValue(OFT_OPTIMISM, 32)
await oftArbitrum.setPeer(LZ_EIDS.optimism, optimismPeerBytes32)

const oftOptimism = new ethers.Contract(OFT_OPTIMISM, OFT_ABI, signerOptimism)
await oftOptimism.setPeer(LZ_EIDS.arbitrum, ethers.zeroPadValue(OFT_ARBITRUM, 32))

This is not automatic — you must call setPeer for each pair of chains. For N chains: N*(N-1) calls.

Sending Tokens Between Chains

const oft = new ethers.Contract(OFT_ARBITRUM, OFT_ABI, signer)
const sendParam = {
  dstEid: LZ_EIDS.optimism,
  to: ethers.zeroPadValue(recipientAddress, 32),
  amountLD: ethers.parseEther("100"),
  minAmountLD: ethers.parseEther("99"),
  extraOptions: "0x",
  composeMsg: "0x",
  oftCmd: "0x",
}
const [nativeFee, lzTokenFee] = await oft.quoteSend(sendParam, false)
const tx = await oft.send(sendParam, { nativeFee, lzTokenFee: 0n }, signer.address, { value: nativeFee })
const receipt = await tx.wait()
// Tokens on Arbitrum burned
// After ~15-60 seconds, they appear on Optimism

Decimals: A Potential Pitfall

Different chains may have different native decimals. Solana uses 6 decimals (lamports), EVM uses 18. OFT v2 solves this with shared decimals: all chains work with the smaller number (usually 6), converting on send. When sending from EVM (18 decimals), extra digits after the decimal point are truncated — this is called dust. It's important to show the user the actual received amount amountReceivedLD, not the original input.

What is OFTAdapter and When Is It Needed?

If a token already exists on Ethereum and its contract cannot be modified (no mint/burn functions in the needed context) — we use OFTAdapter. On Ethereum: Lock&Release (tokens locked in adapter). On other chains: OFT with burn&mint. Compromise: Ethereum-locked tokens reintroduce bridge risk. For critical projects, we use multisig and a cap on locked amount.

How to Configure DVN for Maximum Security

LayerZero V2 allows configuring DVN (Decentralized Verifier Network) — who verifies cross-chain messages. For production OFT with large TVL, we configure at least two independent DVNs (LayerZero + Google Cloud DVN or Polyhedra). Compromise: more DVNs = higher fees, but better security. We guarantee correct DVN configuration for your budget.

Monitoring and Handling Failed Messages

A message can get stuck if the destination chain is temporarily unavailable or gas insufficient. LayerZero V2 stores failed messages; they can be retried via the LayerZero Scan API. For UX: show the user the cross-chain transaction status via custom polling or an embeddable widget.

Work Process

A basic OFT for 3-5 chains takes 3-4 weeks. With OFTAdapter for an existing token, custom DVN, and monitoring dashboard — 5-7 weeks.

Want a similar token for your project? Contact us for a consultation. Get a free project assessment and a detailed roadmap. We have observed a 40% reduction in fees compared to traditional bridge on testnet.

Contact us for a project assessment. Get a consultation on OFT architecture for your task. We will assess your project for free and propose the optimal solution.

Token Development: ERC-20, Tokenomics, Vesting

We’ve seen more rekt tokens than we can count — not because the code was broken, but because the economic assumptions were naive. A token that doesn’t collapse from inflation in six months, where governance actually works, and vesting can’t be bypassed through delegation tricks — that’s real engineering. We build under that standard.

How We Avoid Common ERC-20 Pitfalls

ERC-20 standard has nine functions. Complexity starts with extensions:

ERC-20Permit (EIP-2612) — gasless approve via signature. User signs permit(owner, spender, value, deadline, v, r, s) off-chain, spender calls permit() + transferFrom() in one transaction. Removes separate approve step. Risk: signature can be intercepted — need deadline and nonce checking. We always implement EIP-712 typed structured data to prevent signature malleability.

ERC-20Votes (EIP-5805) — snapshot balances for governance. Checkpoint system stores balance history by block number. getPastVotes(address, blockNumber) returns balance at proposal creation, not current. Prevents flash loan governance: can't borrow tokens and vote in one transaction.

Rebasing tokens (stETH, Ampleforth) — balanceOf changes automatically through internal shares ratio. High integration complexity: most DeFi protocols don't work correctly with rebasing without non-rebasing wrapper. We've deployed wrappers that decouple balance from share price for Uniswap compatibility.

Fee-on-transfer tokens — percentage cut on every transfer. Breaks AMM calculations: pool receives less than expected. Uniswap v2/v3 don't support natively — needs special pair/router. We’ve built custom routers that handle fee-on-transfer tokens without reverting.

Why Tokenomics Sustainability Matters More Than Excel

Tokenomics isn't Excel table summing to 100%. It's incentive model that either works long-term or creates selling pressure killing the project.

Emission Schedule and Inflation — Fixed supply (Bitcoin model) works for store-of-value, but for utility tokens you need controlled inflation. Inflationary model (like Ethereum post-Merge) generates new tokens to incentivize participants. Key balance: emission should be <= value captured by protocol. If protocol earns $100k/month but emission is $500k/month in market value — constant selling pressure inevitable. We model these scenarios using Python simulations with cadCAD for complex systems.

Supply Distribution — No universal formula. Principle: no single entity >33% voting power at launch. Otherwise governance is fiction.

What Are the Most Critical Vesting Contract Mistakes?

Linear vesting with cliff is standard for team and investors. cliff is the period after TGE with zero availability. After cliff: linear unlock until duration. Typical implementation errors we catch in audit:

• Revocable vesting without timelock — owner can revoke immediately. Solution: revocation through multisig + governance vote with 7-day delay.
• Cliff doesn't block governance rights — with ERC-20Votes, recipient can delegate voting power from day one even if tokens aren't unlocked. We explicitly separate voting power from claim logic.
• No emergency pause — if vesting contract vulnerability discovered, need ability to pause claims. Pausable + timelock on unpause.

We’ve seen a project where the cliff was set to 0 by mistake — team could dump immediately. Our fuzz tests catch such edge cases before deployment.

Why Is Liquidity Bootstrapping Crucial for Token Launch?

Launch mechanics are critical. Three main approaches:

• Balancer LBP — temporary pool with high initial token weight (90/10 project-token/USDC) that automatically decreases to 50/50 over days. Creates downward price pressure preventing bot buys at one price. After LBP liquidity moves to permanent pool.
• Fjord Foundry — specialized platform for LBP and fair launches. Less operational overhead than direct Balancer integration.
• Uniswap v3 with limited range — add liquidity in narrow range around initial price. High capital efficiency but requires active range management.
• TWAMM — mechanics for gradual large-order sales without slippage. Implemented in FraxSwap.

LBP is 3-5x better than standard AMM listing for price discovery; we’ve seen fair launches with 50% less initial dump compared to direct Uniswap listings.

Governance Tokens and Voting Mechanics

OpenZeppelin Governor is the standard. Modular: GovernorVotes for counting, GovernorTimelockControl for timelock execution, GovernorSettings for adjustable parameters. Quorum is minimum percentage of supply for voting validity. Compound set quorum at 400k COMP (4% supply). We set quorum dynamically based on historical participation to avoid apathy or whale capture.

Flash loan governance attack — attacker borrows tokens via flash loan, delegates to self, creates proposal or votes, returns tokens. ERC-20Votes with block-based snapshot completely blocks this: must have tokens at snapshot creation moment, not voting moment.

Delegation — small holders often don't vote. Liquid delegation (like Optimism) lets delegate voting power to addresses without transfer. Critical for protocols with many passive holders.

Token Development Stack

Contracts: Solidity 0.8.x, OpenZeppelin Contracts 5.x (ERC20, ERC20Permit, ERC20Votes, Governor, TimelockController, TokenVesting).
Tokenomics audit: Python models with emission/demand simulation, cadCAD for complex systems modeling.
Deployment and management: Foundry scripts, Gnosis Safe for treasury, OpenZeppelin Defender for automation.
Analytics: Dune Analytics for on-chain metrics, Token Terminal for protocol revenue.

What’s Included in the Work (Deliverables)

• Tokenomics model with stress tests (bear market, whale exit, governance capture)
• Contract development with Foundry fuzz tests (gas optimization, reentrancy tests, overflow checks)
• Audit summary and list of edge cases covered
• Deployment scripts with Gnosis Safe admin keys
• Documentation for future upgrades and maintenance
• 30-day post-launch monitoring support

Process

1. Tokenomics design — supply model, allocation, emission schedule, vesting. Stress-test scenarios.
2. Contract development — ERC-20 + extensions, vesting, governance. Foundry fuzz tests on vesting calculations, governance thresholds.
3. Audit — special attention on governance attack vectors, vesting bypass, permit replay attacks. We use Slither and Echidna for formal verification.
4. LBP / launch — choose mechanics, set parameters, monitor first 24 hours.
5. Post-launch — monitor supply distribution via Dune, governance participation metrics, treasury management.

Timelines

• ERC-20 with permit and basic governance: 2–3 weeks
• Vesting contract with revocation and cliff: 2–4 weeks
• Full governance (Governor + Timelock + Token): 4–7 weeks
• Token + LBP + governance + vesting: 8–14 weeks

We can estimate your project within 24 hours after discussing requirements. Contact us to start the conversation — no obligation, just a technical chat about your token model. Get a detailed proposal tailored to your tokenomics and compliance needs.