Building the Future of Stablecoin Interoperability: PYUSD and LayerZero

Moving stablecoins cross-chain using bridges is expensive, risky, and slow. With PYUSD’s new

LayerZero integration, you can now programmatically move PYUSD between Ethereum and

Solana without using third-party bridges or centralized exchanges. This new integration makes

moving PYUSD across chains simple and fast.

Let’s look in detail at the mechanics behind the integration, the advantages over bridging, and

then walk through a short tutorial to see how you can incorporate cross-chain PYUSD into your

application.

How the PYSUD and LayerZero Integration Works

The PYUSD/LayerZero integration uses a burn-and-mint mechanism. Developers call an API

that causes PYUSD tokens to be burned on the source chain and minted on the destination

chain.

Step 1: Burn on source chain: When a user initiates a transfer of PYUSD (from

Ethereum to Solana, for example), the tokens are burned (permanently eliminated) on

Ethereum, removing them from circulation on the source chain.

Step 2: Mint on target chain: Then an equal number of PYUSD tokens are minted on

Solana.

Unlike traditional bridge 1 solutions, this solution:

• Helps Eliminate slippage: Token valuations remain consistent across chains. Since
  
  supply can vary between chains, using traditional bridges can often result in unwanted
  
  trades with inconsistent valuations.
• Speeds up transfers: Transactions generally complete within five minutes, faster than
  
  some other conventional cross-chain transfers that may require lengthy validation
  
  processes.
• Embodies decentralization: Transfers operate without permission and remove reliance
  
  on intermediaries.
• Enhances security: This integration bypasses all bridges. Helps Eliminate liquidity fragmentation and the risk of inflation by controlling the burning and minting. This ensures that one single versioning of PYUSD is used across chains, ensuring token integrity and preventing liquidity fragmentation.

An Integration Made with a Security-First Mindset

The integration was designed with a mindset that prioritizes trust and reliability through multiple

layers of safeguards, including:

• Immutable contracts: Smart contracts are immutable and non-upgradeable. This
  
  eliminates the risks of introducing new vulnerabilities or potential malicious changes.
• Comprehensive audits: The system has undergone two audits by leading blockchain
  
  security firms.
• Decentralized permissionless transfers: Unlike centralized solutions, the integration
  
  operates permissionlessly, removing reliance on (and risks of) intermediaries.

Leveraging Ethereum Improvement Proposals (EIPs)

The integration incorporates two Ethereum Improvement Proposals (EIPs): EIP-3009 and EIP-

2612. Let’s look at each.

EIP-3009: Gasless transfers

EIP-3009 allows “transfer with authorization” for off-chain approvals. This means:

• Off-chain authorization: Users can sign off-chain approvals for on-chain execution.
• Gasless transactions: Gas fees can be handled by the executing party instead of the
  
  user.
• Pull payments: Businesses can create subscriptions where transfers are
  
  programmatically authorized.
  
  

EIP-2612: Streamlined approvals

EIP-2612 allows users to approve token allowances via off-chain signatures. This means:

• Off-chain authorization: On-chain approval transactions are no longer needed.
• Nonce management: Unique identifiers ensure each approval is secure.
• Gas savings: The Permit function allows a message to approve ERC-20 spending to
  
  reduce gas consumption.

Benefits of EIP-3009 and EIP-2612

Together, these EIPs create several benefits:

• Lower entry barriers: Users can participate in token transfers without needing ETH for
  
  gas fees.
• Cost reduction: EIP-2612 removes the need for on-chain approval steps.
• Simplified user experience: Users can interact with dApps or wallets without dealing
  
  with multiple steps or needing technical knowledge.
• Improved developer capabilities: Developers can implement features like subscription
  
  payments, pull transactions, and gasless operations.
• Enhanced security: Nonce management ensures every authorization is unique,
  
  preventing replay attacks. Revocable authorizations give users control over unused
  
  approvals to protect against misuse.

Specifically for the PYUSD/LayerZero integration, these combined EIPs mean that the burn/mint

mechanism can happen with minimal user involvement—one off-chain signature, no separate

approvals, and no extra gas fees required for the user. This creates an easy experience for

users.

Developer tools and resources

To help with integrating transfers into your apps, LayerZero has a wide variety of integration documentation and development utility tools. These APIs are designed to work with existing dApps that extend current DeFi payment systems and allow a simple way to add blockchain payments to Web2 applications with minimal overhead.

