获取callData 数据
调用接口发起兑换
注意
发起兑换之前,钱包地址需要确认from币种是否对合约地址进行授权,合约地址在quote接口中已返回
方法一:接口调用获取
POST
https://api.bridgers.xyz/api/sswap/swap
以下参数带*字段为必填,不带*号为选填
Request Body
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)
{
"resCode":"100",
"resMsg":"Success",
"data":{
"txData":{
"data":"0x...", //交易calldata
"to": "0x6b4427caa371627e2a73521a2568fcf1212cd4d9", //合约地址
"value":"0x2dd47b4d9a4000"
}
}
}
调用示例
// 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://api.bridgers.xyz/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合约调用实例
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/BridgersAbi.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;
}
TON合约调用实例
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合约调用实例
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: bridgersXRPContract,
Amount: amount,
Memos: [{Memo: {MemoData: hexStr}}],
}
} else {
let amount1 = new BigNumber(amount).shiftedBy(parseInt(-fromTokenDecimals)).dp(10).toFixed();
result = {
TransactionType: "Payment",
Destination: bridgersXRPContract,
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;
}
Last updated