Multi chain

The Moromoro SDK supports multiple blockchain networks. This guide shows how to use the SDK across different chains.

Supported Networks

Network

Chain ID

Native Token

Example RPC

HyperEVM

HYPE

https://rpc.hyperliquid.xyz/evm

BSC

BNB

https://bsc-dataseed.binance.org

Ethereum

ETH

Your RPC URL

Polygon

137

MATIC

https://polygon-rpc.com

Arbitrum

42161

ETH

https://arb1.arbitrum.io/rpc

Avalanche

43114

AVAX

https://api.avax.network/ext/bc/C/rpc

Optimism

ETH

https://mainnet.optimism.io

HyperEVM Example

const { MoroBestRate } = require('@moromoro/moro-sdk')
const { ethers } = require('ethers')

async function swapOnHyperEVM() {
  const provider = new ethers.providers.JsonRpcProvider(
    'https://rpc.hyperliquid.xyz/evm'
  )
  const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider)
  const moroClient = new MoroBestRate(provider, 'hyperevm')

  const HYPE = '0x5555555555555555555555555555555555555555'
  const USDT = '0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb'
  const amountIn = ethers.utils.parseUnits('10', 18)
  const gasPrice = ethers.BigNumber.from('5000000000') // 5 gwei

  const quote = await moroClient.getQuote(HYPE, USDT, amountIn, gasPrice)
  const minOut = ethers.BigNumber.from(quote.amountOut).mul(99).div(100)

  const tx = await moroClient.swap(signer, HYPE, USDT, amountIn, minOut, quote)
  await tx.wait()

  console.log('✓ Swapped on HyperEVM')
}

swapOnHyperEVM()

BSC Example

async function swapOnBSC() {
  const provider = new ethers.providers.JsonRpcProvider(
    'https://bsc-dataseed.binance.org'
  )
  const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider)
  const moroClient = new MoroBestRate(provider, 'bsc')

  // BNB = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee (native)
  // BUSD = 0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56
  const BNB = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
  const BUSD = '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56'
  const amountIn = ethers.utils.parseUnits('1', 18) // 1 BNB
  const gasPrice = ethers.utils.parseUnits('5', 'gwei')

  const quote = await moroClient.getQuote(
    BNB,
    BUSD,
    amountIn,
    gasPrice,
    { enableSplit: true }
  )

  console.log('Will receive:', ethers.utils.formatUnits(quote.amountOut, 18), 'BUSD')

  const minOut = ethers.BigNumber.from(quote.amountOut).mul(99).div(100)
  const tx = await moroClient.swap(signer, BNB, BUSD, amountIn, minOut, quote)
  await tx.wait()

  console.log('✓ Swapped on BSC')
}

swapOnBSC()

Polygon Example

async function swapOnPolygon() {
  const provider = new ethers.providers.JsonRpcProvider(
    'https://polygon-rpc.com'
  )
  const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider)
  const moroClient = new MoroBestRate(provider, 'polygon')

  // MATIC (wrapped) = 0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270
  // USDC = 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174
  const WMATIC = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270'
  const USDC = '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174'
  const amountIn = ethers.utils.parseUnits('1000', 18) // 1000 WMATIC
  const gasPrice = ethers.utils.parseUnits('50', 'gwei')

  // Approve WMATIC first
  await moroClient.approve(signer, WMATIC, amountIn)

  const quote = await moroClient.getQuote(WMATIC, USDC, amountIn, gasPrice)
  console.log('Output:', ethers.utils.formatUnits(quote.amountOut, 6), 'USDC')

  const minOut = ethers.BigNumber.from(quote.amountOut).mul(99).div(100)
  const tx = await moroClient.swap(signer, WMATIC, USDC, amountIn, minOut, quote)
  await tx.wait()

  console.log('✓ Swapped on Polygon')
}

swapOnPolygon()

Arbitrum Example (L2)

For L2 chains like Arbitrum and Optimism, you need to provide L2 gas price.

