Moonbeam RPC with Dwellir

// Example: Send message to Ethereum via Axelar
import { AxelarGMPSDK } from '@axelar-network/axelarjs-sdk';

const sdk = new AxelarGMPSDK({
  environment: 'mainnet',
  moonbeamRpcUrl: 'https://api-moonbeam.n.dwellir.com/YOUR_API_KEY'
});

// Send cross-chain transaction
const tx = await sdk.sendToken({
  destinationChain: 'ethereum',
  destinationAddress: '0x...',
  symbol: 'USDC',
  amount: '100'
});

// GLMR balance (native gas token)
const glmrBalance = await provider.getBalance(address);

// XC-20 token balance (ERC-20 compatible)
const tokenContract = new ethers.Contract(
  '0xTokenAddress',
  ['function balanceOf(address) view returns (uint256)'],
  provider
);
const tokenBalance = await tokenContract.balanceOf(address);

// Query events with proper pagination
async function getEvents(contract, eventName, fromBlock = 0) {
  const filter = contract.filters[eventName]();
  const events = [];
  const batchSize = 2000; // Recommended batch size
  const latestBlock = await provider.getBlockNumber();

  for (let i = fromBlock; i <= latestBlock; i += batchSize) {
    const toBlock = Math.min(i + batchSize - 1, latestBlock);
    const batch = await contract.queryFilter(filter, i, toBlock);
    events.push(...batch);
  }

  return events;
}

const batch = [
  { method: 'eth_blockNumber', params: [] },
  { method: 'eth_gasPrice', params: [] },
  { method: 'eth_getBalance', params: [address, 'latest'] }
];

const results = await provider.send(batch);

const wsProvider = new ethers.WebSocketProvider(
  'wss://api-moonbeam.n.dwellir.com/YOUR_API_KEY'
);

// Subscribe to new blocks
wsProvider.on('block', (blockNumber) => {
  console.log('New block:', blockNumber);
});

// Subscribe to pending transactions
wsProvider.on('pending', (txHash) => {
  console.log('Pending tx:', txHash);
});

const cache = new Map();

async function getCachedBlockData(blockNumber) {
  const key = `block_${blockNumber}`;

  if (!cache.has(key)) {
    const block = await provider.getBlock(blockNumber);
    cache.set(key, block);
  }

  return cache.get(key);
}

// Always account for gas in balance checks
const balance = await provider.getBalance(address);
const gasPrice = await provider.getGasPrice();
const gasLimit = await provider.estimateGas(tx);
const gasCost = gasPrice * gasLimit;

if (balance < (tx.value + gasCost)) {
  throw new Error(`Need ${(tx.value + gasCost) - balance} more wei`);
}

// Get current fee data
const feeData = await provider.getFeeData();

const tx = {
  to: recipient,
  value: amount,
  gasPrice: feeData.gasPrice, // Moonbeam uses legacy gas pricing
  gasLimit: 21000n
};

async function callWithRetry(fn, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (error) {
      if (error.code === 429 && i < maxRetries - 1) {
        await new Promise(r => setTimeout(r, 2 ** i * 1000));
      } else {
        throw error;
      }
    }
  }
}

# Test Moonbeam mainnet
curl -X POST https://api-moonbeam.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Test Moonriver (testnet)
curl -X POST https://api-moonriver.n.dwellir.com/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'

// Test mainnet connection
const mainnetProvider = new JsonRpcProvider(
  'https://api-moonbeam.n.dwellir.com/YOUR_API_KEY'
);

const blockNumber = await mainnetProvider.getBlockNumber();
const network = await mainnetProvider.getNetwork();

console.log('Block number:', blockNumber);
console.log('Chain ID:', network.chainId); // Should be 1284n

from web3 import Web3

# Test connection
web3 = Web3(Web3.HTTPProvider(
  'https://api-moonbeam.n.dwellir.com/YOUR_API_KEY'
))

print('Connected:', web3.is_connected())
print('Chain ID:', web3.eth.chain_id)  # Should be 1284
print('Block number:', web3.eth.block_number)

// Before
const provider = new JsonRpcProvider('https://other-provider.com');

// After
const provider = new JsonRpcProvider(
  'https://api-moonbeam.n.dwellir.com/YOUR_API_KEY'
);

// All existing code works identically
// Same JSON-RPC methods supported
// Same response formats
// Note: Update your API endpoint URL
// Note: Add your Dwellir API key

// Your Ethereum contracts work on Moonbeam without changes
const contract = new ethers.Contract(
  contractAddress,
  abi,
  provider // Just change the provider to Moonbeam!
);

// All contract interactions work the same
const result = await contract.someFunction();