获取callData 数据

注意

发起兑换之前，钱包地址需要确认from币种是否对合约地址进行授权，合约地址在quote接口中已返回

方法一：接口调用获取

POST https://open.crosschainx.io/api/sswap/swap

以下参数带*字段为必填，不带*号为选填

Request Body

Name	Type	Description
fromTokenAddress*	String	出售币种合约地址（可通过获取币种列表中的address字段获得）
amountOutMin*	String	预期得到币种数量(带精度，可通过询价接口里的amountOutMin字段获得)
equipmentNo*	String	设备号设备号（该字段将作为用户的唯一标识，三方可通过自己的方式获得，如fromAddress的前32位字符，或者32位随机数字与字母结合的字符串）
toAddress*	String	接受地址
toTokenChain*	String	获得币种链（可通过获取币种列表中的chain字段获得，详细支持链的情况可查看【基本说明】）
fromTokenAmount*	String	出售币种数量(带精度，可通过询价接口里的fromTokenAmount字段获得)
fromTokenChain*	String	出售币种链（可通过获取币种列表中的chain字段获得，详细支持链的情况可查看【基本说明】）
toTokenAddress*	String	获得币种合约地址（可通过获取币种列表中的address字段获得）
fromAddress*	String	用户地址
sourceFlag*	String	渠道来源（需要双方约定一个名称来代表三方的渠道）
fromCoinCode*	String	出售代币名称（可通过获取币种列表中的symbol字段获得）
toCoinCode*	String	获得代币名称（可通过获取币种列表中的symbol字段获得）
sourceType	String	设备类型（H5/IOS/Android 该字段为选填，如通过直接通过API调用，可为空)
slippage	String	滑点，例如：0.1（代表10%）最低接收数量 = amountOutMin * (1 - slippage)

200: OK EVM链与TRON链返回结果

{
 "resCode":"100",
 "resMsg":"Success",
 "data":{
  "txData":{
   "data":"0x...", //交易calldata
   "to": "0x6b4427caa371627e2a73521a2568fcf1212cd4d9", //合约地址
   "value":"0x2dd47b4d9a4000"
  }
 }
}

200: OK SOLANA链返回结果

调用示例

JavaScript

// swap example
 import { ethers } from 'ethers'
 const provider = new ethers.providers.Web3Provider(window.ethereum, 'any')
 cosnt signer = provider.getSigner()
 const params = {
   fromTokenAddress: '0x55d398326f99059ff775485246999027b3197955',
   toTokenAddress: '0xa71edc38d189767582c38a3145b5873052c3e47a',
   fromAddress: '0x...',  //The wallet address used to send the tokens
   toAddress: '0x...',  //The wallet address used to accept tokens
   fromTokenChain: 'BSC',
   toTokenChain: 'HECO',
   fromTokenAmount: '8000000000000000000',
   amountOutMin:'7884000000000000000',
   fromCoinCode:'USDT(BSC)',
   toCoinCode:'USDT(HECO)',
   equipmentNo:'', // your equipment number
   sourceType:'H5',
   sourceFlag:'widget'
  }
  const res = await axios.post('https://open.crosschainx.io/api/sswap/swap',params)
  console.log(res)
  if(res.resCode === '100'){
    const transactionParameters = {
        to: res.data.txData.to, // Required except during contract publications.
        from: state.wallet.address, // must match user's active address.
        data: res.data.txData.data,
        value: res.data.txData.value,
        //gasPrice: 5000000000, // 6 gwei
        //gas: new BigNumber(1000000), // 1000000
    }
    signer.sendTransaction(transactionParameters)
      .then((data) => {
        console.log(data.hash)
      })   
  }

Postman 示例

方法二：直接调用合约生成

要发送交换消息，请调用合约的 swap() 或 swapEth() 函数。

合约方法swap和swapEth的解释

// @param fromToken - 兑换的原币种合约地址
// @param toToken - 兑换的目标币种（取getToken接口返回的symbol）
// @param destination - 目标币种的接收地址
// @param fromAmount - 原币种数量
// @param minReturnAmount - 预期兑换的目标币数量
function swap(
        address fromToken,
        string memory toToken,
        string memory destination,
        uint256 fromAmount,
        uint256 minReturnAmount
    ) external nonReentrant

// @param toToken - 兑换的目标币种（取getToken接口返回的symbol）
// @param destination - 目标币种的接收地址
// @param minReturnAmount - 预期兑换的目标币数量
function swapEth(
        string memory toToken, 
        string memory destination, 
        uint256 minReturnAmount
    )

主网币兑换调用swapEth方法，代币兑换调用swap方法 EVM合约调用实例

nodejs