async function swapOnArbitrum() {
  const provider = new ethers.providers.JsonRpcProvider(
    'https://arb1.arbitrum.io/rpc'
  )
  const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider)
  const moroClient = new MoroBestRate(provider, 'arbitrum')

  // ETH = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
  // USDC = 0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8
  const ETH = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
  const USDC = '0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8'
  const amountIn = ethers.utils.parseUnits('1', 18) // 1 ETH

  // For L2 chains, provide both L1 and L2 gas prices
  const l1GasPrice = ethers.utils.parseUnits('20', 'gwei')  // Ethereum L1
  const l2GasPrice = ethers.utils.parseUnits('0.1', 'gwei') // Arbitrum L2

  const quote = await moroClient.getQuote(
    ETH,
    USDC,
    amountIn,
    l1GasPrice,
    {
      enableSplit: true,
      gasPriceL2: l2GasPrice  // Required for L2 chains
    }
  )

  console.log('Output:', ethers.utils.formatUnits(quote.amountOut, 6), 'USDC')

  const minOut = ethers.BigNumber.from(quote.amountOut).mul(99).div(100)
  const tx = await moroClient.swap(signer, ETH, USDC, amountIn, minOut, quote)
  await tx.wait()

  console.log('✓ Swapped on Arbitrum')
}

swapOnArbitrum()

Optimism Example (L2)

async function swapOnOptimism() {
  const provider = new ethers.providers.JsonRpcProvider(
    'https://mainnet.optimism.io'
  )
  const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider)
  const moroClient = new MoroBestRate(provider, 'optimism')

  // ETH = 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee
  // OP = 0x4200000000000000000000000000000000000042
  const ETH = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
  const OP = '0x4200000000000000000000000000000000000042'
  const amountIn = ethers.utils.parseUnits('1', 18)

  const l1GasPrice = ethers.utils.parseUnits('20', 'gwei')
  const l2GasPrice = ethers.utils.parseUnits('0.001', 'gwei')

  const quote = await moroClient.getQuote(
    ETH,
    OP,
    amountIn,
    l1GasPrice,
    {
      enableSplit: true,
      gasPriceL2: l2GasPrice
    }
  )

  console.log('Output:', ethers.utils.formatUnits(quote.amountOut, 18), 'OP')

  const minOut = ethers.BigNumber.from(quote.amountOut).mul(99).div(100)
  const tx = await moroClient.swap(signer, ETH, OP, amountIn, minOut, quote)
  await tx.wait()

  console.log('✓ Swapped on Optimism')
}

swapOnOptimism()

Avalanche Example

async function swapOnAvalanche() {
  const provider = new ethers.providers.JsonRpcProvider(
    'https://api.avax.network/ext/bc/C/rpc'
  )
  const signer = new ethers.Wallet(process.env.PRIVATE_KEY, provider)
  const moroClient = new MoroBestRate(provider, 'avalanche')

  // WAVAX = 0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7
  // USDC = 0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E
  const WAVAX = '0xb31f66aa3c1e785363f0875a1b74e27b85fd66c7'
  const USDC = '0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E'
  const amountIn = ethers.utils.parseUnits('10', 18) // 10 AVAX
  const gasPrice = ethers.utils.parseUnits('30', 'gwei')

  await moroClient.approve(signer, WAVAX, amountIn)

  const quote = await moroClient.getQuote(WAVAX, USDC, amountIn, gasPrice)
  console.log('Output:', ethers.utils.formatUnits(quote.amountOut, 6), 'USDC')

  const minOut = ethers.BigNumber.from(quote.amountOut).mul(99).div(100)
  const tx = await moroClient.swap(signer, WAVAX, USDC, amountIn, minOut, quote)
  await tx.wait()

  console.log('✓ Swapped on Avalanche')
}

swapOnAvalanche()

Multi-Chain Manager

Utility class to manage swaps across multiple chains.

const { MoroBestRate } = require('@moromoro/moro-sdk')
const { ethers } = require('ethers')

class MultiChainSwapManager {
  constructor(privateKey) {
    this.privateKey = privateKey
    this.clients = {}
    this.providers = {}
  }

  addChain(network, rpcUrl) {
    this.providers[network] = new ethers.providers.JsonRpcProvider(rpcUrl)
    this.clients[network] = new MoroBestRate(
      this.providers[network],
      network
    )
  }

  getSigner(network) {
    return new ethers.Wallet(this.privateKey, this.providers[network])
  }

