Trading Guide

import { ethers } from "ethers";
import { SwapRouter, Token, CurrencyAmount, TradeType, Percent } from "@uniswap/sdk-core";
import { Pool, Route, Trade, SwapOptions } from "@uniswap/v3-sdk";

const CHAIN_ID = /* BiniChain chainId */;
const SWAP_ROUTER_ADDRESS = "0x..."; // see /baidex/contracts

const provider = new ethers.JsonRpcProvider("https://rpc.binibit.com");
const signer = new ethers.Wallet(privateKey, provider);

// Token instances
const USBI = new Token(CHAIN_ID, "0x...USBI", 18, "USBI", "Binibit USBI");
const WBINI = new Token(CHAIN_ID, "0x...wBINI", 18, "wBINI", "Wrapped BINI");

// Build pool, route, trade as standard V3 SDK...
// (full pool fetch and trade construction omitted for brevity)

const swapOptions = {
  slippageTolerance: new Percent(50, 10_000), // 0.50%
  deadline: Math.floor(Date.now() / 1000) + 60 * 10,
  recipient: signer.address,
};

const { calldata, value } = SwapRouter.swapCallParameters(trade, swapOptions);

const tx = await signer.sendTransaction({
  data: calldata,
  to: SWAP_ROUTER_ADDRESS,
  value,
  gasLimit: 500_000,
});
await tx.wait();

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

import "@uniswap/v3-periphery/contracts/interfaces/ISwapRouter.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract MyContract {
    ISwapRouter public immutable swapRouter;

    address public constant WBINI = 0x...;
    address public constant USBI  = 0x...;

    constructor(ISwapRouter _swapRouter) {
        swapRouter = _swapRouter;
    }

    function swapWbiniForUsbi(uint256 amountIn, uint256 amountOutMinimum)
        external
        returns (uint256 amountOut)
    {
        IERC20(WBINI).transferFrom(msg.sender, address(this), amountIn);
        IERC20(WBINI).approve(address(swapRouter), amountIn);

        ISwapRouter.ExactInputSingleParams memory params = ISwapRouter.ExactInputSingleParams({
            tokenIn:           WBINI,
            tokenOut:          USBI,
            fee:               10_000,            // 1.00% (BaiDEX single tier)
            recipient:         msg.sender,
            deadline:          block.timestamp + 600,
            amountIn:          amountIn,
            amountOutMinimum:  amountOutMinimum,
            sqrtPriceLimitX96: 0,
        });

        amountOut = swapRouter.exactInputSingle(params);
    }
}

import { ethers } from "ethers";

const QUOTER_ADDRESS = "0x..."; // see /baidex/contracts
const QUOTER_ABI = [
  "function quoteExactInputSingle(address tokenIn, address tokenOut, uint24 fee, uint256 amountIn, uint160 sqrtPriceLimitX96) external returns (uint256 amountOut)",
];

const quoter = new ethers.Contract(QUOTER_ADDRESS, QUOTER_ABI, provider);

const amountOut = await quoter.quoteExactInputSingle.staticCall(
  WBINI_ADDRESS,
  USBI_ADDRESS,
  10_000,           // 1.00% fee tier
  ethers.parseEther("1"),
  0,
);

console.log("Expected output:", ethers.formatEther(amountOut), "USBI");

// Path: WBINI → USBI → AgentToken
bytes memory path = abi.encodePacked(WBINI, uint24(10_000), USBI, uint24(10_000), AGENT_TOKEN);

ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
    path:              path,
    recipient:         msg.sender,
    deadline:          block.timestamp + 600,
    amountIn:          amountIn,
    amountOutMinimum:  amountOutMinimum,
});

amountOut = swapRouter.exactInput(params);