exports.swapCallData = async (nodeHost,fromTokenChain,fromTokenAddress,fromTokenAmount,toCoinCode,toAddress,amountOutMin) => {
    const web3 = new Web3(new Web3.providers.HttpProvider(nodeHost));
    const ROUTER_ADDRESS =  ''; //合约地址
    const ROUTE_ABI = require('./abis/CrossChainXAbi.json'); //ABI 在链上合约中
    const routerContract = new web3.eth.Contract(ROUTE_ABI, ROUTER_ADDRESS);
    let data;
    let value;
    if('0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'==fromTokenAddress){
        data = routerContract.methods.swapEth(toCoinCode,toAddress,amountOutMin).encodeABI();
        value = '0x' + new BigNumber(fromTokenAmount).toString(16);
    }else{
        data = routerContract.methods.swap(fromTokenAddress,toCoinCode,toAddress,fromTokenAmount,amountOutMin).encodeABI();
        value = '0x0';
    }

    let res = {
        'data': data,
        'to': ROUTER_ADDRESS,
        'value': value
    };
    return res;
}

JavaScript

TON合约调用实例

nodejs

const TonWeb = require('tonweb');
const { Contract, ContractProvider, Sender, Address, Cell, contractAddress, beginCell, SendMode, toNano } = require("@ton/core");
const { TonClient, JettonMaster, WalletContractV4} = require("@ton/ton");
const { getHttpEndpoint } = require("@orbs-network/ton-access")

exports.swapCallData= async(fromAddress, fromTokenAddress, amount, toAddress, amountOutMin, toCoinCode) => {
    const swap = 1783769518;
    const swapETH = 1023744248;
    const transfer = 260734629;
    const gas = toNano("0.06").toString();
    const forwardAmount = toNano("0.01").toString();
    if (fromTokenAddress.toLowerCase() == '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
        const forwardPayload = beginCell()
            .storeUint(swapETH, 32)
            .storeAddress(Address.parse(fromAddress))
            .storeCoins(forwardAmount)
            .storeRef(beginCell().storeUint(0, 32).storeStringTail(JSON.stringify({"fromToken": fromTokenAddress, "toToken":  toCoinCode, "sender": fromAddress, "destination" : toAddress, "minReturnAmount": amountOutMin})).endCell())
            .endCell();
        const body = beginCell()
            .storeUint(0x7362d09c, 32)
            .storeRef(forwardPayload)
            .endCell();
        return {address: sdkInfo.sswapContract.TON, amount: amount, payload: body.toBoc().toString("base64")};
    }
    const swap_forwardPayload = beginCell()
        .storeUint(swap, 32)
        .storeAddress(Address.parse(fromAddress))
        .storeCoins(forwardAmount)
        .storeRef(beginCell().storeUint(0, 32).storeStringTail(JSON.stringify({"fromToken": fromTokenAddress, "toToken":  toCoinCode, "sender": fromAddress, "destination" : toAddress, "minReturnAmount": amountOutMin})).endCell())
        .endCell();

    const swap_body = beginCell()
        .storeUint(transfer, 32)
        .storeUint(0, 64)
        .storeCoins(amount)
        .storeAddress(Address.parse(tonContractAddress))
        .storeAddress(Address.parse(fromAddress))
        .storeBit(0)
        .storeCoins(forwardAmount)
        .storeBit(1)
        .storeRef(swap_forwardPayload)
        .endCell();
    const client = new TonClient({
        endpoint: await getHttpEndpoint({ network: 'mainnet' }),
    })
    const jettonMasterAddress = Address.parse(fromTokenAddress);
    const userAddress = Address.parse(fromAddress);
    const jettonMaster = client.open(JettonMaster.create(jettonMasterAddress));
    const jettonWalletAddress = await jettonMaster.getWalletAddress(userAddress);
    return {address: jettonWalletAddress.toString(), amount: gas, payload: swap_body.toBoc().toString("base64")};
}

XRP合约调用实例

nodejs

const  {Xumm} = require("xumm");

exports.swap = async (fromAddress, fromTokenAddress, fromTokenDecimals, amount, toAddress, amountOutMin, toCoinCode, xrpTokenCode = '') => {
    let result = '';
    const memoData = {
        "fromToken": fromTokenAddress,
        "toToken": toCoinCode,
        "sender": fromAddress,
        "destination": toAddress,
        "minReturnAmount": amountOutMin,
        "fromAmount": amount
    };
    const buffer = Buffer.from(JSON.stringify(memoData), 'utf-8');
    const hexStr = buffer.toString('hex');
    if (fromTokenAddress == '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
        result = {
            TransactionType: "Payment",
            Destination: CrossChainXXRPContract,
            Amount: amount,
            Memos: [{Memo: {MemoData: hexStr}}],
        }
    } else {
        let amount1 = new BigNumber(amount).shiftedBy(parseInt(-fromTokenDecimals)).dp(10).toFixed();
        result = {
            TransactionType: "Payment",
            Destination: CrossChainXXRPContract,
            Amount: {
                currency: xrpTokenCode,
                value: amount1,
                issuer: fromTokenAddress
            },
            Memos: [{Memo: {MemoData: hexStr}}],
        }
    }
    const xumm = new Xumm(API-KEY, API-SECRET);
    let payload = await xumm.payload?.create({
        txjson: result,
        options: {
            force_network: "MAINNET"
        }
    });
    return payload;
}