Solana to EVM Swaps

Complete guide for cross-chain swaps from Solana to EVM chains

This guide demonstrates how to create atomic swaps from Solana to EVM-compatible chains. Solana swaps require both relayer announcement and on-chain order publishing.

Overview

Solana to EVM swaps differ from EVM-to-EVM swaps:

• Orders must be announced to the relayer using announceOrder()
• Orders must be published on-chain using Solana transactions
• Address formats use SolanaAddress for Solana and EvmAddress for EVM chains
• Native Solana tokens use SolanaAddress.NATIVE

Prerequisites

• Solana wallet with sufficient SOL for transaction fees
• Sufficient token balance for the swap
• Dev Portal API key from portal.1inch.dev

Complete Example

This example swaps 10 USDT from Solana to USDT on Ethereum.

1. Setup Dependencies

   Import required modules and initialize the SDK.

   import {
     NetworkEnum,
     SDK,
     SolanaAddress,
     HashLock,
     EvmAddress,
     SvmSrcEscrowFactory,
     OrderStatus
   } from '@1inch/cross-chain-sdk'
   import { utils, web3 } from '@coral-xyz/anchor'
   import { randomBytes } from 'node:crypto'
   import { setTimeout } from 'node:timers/promises'
   import assert from 'node:assert'
   
   const authKey = process.env.DEV_PORTAL_API_TOKEN
   assert(authKey, 'Please provide DEV_PORTAL_API_TOKEN')
   
   const signerPrivateKey = process.env.SOLANA_PRIVATE_KEY
   assert(signerPrivateKey, 'Please provide SOLANA_PRIVATE_KEY')
   
   const makerSigner = web3.Keypair.fromSecretKey(
     utils.bytes.bs58.decode(signerPrivateKey)
   )
   
2. Initialize SDK and Addresses

   Configure the SDK and set up token addresses.

   const SOLANA_RPC = 'https://api.mainnet-beta.solana.com'
   const sdk = new SDK({
     url: 'https://api.1inch.com/fusion-plus',
     authKey
   })
   
   // Token addresses
   const USDT_SOL = 'Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB'
   const USDT_ETHEREUM = '0xdac17f958d2ee523a2206206994597c13d831ec7'
   
   const maker = makerSigner.publicKey.toBase58()
   const receiver = '0x962a836519109e162754161000D65d9Dc027Fa0F'
   
   const srcToken = SolanaAddress.fromString(USDT_SOL)
   const dstToken = EvmAddress.fromString(USDT_ETHEREUM)
   const amount = 10_000_000n // 10 USDT
   
   const srcChainId = NetworkEnum.SOLANA
   const dstChainId = NetworkEnum.ETHEREUM
   

   For native SOL, use EvmAddress.NATIVE as the token address.

3. Get Quote

   Request a quote for the Solana to EVM swap.

   console.log(
     `Creating order from wallet ${maker} for [${srcChainId}] ${amount} ${srcToken} -> ${dstToken} [${dstChainId}]`
   )
   
   const quote = await sdk.getQuote({
     amount: amount.toString(),
     srcChainId,
     dstChainId,
     srcTokenAddress: srcToken.toString(),
     dstTokenAddress: dstToken.toString(),
     enableEstimate: true,
     walletAddress: maker
   })
   
   console.log('Got quote', quote)
   
   const preset = quote.getPreset(quote.recommendedPreset)
   assert(quote.quoteId)
   
4. Generate Secrets and Create Order

   Generate secrets and create the Solana order.

   function getSecret(): string {
     return '0x' + randomBytes(32).toString('hex')
   }
   
   const secrets = Array.from({ length: preset.secretsCount }).map(getSecret)
   const secretHashes = secrets.map(HashLock.hashSecret)
   const leaves = HashLock.getMerkleLeaves(secrets)
   
   const hashLock = secrets.length > 1
     ? HashLock.forMultipleFills(leaves)
     : HashLock.forSingleFill(secrets[0])
   
   // Create Solana-specific order
   const order = quote.createSolanaOrder({
     hashLock,
     receiver: EvmAddress.fromString(receiver),
     preset: quote.recommendedPreset
   })
   
5. Announce Order to Relayer

   First, announce the order to the 1inch relayer network.

   const orderHash = await sdk.announceOrder(order, quote.quoteId, secretHashes)
   console.log('Announced order to relayer', orderHash)
   

   This registers your order with the relayer before publishing on-chain.

