Transfer Assets from Ethereum into Polkadot¶
Introduction¶
This guide walks you through transferring tokens from Ethereum to Polkadot using the ParaSpell XCM SDK and Snowbridge. Snowbridge is a trustless, decentralized bridge integrated into the Polkadot protocol that enables secure asset transfers between the Ethereum and Polkadot ecosystems.
How the Bridge Works¶
The following diagram shows the complete flow when bridging WETH from Ethereum to Polkadot:
sequenceDiagram
participant User
participant Ethereum
participant Relayers
participant Polkadot
User->>Ethereum: 1. Approve & send tokens
Ethereum->>Ethereum: Lock tokens
Note over Relayers: ~30 min relay
Relayers->>Polkadot: 2. Relay message
Polkadot->>Polkadot: Verify & mint tokens
Polkadot-->>User: 3. Tokens availableIn this guide, you will:
- Set up an Ethereum development environment with the ParaSpell SDK
- Approve tokens for the Snowbridge Gateway contract
- Build and execute a bridge transfer from Ethereum to Polkadot Hub
- Monitor the transfer status
Prerequisites¶
Before you begin, ensure you have the following:
- A basic understanding of XCM.
- Familiarity with JavaScript/TypeScript and Ethereum development.
- Node.js v18 or higher and npm installed.
- An Ethereum wallet with WETH tokens. See Prepare Tokens for Bridging for instructions to wrap ETH if needed.
- A Polkadot account to receive the bridged assets.
Prepare Tokens for Bridging¶
To bridge ETH, you need to wrap it into WETH first. The WETH contract on Ethereum mainnet is:
Why WETH instead of ETH?
Snowbridge only supports ERC-20 tokens—it cannot bridge native ETH directly. The bridge uses a standardized token interface to lock assets on Ethereum and mint corresponding representations on Polkadot. Since native ETH doesn't conform to the ERC-20 standard, you must first wrap it into WETH (Wrapped ETH), an ERC-20-compliant token pegged 1:1 to ETH.
You can wrap ETH by:
- Visiting the WETH contract on Etherscan
- Connecting your wallet
- Calling the
depositfunction with the amount of ETH you want to wrap
Initialize Your Project¶
Follow these steps to setup and initialize your project: 1. Create the project folder using the following commands:
- Initialize the JavaScript project:
Install dev dependencies:
Install the ParaSpell SDK, its Snowbridge extension, and viem, which the extension uses to sign Ethereum transactions:
Now add the following setup code to index.ts:
import { Builder, getBridgeStatus } from '@paraspell/sdk';
import { approveToken, getTokenBalance } from '@paraspell/evm-snowbridge';
import { createClient } from 'polkadot-api';
import { getWsProvider } from 'polkadot-api/ws';
import { createPublicClient, createWalletClient, formatUnits, http, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';
// Ethereum mainnet RPC endpoint (use your own API key)
const ETH_RPC = 'https://eth-mainnet.g.alchemy.com/v2/INSERT_API_KEY';
// Polkadot Bridge Hub RPC endpoint, used to check the bridge status
const BRIDGE_HUB_RPC = 'wss://polkadot-bridge-hub-rpc.polkadot.io';
// WETH contract address on Ethereum mainnet
const WETH_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
// WETH has 18 decimals
const WETH_UNITS = 1_000_000_000_000_000_000n;
// Amount to bridge: 0.001 WETH (raw units as bigint)
const AMOUNT = WETH_UNITS / 1000n;
// Your Polkadot address to receive the bridged tokens (SS58 format)
const RECIPIENT_ADDRESS = 'INSERT_YOUR_POLKADOT_ADDRESS';
// Connect to Ethereum mainnet
// For a browser wallet (MetaMask), use custom(window.ethereum) as the transport
const walletClient = createWalletClient({
account: privateKeyToAccount('INSERT_PRIVATE_KEY' as Hex),
chain: mainnet,
transport: http(ETH_RPC),
});
const publicClient = createPublicClient({ chain: mainnet, transport: http(ETH_RPC) });
Replace the following placeholders:
INSERT_API_KEY: Your Ethereum RPC provider API key.INSERT_PRIVATE_KEY: The private key of the Ethereum account holding your WETH, as a0x-prefixed hex string.INSERT_YOUR_POLKADOT_ADDRESS: The Polkadot account address (SS58 format) that will receive the bridged tokens on Polkadot Hub.
Security Warning
Never commit private keys or seed phrases to production code. Use environment variables or secure key management systems.
Approve Tokens for Bridging¶
Before bridging ERC-20 tokens, you must approve the Snowbridge Gateway contract to spend your tokens. The @paraspell/evm-snowbridge package provides helper functions to check your balance and current allowance and to approve spending:
async function approveTokens() {
// Check current WETH balance and Snowbridge Gateway allowance
const { balance, gatewayAllowance } = await getTokenBalance(walletClient, 'WETH');
console.log(`Current WETH balance: ${formatUnits(balance, 18)}`);
if (balance === 0n) {
console.log('No WETH balance. Please wrap some ETH to WETH first.');
console.log(`WETH contract: ${WETH_ADDRESS}`);
process.exit(1);
}
if (gatewayAllowance >= AMOUNT) {
console.log('Gateway allowance already covers the transfer amount.');
return;
}
// Approve the Snowbridge Gateway contract to spend WETH
const approveTxHash = await approveToken(walletClient, AMOUNT, 'WETH');
console.log(`Approval transaction hash: ${approveTxHash}`);
// Wait for confirmation
await publicClient.waitForTransactionReceipt({ hash: approveTxHash });
console.log('Token approval confirmed!');
}
approveTokens();
Run the approval script:
You will see output confirming the token balance and approval similar to the following:
Build and Execute the Bridge Transfer¶
Now build and execute the bridge transfer from Ethereum to Polkadot Hub:
async function bridgeToPolkadot() {
console.log('Building bridge transaction...');
console.log(`Bridging ${formatUnits(AMOUNT, 18)} WETH to Polkadot Hub`);
console.log(`Recipient: ${RECIPIENT_ADDRESS}`);
// Build and execute the bridge transfer
// Note: 'AssetHubPolkadot' is the SDK identifier for Polkadot Hub
const builder = Builder()
.from('Ethereum')
.to('AssetHubPolkadot')
.currency({
symbol: 'WETH',
amount: AMOUNT,
})
.recipient(RECIPIENT_ADDRESS)
.sender(walletClient);
// Resolves once the Ethereum transaction is confirmed
const txHash = await builder.signAndSubmit();
await builder.disconnect();
console.log('Bridge transaction confirmed on Ethereum!');
console.log(`Transaction hash: ${txHash}`);
console.log('Transfer will arrive in approximately 30 minutes.');
}
bridgeToPolkadot();
Comment out the approveTokens() call and run the transfer:
The signAndSubmit() call resolves once the transaction is confirmed on Ethereum and has emitted the bridge message. You will see the Ethereum transaction hash in the terminal output similar to the following:
Monitor the Transfer¶
Bridge transfers from Ethereum to Polkadot take approximately 30 minutes. You can monitor the transfer status in several ways:
- Snowbridge App - Visit app.snowbridge.network to check the transfer history
- Etherscan - Track your Ethereum transaction on etherscan.io
- Polkadot.js Apps - Monitor incoming transfers on Polkadot Hub
You can also check the bridge status programmatically. First, comment out the bridgeToPolkadot() call so the script doesn't send another transfer. Then add the following code to index.ts:
async function checkBridgeStatus() {
// Check the current status of the Snowbridge
const client = createClient(getWsProvider(BRIDGE_HUB_RPC));
const status = await getBridgeStatus(client);
console.log('Bridge Status:', status);
client.destroy();
}
checkBridgeStatus();
Run the script:
The script prints Bridge Status: Normal while the bridge is operating.
Supported Assets and Destinations¶
Snowbridge can bridge any ERC-20 token from Ethereum, but the destination chain must have that asset registered as a foreign asset to receive it.
Verify Foreign Assets
Foreign asset creation on Polkadot Hub is permissionless—anyone can register a foreign asset. Before bridging, verify that the foreign asset registered on Polkadot Hub corresponds to the legitimate token on Ethereum by checking the asset's multilocation and confirming the Ethereum contract address matches the official token contract.
You can query which assets are supported for a specific route using the ParaSpell SDK as follows:
import { getSupportedAssets } from '@paraspell/sdk';
// Get assets supported for Ethereum → Polkadot Hub transfers
const supportedAssets = getSupportedAssets('Ethereum', 'AssetHubPolkadot');
console.log('Supported assets:', supportedAssets.map(a => a.symbol));
Running this script will return a list of supported assets in the terminal similar to the following:
Common supported tokens on Polkadot Hub include:
| Token | Symbol | Description |
|---|---|---|
| Wrapped Ether | WETH | Ethereum's native token wrapped as ERC-20 |
| Wrapped Bitcoin | WBTC | Bitcoin wrapped as an ERC-20 token |
| Shiba Inu | SHIB | Popular ERC-20 meme token |
To transfer to a different destination, change the .to() parameter and verify the asset is supported using the following code:
// Check if WETH is supported on Hydration
const hydrationAssets = getSupportedAssets('Ethereum', 'Hydration');
const wethSupported = hydrationAssets.some(a => a.symbol === 'WETH');
console.log('WETH supported on Hydration:', wethSupported);
if (wethSupported) {
const txHash = await Builder()
.from('Ethereum')
.to('Hydration')
.currency({ symbol: 'WETH', amount: AMOUNT })
.recipient(RECIPIENT_ADDRESS)
.sender(walletClient)
.signAndSubmit();
console.log(`Transaction hash: ${txHash}`);
}
Complete index.ts script
Warning
The complete script calls approveTokens(), bridgeToPolkadot(), and checkBridgeStatus(). Every run of bridgeToPolkadot() sends another WETH transfer, so leave only the call for the step you want to run uncommented.
import { Builder, getBridgeStatus } from '@paraspell/sdk';
import { approveToken, getTokenBalance } from '@paraspell/evm-snowbridge';
import { createClient } from 'polkadot-api';
import { getWsProvider } from 'polkadot-api/ws';
import { createPublicClient, createWalletClient, formatUnits, http, type Hex } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';
// Ethereum mainnet RPC endpoint (use your own API key)
const ETH_RPC = 'https://eth-mainnet.g.alchemy.com/v2/INSERT_API_KEY';
// Polkadot Bridge Hub RPC endpoint, used to check the bridge status
const BRIDGE_HUB_RPC = 'wss://polkadot-bridge-hub-rpc.polkadot.io';
// WETH contract address on Ethereum mainnet
const WETH_ADDRESS = '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2';
// WETH has 18 decimals
const WETH_UNITS = 1_000_000_000_000_000_000n;
// Amount to bridge: 0.001 WETH (raw units as bigint)
const AMOUNT = WETH_UNITS / 1000n;
// Your Polkadot address to receive the bridged tokens (SS58 format)
const RECIPIENT_ADDRESS = 'INSERT_YOUR_POLKADOT_ADDRESS';
// Connect to Ethereum mainnet
// For a browser wallet (MetaMask), use custom(window.ethereum) as the transport
const walletClient = createWalletClient({
account: privateKeyToAccount('INSERT_PRIVATE_KEY' as Hex),
chain: mainnet,
transport: http(ETH_RPC),
});
const publicClient = createPublicClient({ chain: mainnet, transport: http(ETH_RPC) });
async function approveTokens() {
// Check current WETH balance and Snowbridge Gateway allowance
const { balance, gatewayAllowance } = await getTokenBalance(walletClient, 'WETH');
console.log(`Current WETH balance: ${formatUnits(balance, 18)}`);
if (balance === 0n) {
console.log('No WETH balance. Please wrap some ETH to WETH first.');
console.log(`WETH contract: ${WETH_ADDRESS}`);
process.exit(1);
}
if (gatewayAllowance >= AMOUNT) {
console.log('Gateway allowance already covers the transfer amount.');
return;
}
// Approve the Snowbridge Gateway contract to spend WETH
const approveTxHash = await approveToken(walletClient, AMOUNT, 'WETH');
console.log(`Approval transaction hash: ${approveTxHash}`);
// Wait for confirmation
await publicClient.waitForTransactionReceipt({ hash: approveTxHash });
console.log('Token approval confirmed!');
}
approveTokens();
async function bridgeToPolkadot() {
console.log('Building bridge transaction...');
console.log(`Bridging ${formatUnits(AMOUNT, 18)} WETH to Polkadot Hub`);
console.log(`Recipient: ${RECIPIENT_ADDRESS}`);
// Build and execute the bridge transfer
// Note: 'AssetHubPolkadot' is the SDK identifier for Polkadot Hub
const builder = Builder()
.from('Ethereum')
.to('AssetHubPolkadot')
.currency({
symbol: 'WETH',
amount: AMOUNT,
})
.recipient(RECIPIENT_ADDRESS)
.sender(walletClient);
// Resolves once the Ethereum transaction is confirmed
const txHash = await builder.signAndSubmit();
await builder.disconnect();
console.log('Bridge transaction confirmed on Ethereum!');
console.log(`Transaction hash: ${txHash}`);
console.log('Transfer will arrive in approximately 30 minutes.');
}
bridgeToPolkadot();
async function checkBridgeStatus() {
// Check the current status of the Snowbridge
const client = createClient(getWsProvider(BRIDGE_HUB_RPC));
const status = await getBridgeStatus(client);
console.log('Bridge Status:', status);
client.destroy();
}
checkBridgeStatus();
Transfer Assets Out of Polkadot
To transfer assets out of Polkadot, you can use the ParaSpell XCM SDK to build and execute a bridge transfer from Polkadot to Ethereum. Check out the Polkadot to Ethereum section of the ParaSpell XCM SDK documentation.
Where to Go Next¶
- External Documentation - Dive deeper into the ParaSpell XCM SDK and Snowbridge documentation resources.
- Learn about XCM - Understand the underlying protocol by visiting the Get Started with XCM guide
| Created: January 14, 2026