EVM & Smart Contracts

import { createPublicClient, http } from 'viem';
import { liquidEvm } from './chains';

const client = createPublicClient({
  chain: liquidEvm,
  transport: http('https://rpc.liquidity.io'),
});

const gasPrice = await client.getGasPrice();
const feeHistory = await client.getFeeHistory({
  blockCount: 10,
  rewardPercentiles: [25, 50, 75],
});

console.log(`Current gas price: ${gasPrice} wei`);
console.log(`Fee history (last 10 blocks):`, feeHistory);

fee = (amount * 9) / 10000
totalRepayment = amount + fee

import { ethers } from 'ethers';

// Connect to Liquidity Chain
const provider = new ethers.JsonRpcProvider(
  'https://rpc.liquidity.io',
  { name: 'lqdty', chainId: 8675309 }
);

// Read contract state
const flashLoanPool = new ethers.Contract(
  FLASH_LOAN_POOL_ADDRESS,
  [
    'function getAvailableLiquidity(address asset) view returns (uint256)',
    'function calculateFee(uint256 amount) pure returns (uint256)',
    'function getSupportedAssets() view returns (address[])',
  ],
  provider
);

const liquidity = await flashLoanPool.getAvailableLiquidity(USDC_ADDRESS);
const fee = await flashLoanPool.calculateFee(ethers.parseUnits('1000', 6));
const assets = await flashLoanPool.getSupportedAssets();

console.log(`Available USDC liquidity: ${ethers.formatUnits(liquidity, 6)}`);
console.log(`Fee for 1000 USDC loan: ${ethers.formatUnits(fee, 6)} USDC`);
console.log(`Supported assets: ${assets.length}`);

// Execute a flash loan (requires a receiver contract)
const signer = new ethers.Wallet(PRIVATE_KEY, provider);
const poolWithSigner = flashLoanPool.connect(signer);

const tx = await poolWithSigner.flashLoan(
  RECEIVER_CONTRACT_ADDRESS,
  USDC_ADDRESS,
  ethers.parseUnits('1000', 6),
  '0x' // params passed to receiver's executeOperation
);

const receipt = await tx.wait();
console.log(`Flash loan tx: ${receipt.hash}`);

import { createPublicClient, createWalletClient, http, parseAbi } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';

// Define the LQDTY chain
const liquidEvm = {
  id: 96369,
  name: 'LQDTY',
  nativeCurrency: { name: 'LQDTY', symbol: 'LQDTY', decimals: 18 },
  rpcUrls: {
    default: { http: ['https://rpc.liquidity.io'] },
  },
  blockExplorers: {
    default: { name: 'Liquidity Explorer', url: 'https://explorer.liquidity.io' },
  },
} as const;

const publicClient = createPublicClient({
  chain: liquidEvm,
  transport: http(),
});

// Read flash loan pool state
const flashLoanAbi = parseAbi([
  'function getAvailableLiquidity(address asset) view returns (uint256)',
  'function calculateFee(uint256 amount) pure returns (uint256)',
  'function flashLoan(address receiver, address asset, uint256 amount, bytes params) returns (bool)',
  'event FlashLoan(address indexed receiver, address indexed asset, uint256 amount, uint256 fee, bytes32 indexed executionId)',
]);

const liquidity = await publicClient.readContract({
  address: FLASH_LOAN_POOL_ADDRESS,
  abi: flashLoanAbi,
  functionName: 'getAvailableLiquidity',
  args: [USDC_ADDRESS],
});

console.log(`Available liquidity: ${liquidity}`);

// Watch for flash loan events
const unwatch = publicClient.watchContractEvent({
  address: FLASH_LOAN_POOL_ADDRESS,
  abi: flashLoanAbi,
  eventName: 'FlashLoan',
  onLogs: (logs) => {
    for (const log of logs) {
      console.log(`Flash loan: ${log.args.amount} of ${log.args.asset}, fee: ${log.args.fee}`);
    }
  },
});

// Execute a flash loan
const account = privateKeyToAccount(PRIVATE_KEY);

const walletClient = createWalletClient({
  account,
  chain: liquidEvm,
  transport: http(),
});

const hash = await walletClient.writeContract({
  address: FLASH_LOAN_POOL_ADDRESS,
  abi: flashLoanAbi,
  functionName: 'flashLoan',
  args: [RECEIVER_ADDRESS, USDC_ADDRESS, 1000000000n, '0x'],
});

const receipt = await publicClient.waitForTransactionReceipt({ hash });
console.log(`Transaction confirmed in block ${receipt.blockNumber}`);

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://rpc.liquidity.io"))

# Verify connection
assert w3.is_connected()
print(f"Chain ID: {w3.eth.chain_id}")  # 96369
print(f"Latest block: {w3.eth.block_number}")

# Read contract
flash_loan_abi = [
    {
        "inputs": [{"name": "asset", "type": "address"}],
        "name": "getAvailableLiquidity",
        "outputs": [{"name": "", "type": "uint256"}],
        "stateMutability": "view",
        "type": "function",
    },
    {
        "inputs": [{"name": "amount", "type": "uint256"}],
        "name": "calculateFee",
        "outputs": [{"name": "", "type": "uint256"}],
        "stateMutability": "pure",
        "type": "function",
    },
]

pool = w3.eth.contract(address=FLASH_LOAN_POOL_ADDRESS, abi=flash_loan_abi)
liquidity = pool.functions.getAvailableLiquidity(USDC_ADDRESS).call()
fee = pool.functions.calculateFee(1_000_000_000).call()  # 1000 USDC (6 decimals)

print(f"Available USDC: {liquidity / 1e6:.2f}")
print(f"Fee for 1000 USDC: {fee / 1e6:.4f} USDC")

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

import "./interfaces/IFlashLoanReceiver.sol";
import "./interfaces/IERC20.sol";

contract MyArbitrageBot is IFlashLoanReceiver {
    address public immutable flashLoanPool;

    constructor(address _pool) {
        flashLoanPool = _pool;
    }

    function executeOperation(
        address asset,
        uint256 amount,
        uint256 fee,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        require(msg.sender == flashLoanPool, "Only pool");

        // --- Your arbitrage logic here ---
        // Buy low on DEX A, sell high on DEX B, etc.

        // Repay loan + fee
        uint256 amountToRepay = amount + fee;
        IERC20(asset).approve(flashLoanPool, amountToRepay);

        return true;
    }

    // Multi-asset flash loan callback
    function executeOperationMulti(
        address[] calldata assets,
        uint256[] calldata amounts,
        uint256[] calldata fees,
        address initiator,
        bytes calldata params
    ) external override returns (bool) {
        require(msg.sender == flashLoanPool, "Only pool");

        // --- Multi-asset arbitrage logic ---

        // Repay all loans + fees
        for (uint256 i = 0; i < assets.length; i++) {
            IERC20(assets[i]).approve(flashLoanPool, amounts[i] + fees[i]);
        }

        return true;
    }
}

import { LiquidityClient } from '@liquidityio/sdk';

// Mainnet
const client = new LiquidityClient({
    chainId: 8675309,
    rpcUrl: 'https://rpc.liquidity.io',
    signer: wallet,
});

// Testnet
const testnetClient = new LiquidityClient({
    chainId: 8675310,
    rpcUrl: 'https://testnet-rpc.liquidity.io',
    signer: wallet,
});