6. Publish Order On-Chain

   Create and submit the Solana transaction to publish the order on-chain.

   // Create instruction for order creation
   const ix = SvmSrcEscrowFactory.DEFAULT.createOrder(order, {
     srcTokenProgramId: SolanaAddress.TOKEN_PROGRAM_ID
   })
   
   // Build transaction
   const tx = new web3.Transaction().add({
     data: ix.data,
     programId: new web3.PublicKey(ix.programId.toBuffer()),
     keys: ix.accounts.map((a) => ({
       isSigner: a.isSigner,
       isWritable: a.isWritable,
       pubkey: new web3.PublicKey(a.pubkey.toBuffer())
     }))
   })
   
   // Send transaction
   const connection = new web3.Connection(SOLANA_RPC)
   const result = await connection.sendTransaction(tx, [makerSigner])
   
   console.log('Submitted order', result)
   await setTimeout(5000) // Wait for transaction confirmation
   

   Wait for transaction confirmation before proceeding to secret sharing.

7. Monitor and Share Secrets

   Monitor escrow deployments and share secrets when ready.

   const alreadyShared = new Set<number>()
   
   while (true) {
     const readyToAcceptSecrets = await sdk.getReadyToAcceptSecretFills(orderHash)
     const idxes = readyToAcceptSecrets.fills.map((f) => f.idx)
   
     for (const idx of idxes) {
       if (!alreadyShared.has(idx)) {
         // Verify escrow addresses before sharing secrets
         await sdk.submitSecret(orderHash, secrets[idx])
         alreadyShared.add(idx)
         console.log('Submitted secret', secrets[idx])
       }
     }
   
     // Check if order finished
     const { status } = await sdk.getOrderStatus(orderHash)
   
     if (
       status === OrderStatus.Executed ||
       status === OrderStatus.Expired ||
       status === OrderStatus.Refunded
     ) {
       break
     }
   
     await setTimeout(5000)
   }
   
   const statusResponse = await sdk.getOrderStatus(orderHash)
   console.log(statusResponse)
   

Key Differences from EVM

Order Announcement

Solana orders require calling sdk.announceOrder() instead of sdk.submitOrder(). This registers the order with the relayer before on-chain publication.

// Solana
const orderHash = await sdk.announceOrder(order, quote.quoteId, secretHashes)

// vs EVM
const { orderHash } = await sdk.submitOrder(srcChainId, order, quoteId, secretHashes)

On-Chain Publishing

After announcement, Solana orders must be published on-chain using SvmSrcEscrowFactory:

const ix = SvmSrcEscrowFactory.DEFAULT.createOrder(order, {
  srcTokenProgramId: SolanaAddress.TOKEN_PROGRAM_ID
})

EVM orders are automatically published when submitted to the relayer.

Address Types

Use proper address types for each chain:

// Solana addresses
const srcToken = SolanaAddress.fromString(USDT_SOL)
const maker = makerSigner.publicKey.toBase58()

// EVM addresses
const dstToken = EvmAddress.fromString(USDT_ETHEREUM)
const receiver = EvmAddress.fromString('0x...')

Transaction Handling

Solana requires building and sending transactions manually:

const connection = new web3.Connection(SOLANA_RPC)
const result = await connection.sendTransaction(tx, [makerSigner])
await connection.waitForTransaction(result)

Error Handling

try {
  const result = await connection.sendTransaction(tx, [makerSigner])
  await setTimeout(5000)
} catch (error) {
  if (error.message.includes('insufficient funds')) {
    console.error('Insufficient SOL for transaction fees')
  } else if (error.message.includes('TokenAccountNotFound')) {
    console.error('Token account does not exist')
  } else {
    console.error('Transaction failed:', error)
  }
  throw error
}

Best Practices

Wait for Confirmation

Always wait for Solana transaction confirmation before sharing secrets.

Check Token Accounts

Verify token accounts exist before attempting swaps.

Use Recommended Preset

Use quote.recommendedPreset for optimal execution.

Track Shared Secrets

Maintain a set of shared secret indices to avoid duplicates.

Next Steps

EVM to Solana

Learn about swaps from EVM to Solana

Order Lifecycle

Understand order states and transitions