HASHI Bridge (Ethereum)

HASHI Bridge

HASHI is SORA’s decentralized and trustless cross-chain bridge that enables secure asset transfers between Ethereum and the SORA network. Unlike centralized bridges, HASHI uses cryptographic proofs to validate transactions across chains without relying on trusted intermediaries.

Key Features

Trustless

No centralized custodians or multisigs holding your assets.

Decentralized

Secured by SORA validators, not a single party.

ERC-20 Support

Bridge any ERC-20 token between networks.

Polkaswap Integrated

Trade bridged assets directly on Polkaswap.

How HASHI Works

Architecture Overview

┌─────────────────┐                    ┌─────────────────┐
│    Ethereum     │                    │      SORA       │
│    Network      │                    │     Network     │
│                 │                    │                 │
│  ┌───────────┐  │    Validators     │  ┌───────────┐  │
│  │  Bridge   │◄─┼─── Sign & Relay ──┼─►│  Bridge   │  │
│  │ Contract  │  │    Proofs         │  │  Pallet   │  │
│  └───────────┘  │                    │  └───────────┘  │
│        │        │                    │        │        │
│  ┌─────▼─────┐  │                    │  ┌─────▼─────┐  │
│  │   ERC-20  │  │                    │  │   Asset   │  │
│  │   Tokens  │  │                    │  │  (Wrapped)│  │
│  └───────────┘  │                    │  └───────────┘  │
└─────────────────┘                    └─────────────────┘

Bridge Flow: Ethereum → SORA

User deposits tokens into the Ethereum bridge contract:

// Approve tokens
token.approve(bridgeAddress, amount);

// Deposit to bridge
bridge.deposit(tokenAddress, amount, soraRecipient);

SORA network mints wrapped tokens:

// On SORA
Mint wrapped_DAI to user_account
Amount: deposited_amount - bridge_fee

Bridge Flow: SORA → Ethereum

User burns wrapped tokens on SORA:

// Submit withdrawal request
bridge.withdraw(
    asset_id: "DAI",
    amount: 1000,
    eth_recipient: "0x..."
)

Tokens released on Ethereum:

// User or relayer submits proof
bridge.withdraw(
    tokenAddress,
    amount,
    recipient,
    validatorSignatures
);

Supported Assets

Native Support

Token	Contract	Status
ETH	Native	✅ Supported
DAI	0x6B17…	✅ Supported
USDC	0xA0b8…	✅ Supported
USDT	0xdAC1…	✅ Supported
WBTC	0x2260…	✅ Supported

Adding New Tokens

Any ERC-20 can be added through governance:

Proposal — Submit governance request
Review — Technical committee evaluates
Vote — Parliament approves
Deploy — Bridge configuration updated

Security Model

Validator Security

HASHI relies on SORA’s validator set:

Layer	Mechanism
Economic	Validators stake VAL as collateral
Consensus	BFT requires 2/3+ honest validators
Slashing	Malicious behavior penalized
Rotation	Validator set changes over time

Cryptographic Proofs

Bridge transfers are secured by:

Merkle proofs — Verify transaction inclusion
Threshold signatures — Multiple validators must sign
Finality guarantees — Wait for sufficient confirmations

No Single Point of Failure

Traditional Bridge:          HASHI:

    ┌─────────┐             ┌───┐ ┌───┐ ┌───┐
    │Multisig │             │ V │ │ V │ │ V │
    │  3/5    │             └─┬─┘ └─┬─┘ └─┬─┘
    └────┬────┘               │     │     │
         │                  ┌─▼─────▼─────▼─┐
    Single Point            │   Consensus   │
    of Failure              │   Required    │
                            └───────────────┘

Fees

Fee Structure

Component	Fee	Recipient
Bridge Fee	~0.1%	SORA Treasury
Ethereum Gas	Variable	Ethereum Miners
SORA Fee	Minimal	Validators

Gas Optimization

HASHI batches operations to reduce costs:

Multiple withdrawals aggregated
Signature aggregation reduces calldata
Off-peak submission for lower gas

Using HASHI

Via Polkaswap UI

The easiest way to use HASHI:

Go to polkaswap.io
Select “Bridge” tab
Connect Ethereum wallet (MetaMask)
Connect SORA wallet (Fearless/Polkadot.js)
Select token and amount
Confirm transactions

Via Code

For programmatic access:

import { ethers } from 'ethers';

// Connect to Ethereum
const provider = new ethers.providers.Web3Provider(window.ethereum);
const signer = provider.getSigner();

// Bridge contract
const bridge = new ethers.Contract(BRIDGE_ADDRESS, BRIDGE_ABI, signer);

// Approve tokens
const token = new ethers.Contract(TOKEN_ADDRESS, ERC20_ABI, signer);
await token.approve(BRIDGE_ADDRESS, amount);

// Deposit to bridge
const tx = await bridge.deposit(
    TOKEN_ADDRESS,
    amount,
    soraAccountBytes32  // SORA recipient
);

await tx.wait();

Monitoring

Transaction Status

Track bridge transfers:

// Check if transfer is complete on SORA
const events = await api.query.ethereumBridge.requests(requestId);
console.log('Status:', events.status);

Bridge Health

Monitor bridge status:

Metric	Healthy Value
Pending transfers	< 100
Average delay	< 15 min
Validator participation	> 66%

Troubleshooting

Common Issues

Causes:

Ethereum congestion
Insufficient confirmations
Validator sync issues

Solution:

Wait for more confirmations
Check bridge status page
Contact support if > 1 hour

Learn More

Polkadot Bridge

XCM and parachain connectivity

TON Bridge

TONSWAP integration

Polkaswap

Trade bridged assets

Security

Bridge security model