Skip to main content

Cross-Chain Module

The crosschain module enables token transfers across different blockchain networks (Sepolia, Amoy, Neon) using burn-and-mint bridge mechanism.

Import​

const crosschain = await brdzSDK.crosschain;

Methods Overview​

MethodDescriptionAuth RequiredHTTP Endpoint
initiateTransferStart cross-chain transfer✅POST /crosschain/initiate
confirmTransferConfirm burn transaction✅PATCH /crosschain/confirm
mintTokenMint tokens on destination chain✅POST /crosschain/mint
getUSDCBalanceGet USDC balance on specific chain✅GET /crosschain/balance/:chain/:address
testMintMint test USDC (testnet)✅POST /crosschain/test-mint
burnTokenBurn tokens via backend/MetaMask✅POST /crosschain/burn
burnTokenFrontendBurn tokens via private key✅POST /crosschain/burn-frontend
getCTransactionHistoryGet transaction history✅GET /crosschain/history/:user_id
getCTransactionDetailsGet transaction details✅GET /crosschain/details/:log_id

initiateTransfer​

Initiate a cross-chain token transfer between supported networks.

Syntax​

const result = await crosschain.initiateTransfer(data);

Parameters​

interface TransferData {
  user_id: number;
  amount: string;
  from_chain: 'sepolia' | 'amoy' | 'neon';
  to_chain: 'sepolia' | 'amoy' | 'neon';
  token: 'USDC';
  recipient_address: string;
  return_address?: string;
}

Returns​

Promise<{
  success: boolean;
  data: {
    log_id: string;
    nonce: string;
    amount: string;
    from_chain: string;
    to_chain: string;
    token: string;
    recipient_address: string;
    return_address: string;
    status: string;
    created_at: string;
  };
  message: string;
}>

Example​

const transfer = await crosschain.initiateTransfer({
  user_id: 123,
  amount: '100.0',
  from_chain: 'sepolia',
  to_chain: 'amoy',
  token: 'USDC',
  recipient_address: '0x742d35Cc6834C0532925a3b8D93b3C3e1DEF3e4D',
  return_address: '0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359'
});

console.log('Transfer initiated:', transfer.data.log_id);
console.log('Nonce:', transfer.data.nonce);

confirmTransfer​

Confirm the burn transaction after execution.

Syntax​

const result = await crosschain.confirmTransfer(data);

Parameters​

interface ConfirmData {
  log_id: string;
  tx_hash: string;
  status: 'BURNED' | 'FAILED';
}

Returns​

Promise<{
  success: boolean;
  data: {
    log_id: string;
    tx_hash: string;
    status: string;
    updated_at: string;
  };
  message: string;
}>

Example​

const confirm = await crosschain.confirmTransfer({
  log_id: "550e8400-e29b-41d4-a716-446655440000",
  tx_hash: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
  status: "BURNED"
});

console.log('Transfer confirmed:', confirm.data.status);

mintToken​

Mint tokens on the destination chain after successful burn.

Syntax​

const result = await crosschain.mintToken(nonce);

Parameters​

ParameterTypeRequiredDescription
noncestring✅Unique nonce from transfer log

Returns​

Promise<{
  success: boolean;
  tx_hash: string;
  mint_tx_hash: string;
  log_id: string;
  nonce: string;
  status: string;
  data: {
    log_id: string;
    status: string;
    mint_tx_hash: string;
    updated_at: string;
  };
}>

Example​

const mint = await crosschain.mintToken("nonce_1734567890123");

console.log('Mint transaction:', mint.mint_tx_hash);
console.log('Status:', mint.status);

getUSDCBalance​

Get USDC token balance on a specific blockchain.

Syntax​

const result = await crosschain.getUSDCBalance(chain, address);

Parameters​

ParameterTypeRequiredDescription
chainstring✅Chain ID (sepolia, amoy, neon)
addressstring✅Wallet address

Returns​

Promise<{
  chain: string;
  address: string;
  balance: string;
  contract_address: string;
  source: 'frontend' | 'environment';
}>

Example​

const balance = await crosschain.getUSDCBalance('sepolia', '0x742d35Cc6834C0532925a3b8D93b3C3e1DEF3e4D');

console.log('USDC Balance:', balance.balance);
console.log('Contract:', balance.contract_address);
console.log('Chain:', balance.chain);

