Revolutionize Cross-Chain Transactions with deBridge Finance

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@debridge-finance/contracts/interfaces/IDeBridgeGate.sol";

contract CrossChainDApp {
    // deBridge Gate contract
    IDeBridgeGate public deBridgeGate;
    
    // Constructor sets the deBridge Gate address
    constructor(address _deBridgeGate) {
        deBridgeGate = IDeBridgeGate(_deBridgeGate);
    }
    
    // Function to send a cross-chain message
    function sendCrossChainMessage(
        uint256 targetChainId,
        address targetContract,
        bytes calldata message
    ) external payable {
        // Prepare submission parameters
        bytes memory executionParams = abi.encode(
            targetContract,
            message
        );
        
        // Send cross-chain submission
        deBridgeGate.send{value: msg.value}(
            address(0), // Use native token for fees
            0, // No tokens being transferred
            targetChainId,
            abi.encodePacked(address(this)),
            executionParams,
            0, // No flags
            0, // No fallback address
            bytes("") // No additional data
        );
    }
    
    // Function to receive cross-chain messages
    function executeCrossChainMessage(
        bytes calldata message
    ) external {
        // Verify sender is deBridge Gate
        require(msg.sender == address(deBridgeGate), "Unauthorized");
        
        // Process the received message
        // Implementation depends on your application
    }
}

# Import required libraries
from web3 import Web3
from debridge_sdk import DeBridgeClient

# Initialize Web3 connection
w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_INFURA_KEY'))

# Initialize deBridge client
debridge = DeBridgeClient(
    api_key='YOUR_API_KEY',
    environment='mainnet'
)

# Function to query cross-chain data
def query_cross_chain_data(source_chain_id, target_chain_id, address):
    # Get account balances across chains
    balances = debridge.get_account_balances(
        address=address,
        chains=[source_chain_id, target_chain_id]
    )
    
    # Get historical transactions
    transactions = debridge.get_transactions(
        address=address,
        limit=10
    )
    
    # Get liquidity information
    liquidity = debridge.get_liquidity_info(
        source_chain_id=source_chain_id,
        target_chain_id=target_chain_id
    )
    
    return {
        'balances': balances,
        'transactions': transactions,
        'liquidity': liquidity
    }

# Example usage
result = query_cross_chain_data(
    source_chain_id=1,  # Ethereum
    target_chain_id=56, # BSC
    address='0xYourAddress'
)

print(f"Balances: {result['balances']}")
print(f"Recent transactions: {result['transactions']}")
print(f"Liquidity info: {result['liquidity']}")

use debridge_sdk::{DeBridge, ChainId, TransferParams};
use ethers::{
    prelude::*,
    types::{Address, U256},
};
use std::str::FromStr;

#[tokio::main]
async fn main() -> Result<(), Box> {
    // Connect to Ethereum node
    let provider = Provider::::try_from("https://mainnet.infura.io/v3/YOUR_INFURA_KEY")?;
    
    // Load wallet from private key
    let wallet = "YOUR_PRIVATE_KEY"
        .parse::()?
        .with_chain_id(ChainId::Mainnet as u64);
    
    // Create client with wallet
    let client = SignerMiddleware::new(provider, wallet);
    
    // Initialize deBridge SDK
    let debridge = DeBridge::new(client);
    
    // NFT contract and token ID to transfer
    let nft_contract = Address::from_str("0xNFTContractAddress")?;
    let token_id = U256::from(1234);
    
    // Target chain and recipient
    let target_chain = ChainId::BinanceSmartChain;
    let recipient = Address::from_str("0xRecipientAddressOnBSC")?;
    
    // Prepare transfer parameters
    let params = TransferParams {
        token: nft_contract,
        token_id: Some(token_id),
        amount: None, // Not needed for NFT
        target_chain,
        recipient,
        fee: U256::from(1_000_000_000_000_000u64), // 0.001 ETH fee
    };
    
    // Execute cross-chain NFT transfer
    let tx = debridge.transfer_nft(params).await?;
    println!("Transfer initiated: {:?}", tx.tx_hash());
    
    // Wait for confirmation
    let receipt = tx.await?;
    println!("Transfer confirmed in block: {}", receipt.block_number.unwrap());
    
    // Get transfer status
    let status = debridge.get_transfer_status(tx.tx_hash()).await?;
    println!("Transfer status: {:?}", status);
    
    Ok(())
}