Skip to main content
This is an advanced topic for relayer operators and liquidity providers. Regular users benefit automatically when relayers offer fast finalization.
Fast transfers let liquidity providers front tokens on the destination chain before the original transfer fully finalizes. Users receive tokens in seconds instead of minutes.

​
How It Works

  1. User initiates transfer with fees
  2. Relayer sees the pending transfer
  3. Relayer sends their own tokens to the recipient immediately
  4. User gets tokens in seconds
  5. Original transfer finalizes normally
  6. Relayer claims the original tokens plus fee as profit

​
Building Fast Finalization Transactions

import { createNearBuilder } from "@omni-bridge/near"
import type { FastFinTransferParams } from "@omni-bridge/near"

const nearBuilder = createNearBuilder({ network: "mainnet" })

const params: FastFinTransferParams = {
  tokenId: "wrap.near",
  amount: "1000000000000000000000000",      // Original amount
  amountToSend: "990000000000000000000000", // Amount minus fee
  transferId: {
    origin_chain: "Eth",
    origin_nonce: 12345n,
  },
  recipient: "near:recipient.near",
  fee: {
    fee: "10000000000000000000000",  // Token fee
    native_fee: "0",
  },
  msg: "",
  storageDepositAmount: "1250000000000000000000",
  relayer: "relayer.near",
}

const tx = nearBuilder.buildFastFinTransfer(params, "relayer.near")

​
Economics

PartyWhat happens
UserReceives amount - fee immediately
RelayerFronts amount - fee, claims amount later
Profitfee (after original finalizes)
const originalAmount = 1000n * 10n**24n  // 1000 tokens
const fee = 10n * 10n**24n               // 10 tokens (1%)
const amountToSend = originalAmount - fee // 990 tokens

// Relayer fronts 990 tokens
// Relayer claims 1000 tokens after finalization
// Profit: 10 tokens

​
Risks

Relayers lock capital until the original transfer finalizes. This introduces financial and operational risks.
RiskDescriptionMitigation
Capital lockTokens locked for 15-30 minMaintain sufficient liquidity
Reorg riskSource chain reorg invalidates transferWait for confirmations
Invalid transferOriginal transfer fails validationVerify on-chain data
Claim failureNetwork issues during claimImplement retry logic

​
Validation Checklist

Before executing a fast transfer: 
function shouldExecuteFastTransfer(transfer: PendingTransfer): boolean {
  // 1. Verify transfer exists on source chain
  if (!await verifyTransferOnSource(transfer)) return false
  
  // 2. Check not already finalized
  if (await isAlreadyFinalized(transfer.transferId)) return false
  
  // 3. Verify fee covers gas + profit margin
  const gasCost = await estimateGasCost()
  if (transfer.fee <= gasCost) return false
  
  // 4. Check liquidity
  if (!hasLiquidity(transfer.tokenId, transfer.amountToSend)) return false
  
  // 5. Validate recipient
  if (!isValidAddress(transfer.recipient)) return false
  
  return true
}

​
Transfer States

StatusMeaning
PendingFast transfer executed, waiting for original
FinalizedOriginal transfer finalized, fee claimable
ClaimedRelayer claimed original tokens + fee

​
Capital Requirements

Relayers need liquidity across multiple tokens: 
const requiredLiquidity = {
  "wrap.near": 100_000n * 10n**24n,  // 100k wNEAR
  "usdc.near": 500_000n * 10n**6n,   // 500k USDC
  "usdt.near": 500_000n * 10n**6n,   // 500k USDT
}

​
See Also