testMint​

Mint test USDC tokens for development purposes (testnet only).

Syntax​

const result = await crosschain.testMint(data);

Parameters​

interface TestMintData {
  chain: 'sepolia' | 'amoy' | 'neon';
  address: string;
  amount: string;
  mode?: 'manual' | 'metamask';
}

Returns​

Promise<{
  success: boolean;
  tx_hash: string;
  mode: string;
  address: string;
  chain: string;
}>

Example​

const testMint = await crosschain.testMint({
  chain: 'sepolia',
  address: '0x742d35Cc6834C0532925a3b8D93b3C3e1DEF3e4D',
  amount: '100.00',
  mode: 'manual'
});

console.log('Test mint successful:', testMint.tx_hash);

burnToken​

Execute burn transaction via backend hot wallet or confirm MetaMask transaction.

Syntax​

const result = await crosschain.burnToken(data);

Parameters​

interface BurnData {
  log_id: string;
  nonce: string;
  tx_hash?: string; // Required for metamask mode
  mode?: 'backend' | 'metamask';
}

Returns​

Promise<{
  success: boolean;
  data: {
    log_id: string;
    tx_hash: string;
    status: string;
    updated_at: string;
  };
}>

Example​

// Backend burn
const backendBurn = await crosschain.burnToken({
  log_id: "550e8400-e29b-41d4-a716-446655440000",
  nonce: "nonce_1734567890123",
  mode: "backend"
});

// MetaMask burn confirmation
const metamaskBurn = await crosschain.burnToken({
  log_id: "550e8400-e29b-41d4-a716-446655440000",
  nonce: "nonce_1734567890123",
  tx_hash: "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
  mode: "metamask"
});

console.log('Burn successful:', backendBurn.data.tx_hash);

burnTokenFrontend​

Execute burn transaction using frontend wallet private key.

Syntax​

const result = await crosschain.burnTokenFrontend(data);

Parameters​

interface BurnFrontendData {
  log_id: string;
  nonce: string;
  private_key: string;
}

Returns​

Promise<{
  success: boolean;
  tx_hash: string;
  log_id: string;
  nonce: string;
  status: string;
  data: {
    log_id: string;
    tx_hash: string;
    status: string;
    updated_at: string;
  };
}>

Example​

const frontendBurn = await crosschain.burnTokenFrontend({
  log_id: "550e8400-e29b-41d4-a716-446655440000",
  nonce: "nonce_1734567890123",
  private_key: "0x..." // Handle securely!
});

console.log('Frontend burn successful:', frontendBurn.tx_hash);

getCTransactionHistory​

Get user's cross-chain transaction history with pagination and filtering.

Syntax​

const result = await crosschain.getCTransactionHistory(user_id, params);

Parameters​

ParameterTypeRequiredDescription
user_idnumber✅User ID
paramsobject❌Query parameters
params.limitnumber❌Records limit (1-100, default: 50)
params.offsetnumber❌Records offset (default: 0)
params.from_chainstring❌Filter by source chain
params.to_chainstring❌Filter by destination chain
params.statusstring❌Filter by status

Returns​

Promise<{
  success: boolean;
  message: string;
  data: {
    user_id: number;
    transactions: Array<{
      log_id: string;
      nonce: string;
      user_id: number;
      amount: string;
      token: string;
      from_chain: string;
      to_chain: string;
      status: string;
      recipient_address: string;
      burn_tx_hash: string;
      mint_tx_hash: string;
      created_at: string;
      updated_at: string;
    }>;
    pagination: {
      total_count: number;
      limit: number;
      offset: number;
      has_more: boolean;
    };
    filters_applied: {
      from_chain: string | null;
      to_chain: string | null;
      status: string | null;
    };
  };
  timestamp: string;
}>

Example​

const history = await crosschain.getCTransactionHistory(123, {
  limit: 10,
  status: 'MINTED',
  from_chain: 'sepolia'
});

history.data.transactions.forEach(tx => {
  console.log(`${tx.from_chain} → ${tx.to_chain}: ${tx.amount} USDC (${tx.status})`);
});

getCTransactionDetails​

Get detailed information about a specific cross-chain transfer.

Syntax​

const result = await crosschain.getCTransactionDetails(log_id);