How to move PYUSD programmatically

Next let’s walk through some sample code that shows how you can easily integrate PYUSD

transfers into your apps. We’ll work from a script provided by LayerZero.

Step #1: Clone the example repo

First, clone the LayerZero devtools repo and checkout the code tagged with @layerzerolabs/devtools@0.4.1.

$ git clone https://github.com/LayerZero-Labs/devtools.git

$ cd devtools

$ git checkout @layerzerolabs/devtools@0.4.1

Next, navigate to the examples/oft-solana folder:

$ cd examples/oft-solana

Install the project dependencies:

$ npm install

$ npm install @layerzerolabs/lz-evm-sdk-v2



Step #2: Get test tokens

Next we need test tokens.

1. Get test PYUSD from the Paxos Faucet.

2. Get test SOL from the Solana Devnet faucet.

Step #3: Move the PYUSD from Solana to Ethereum

Moving USDC from Solana to Ethereum with LayerZero is simple. We’ll use the tasks/solana/sendOFT.ts script in our repo.

In order to send funds from a Solana account, you’ll need to add the Solana RPC URL and your

Solana private key to the .env file.

#Solana configs

RPC_URL_SOLANA_TESTNET="https://api.devnet.solana.com"

SOLANA_PRIVATE_KEY="<solana_testnet_private_key>"

Now simply run the tasks/solana/sendOFT.ts script! The only parameters you need to

change are the <amount>; and <to_address>;.

Whatever amount you want to send in USD, remember to multiply by

10^6 (1000000) due to the decimal assignment. The to_address is the Ethereum address you

want to receive the PYUSD.

Running on Testnet

$ npx hardhat lz:oft:solana:send \

--program-id paxosVkYuJBKUQoZGAidRA47Qt4uidqG5fAt5kmr1nR \

--amount <amount> \

--from-eid 40168 \

--to <to_address> \

--to-eid 40161 \

--mint CXk2AMBfi3TwaEL2468s6zP8xq9NxTXjp9gjMgzeUynM \

--escrow EXJZbFNmPhrNkJxJ3tq8RyGHzzxPcxNQxSgx6HUHoRfU \

--token-program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

Running on Mainnet

$ npx hardhat lz:oft:solana:send \

--program-id paxosVkYuJBKUQoZGAidRA47Qt4uidqG5fAt5kmr1nR \

--amount <amount> \

--from-eid 30168 \

--to <to_address> \

--to-eid 30101 \

--mint 2b1kV6DkPAnxd5ixfnxCpjxmKwqjjaYmCZfHsFu24GXo \

--escrow 6JHAfeFjJLrn9enjvBUsmqLSy8B8Wyobr4uXuPVKyjhT \

--token-program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb





Let’s look at a few of the important details of how the script works. The script:

● Debits the amount of PYUSD tokens from the env’s Solana account.

● Locks/burns them in the OFT escrow on Solana.

● Sends a bridging message so LayerZero can mint/unlock the equivalent tokens to the

specified EVM address to_address on chain to-eid (40168 for Solana Testnet and

40161 for Ethereum Testnet Sepolia).

The script will output the transaction hash and a link to layerzeroscan. For example:

✅ Sent 25000000 token(s) to destination EID: 40161!

View Solana transaction here:

https://explorer.solana.com/tx/3BY2VboN2cGfh1hcX4pFTo43mDZpnzuWocRmFBJTHiq4

zpiSxhTB9VnTi2X3C4nSD6GuNVQTunspxAe7Y8e9o6FM?cluster=devnet

Track cross-chain transfer here:

https://testnet.layerzeroscan.com/tx/3BY2VboN2cGfh1hcX4pFTo43mDZpnzuWocRmFB

JTHiq4zpiSxhTB9VnTi2X3C4nSD6GuNVQTunspxAe7Y8e9o6FM

That’s it! We were able to send PYUSD from Solana via LayerZero to an Ethereum account in

only a few seconds!

Conclusion

The PYUSD/LayerZero integration delivers a fast, developer-friendly solution for cross-chain

PYUSD transfers and creates a more connected, accessible, and decentralized Web3

ecosystem. For more details, you can learn more about LayerZero’s Omnichain Fungible Token standard.

Keep up with PYUSD here!