  async swap(network, srcToken, destToken, amountIn, slippage = 1) {
    if (!this.clients[network]) {
      throw new Error(`Network ${network} not configured`)
    }

    const client = this.clients[network]
    const signer = this.getSigner(network)

    // Get appropriate gas price
    const gasPrice = await this.providers[network].getGasPrice()

    // Get quote
    const isL2 = network === 'arbitrum' || network === 'optimism'
    const quoteOpts = { enableSplit: true }

    if (isL2) {
      quoteOpts.gasPriceL2 = gasPrice.div(10) // Estimate L2 gas
    }

    const quote = await client.getQuote(
      srcToken,
      destToken,
      amountIn,
      gasPrice,
      quoteOpts
    )

    // Approve if needed
    if (srcToken !== '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee' &&
        srcToken !== '0x5555555555555555555555555555555555555555') {
      const approveTx = await client.approve(signer, srcToken, amountIn)
      if (approveTx) await approveTx.wait()
    }

    // Calculate min output
    const minOut = ethers.BigNumber.from(quote.amountOut)
      .mul(100 - slippage)
      .div(100)

    // Execute swap
    const tx = await client.swap(
      signer,
      srcToken,
      destToken,
      amountIn,
      minOut,
      quote
    )

    return tx.wait()
  }
}

// Usage
async function useMultiChainManager() {
  const manager = new MultiChainSwapManager(process.env.PRIVATE_KEY)

  // Configure chains
  manager.addChain('hyperevm', 'https://rpc.hyperliquid.xyz/evm')
  manager.addChain('bsc', 'https://bsc-dataseed.binance.org')
  manager.addChain('polygon', 'https://polygon-rpc.com')

  // Swap on HyperEVM
  await manager.swap(
    'hyperevm',
    '0x5555555555555555555555555555555555555555', // HYPE
    '0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb', // USDT
    ethers.utils.parseUnits('10', 18)
  )

  console.log('✓ Swapped on HyperEVM')

  // Swap on BSC
  await manager.swap(
    'bsc',
    '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', // BNB
    '0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56', // BUSD
    ethers.utils.parseUnits('1', 18)
  )

  console.log('✓ Swapped on BSC')
}

useMultiChainManager()

Getting Network Gas Prices

async function getGasPrices() {
  const networks = {
    hyperevm: 'https://rpc.hyperliquid.xyz/evm',
    bsc: 'https://bsc-dataseed.binance.org',
    polygon: 'https://polygon-rpc.com',
    arbitrum: 'https://arb1.arbitrum.io/rpc',
    optimism: 'https://mainnet.optimism.io'
  }

  for (const [network, rpc] of Object.entries(networks)) {
    const provider = new ethers.providers.JsonRpcProvider(rpc)
    const gasPrice = await provider.getGasPrice()

    console.log(`${network}:`, ethers.utils.formatUnits(gasPrice, 'gwei'), 'gwei')
  }
}

getGasPrices()

Network-Specific Configurations

const NETWORK_CONFIGS = {
  hyperevm: {
    rpc: 'https://rpc.hyperliquid.xyz/evm',
    nativeToken: '0x5555555555555555555555555555555555555555',
    defaultGasPrice: '5000000000', // 5 gwei
    isL2: false
  },
  bsc: {
    rpc: 'https://bsc-dataseed.binance.org',
    nativeToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
    defaultGasPrice: '5000000000',
    isL2: false
  },
  arbitrum: {
    rpc: 'https://arb1.arbitrum.io/rpc',
    nativeToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
    defaultGasPrice: '100000000', // 0.1 gwei
    isL2: true,
    l1GasPrice: '20000000000' // 20 gwei
  },
  optimism: {
    rpc: 'https://mainnet.optimism.io',
    nativeToken: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
    defaultGasPrice: '1000000', // 0.001 gwei
    isL2: true,
    l1GasPrice: '20000000000'
  }
}

function getNetworkConfig(network) {
  return NETWORK_CONFIGS[network]
}

Best Practices

Always check network before transactions

Verify you're connected to the intended network (RPC URL / chain) before signing or sending transactions.

Use appropriate gas prices for each network

Set gas prices according to network conditions. For L2s, provide both L1 and L2 gas pricing when required.

For L2 chains, always provide gasPriceL2 option

L2 chains like Arbitrum and Optimism require an L2 gas price for accurate quoting and execution.

Test with small amounts first on new networks

Validate flow and permissions with minimal amounts before committing larger sums.

Keep separate private keys per network for security

Using different keys per environment or network reduces risk if a key is compromised.