Parameters​

ParameterTypeRequiredDescription
log_idstring✅Transfer log ID (UUID)

Returns​

Promise<{
  success: boolean;
  message: string;
  data: {
    transaction: {
      log_id: string;
      nonce: string;
      user_id: number;
      amount: string;
      token: string;
      from_chain: string;
      to_chain: string;
      status: string;
      recipient_address: string;
      return_address: string;
      burn_tx_hash: string;
      mint_tx_hash: string;
      created_at: string;
      updated_at: string;
    };
    requested_by: number;
    access_level: string;
  };
  timestamp: string;
}>

Example​

const details = await crosschain.getCTransactionDetails("550e8400-e29b-41d4-a716-446655440000");

const tx = details.data.transaction;
console.log(`Transfer: ${tx.amount} USDC from ${tx.from_chain} to ${tx.to_chain}`);
console.log(`Status: ${tx.status}`);

Complete Cross-Chain Transfer Example​

class CrossChainManager {
  constructor(sdk) {
    this.sdk = sdk;
    this.crosschain = null;
    this.initCrossChain();
  }

  async initCrossChain() {
    this.crosschain = await this.sdk.crosschain;
  }

  async transferUSDC(fromChain, toChain, amount, recipientAddress, userId) {
    try {
      // Step 1: Initiate transfer
      const initResult = await this.crosschain.initiateTransfer({
        user_id: userId,
        amount: amount,
        from_chain: fromChain,
        to_chain: toChain,
        token: 'USDC',
        recipient_address: recipientAddress,
        return_address: recipientAddress
      });

      console.log('Transfer initiated:', initResult.data.log_id);
      
      // Step 2: Execute burn transaction
      const burnResult = await this.crosschain.burnToken({
        log_id: initResult.data.log_id,
        nonce: initResult.data.nonce,
        mode: 'backend'
      });

      console.log('Burn completed:', burnResult.data.tx_hash);
      
      // Step 3: Mint on destination chain
      const mintResult = await this.crosschain.mintToken(initResult.data.nonce);
      
      console.log('Mint completed:', mintResult.mint_tx_hash);
      
      return {
        success: true,
        log_id: initResult.data.log_id,
        nonce: initResult.data.nonce,
        burn_tx: burnResult.data.tx_hash,
        mint_tx: mintResult.mint_tx_hash,
        status: mintResult.status
      };
    } catch (error) {
      throw new Error(`Cross-chain transfer failed: ${error.message}`);
    }
  }

  async getTransferHistory(userId, filters = {}) {
    try {
      const history = await this.crosschain.getCTransactionHistory(userId, filters);
      return history.data.transactions;
    } catch (error) {
      throw new Error(`Failed to get transfer history: ${error.message}`);
    }
  }

  async checkTransferStatus(logId) {
    try {
      const details = await this.crosschain.getCTransactionDetails(logId);
      return details.data.transaction.status;
    } catch (error) {
      throw new Error(`Failed to check transfer status: ${error.message}`);
    }
  }
}

// Usage example
const manager = new CrossChainManager(brdzSDK);

// Transfer 100 USDC from Sepolia to Amoy
manager.transferUSDC('sepolia', 'amoy', '100.0', '0x...', 123)
  .then(result => {
    console.log('Transfer completed:', result);
  })
  .catch(error => {
    console.error('Transfer failed:', error.message);
  });

Supported Networks​

ChainNetworkNative TokenUSDC Contract
sepoliaSepolia TestnetETH0x9BF350fBaaA8c7200990B051809334c90778f435
amoyPolygon AmoyPOL0xC15239B6B9012F3225f9ebC091C7CE85FF31b983
neonNeon EVMNEON0xB5234C0418402775bCA3f73c4B0B5bDd906FCA11

Transfer Flow States​

StatusDescriptionNext Action
INITIATEDTransfer created, waiting for burnExecute burn transaction
BURNEDTokens burned on source chainCall mint endpoint
MINTEDTokens minted on destination chainTransfer complete
FAILEDTransfer failedContact support

📋 Complete Network Details: For comprehensive network configurations, RPC URLs, and chain specifications, see USDC and Chains Guide.

⚠️ Security Note: When using burnTokenFrontend, handle private keys securely. Never log or expose private keys in production code.