Rubic Documents
  • RUBIC
    • Overview
    • Rubic's Ecosystem
    • Security
    • Tokenomics
    • Roadmap
    • Rubic Discord Roles
    • “Swap to Earn” Program on Rubic
    • MEV-bot Protection
    • B2B Cross-Chain Toolkit
      • Use Cases
      • Why Rubic?
    • Refund Guidelines for Stuck Transactions
  • ⚒️Integrate SDK
    • SDK Overview
    • SDK Architecture
    • SDK Advantages
    • SDK Integration
    • 1️⃣Install SDK
    • 2️⃣Set up SDK
    • 3️⃣Trade calculation
    • 4️⃣Swap Execution
    • 📜Advanced documentation
    • Migration from V2 to V3
    • Contact Us
  • Integrate Widget
    • Widget Overview
    • Instruction
    • White Label Widget Integration Instruction
    • Partners
    • Listing of tokens
  • Rubic API
    • 🔐Tokens API
    • Referrer And Rate Limits
    • Rubic API
      • Supported chains
      • Supported providers
      • Request Quote
      • Request Data
      • Get Cross-Chain Status
      • Integration example
        • Swaps from EVM
        • Swaps from Solana
        • Swaps from TON
        • Swaps from Tron
        • Swaps from Bitcoin
        • Swaps VIA deposit
      • Swagger
      • Models
        • OnChainTradeType
        • CrossChainTradeType
        • FeesDto
        • RoutingDto
        • TransactionDto
        • ErrorDto
      • Errors
    • Monetization And Fees
  • FAQ
    • What is Rubic?
    • How to start using Rubic?
    • Who can use our service?
    • Is KYC required?
    • What are the minimum and maximum trade sizes?
    • Should I list my token before using your service?
    • How to create a Swap?
    • How long does it take to complete a transaction?
    • How is the privacy and security of the transaction ensured?
    • How does Rubic unite different DEX platforms?
    • Why does Rubic offer a choice between different providers?
    • How do I add the BNB Smart Chain and Polygon networks to MetaMask?
    • What should I do when I see the message: “Trading on Uniswap is not available?”
    • What should I do if Uniswap doesn’t display any rates?
    • How can we integrate the Rubic Relay widget?
    • How do we get listed on Rubic?
    • How to Complete swaps to/from TON network using Rubic
  • Contacts
    • Community
    • PR Marketing
    • Business Development
    • Support
    • Influencers Collaboration Requests
  • Legal Documentation
    • Privacy Policy
    • Terms of Use
    • Third-Party Software
  • Audits
    • MixBytes Audit
  • Pitch Deck
Powered by GitBook
On this page
  • Connecting a Web3 Wallet
  • Retrieving Token Quotes
  • Approving Tokens for Transaction
  • Retrieving Data to Execute a Transaction
  • Executing a Transaction with the API Response Data
  • Track your transaction

Was this helpful?

  1. Rubic API
  2. Rubic API
  3. Integration example

Swaps from Tron

Connecting a Web3 Wallet and Executing a Transaction through Rubic API

This page explains how to connect a Web3 wallet, retrieve token quotes, approve tokens, and execute a transaction using Rubic API, with examples using ethers.js, web3.js, and viem

Connecting a Web3 Wallet

To interact with the blockchain, we first need to connect a wallet. Here are examples using tronWeb.

const TronWeb = require('tronweb');

async function connectWallet() {
    if (window.tronLink) {
        const response = await window.tronLink.request({ method: 'tron_requestAccounts' });
       return window.tronLink.tronWeb.defaultAddress.base58;
    } else {
        console.error("Tron provider not found. Please install TronLink.");
    }
}

Retrieving Token Quotes

Now that the wallet is connected, we can request token quotes from Rubic API.

Endpoint: POST https://api-v2.rubic.exchange/api/routes/quoteBest

async function quoteBest() {
    const response = await fetch("https://api-v2.rubic.exchange/api/routes/quoteBest", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
        },
        body: {
            "srcTokenAddress": "0x0000000000000000000000000000000000000000",
            "srcTokenAmount": "1000.05",
            "srcTokenBlockchain": "TRON",
            "dstTokenAddress": "0x0000000000000000000000000000000000000000",
            "dstTokenBlockchain": "ETH",
            "referrer": "rubic.exchange"
          }
    });
    const data = await response.json();
    const { estimate, transaction, id } = data;
    console.log(estimate);
    // {
    //     This is an estimated amount you will get after the swap.
    //     "destinationTokenAmount": "8248.453781656313882666",
    //     "destinationTokenMinAmount": "8001.000168206624466186",
    //
    //     "destinationUsdAmount": 2637.13,
    //     "destinationUsdMinAmount": 2558.02,
    //
    //     "destinationWeiAmount": "8248453781656313882666",
    //     "destinationWeiMinAmount": "8001000168206624466186",
    //
    //     "durationInMinutes": 5,
    //     "priceImpact": 0.14,
    //     "slippage": 0.03
    // }
    console.log(transaction.approvalAddress);
    // This is the address you need to give approve to spend tokens.
    // See next section for details.
    // 0x3335733c454805df6a77f825f266e136FB4a3333
    console.log(id);
    // This is the swap ID. It will be needed later for swap request.
    return data;
}

You get more information about quote endpoint here:

Approving Tokens for Transaction

Before sending a transaction, you need to approve the token. Approve allows a user to authorize a contract or application to manage a specified amount of their tokens, which is necessary for secure interaction with decentralized applications such as exchanges or DeFi protocols. This gives users control over how many tokens can be used, providing an additional layer of security.

Below are examples for different libraries.

const tronWeb = require('tronweb');
import { TRC20_CONTRACT_ABI } from "./TokenABI"; // replace with the correct ABI

async function approveToken(
    // Token address
    tokenAddress,
    // Contract to give approve to.
    // Put here transaction.approvalAddress obtained on previous step
    spenderAddress,
    // Amount of tokens to approve.
    // For security reasons it's better to set approve
    // amount equal to from amount
    amount
) {
    const contract = await tronWeb.contract(TRC20_CONTRACT_ABI, tokenAddress);
    const tx = await tokenContract.approve(spenderAddress, amount);
    console.log("Approval successful:", tx.hash);
}

Retrieving Data to Execute a Transaction

To perform a token swap through Rubic API, we need to get the necessary data for the transaction.

Endpoint: POST https://api-v2.rubic.exchange/api/routes/swap

async function getSwapData() {
    const response = await fetch("https://api-v2.rubic.exchange/api/routes/swap", {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
        },
        body: {
            "srcTokenAddress": "0x0000000000000000000000000000000000000000",
            "srcTokenAmount": "1000.05",
            "srcTokenBlockchain": "TRON",
            "dstTokenAddress": "0x0000000000000000000000000000000000000000",
            "dstTokenBlockchain": "ETH",
            "referrer": "rubic.exchange"
            "fromAddress": "USER WALLET ADDRESS",
            "id": "ID FROM QUOTE STEP",
            "receiver": "RECEIVER ADDRESS"
          }
    });
    const result = await response.json();
    const { transaction } = result;
    console.log(transaction);
    // {
    //     "approvalAddress": "0x3335733c454805df6a77f825f266e136FB4a3333",
    //     "data": "0xe1fcde8e0000000...00000000000000000000000000000000000000000000000",
    //     "to": "0x3335733c454805df6a77f825f266e136FB4a3333",
    //     "value": "1050785817564594203",
    //     "feeLimit": "..."
    // },
    return result;
}

You get more information about swap endpoint here:

Executing a Transaction with the API Response Data

Using the data obtained from the Rubic API, you can now execute the transaction.

async function executeSwap(
    // Transaction object, obtained on previous step from Rubic API
    transaction,
    // Signer object, obtained while ethers.js initializing
    tronWeb,
    // From wallet address
    fromAddress
) {
    const tronTx = await tronWeb.transactionBuilder.triggerSmartContract(
        transaction.to,
        transaction.functionName,
        transaction.parameters,
        fromAddress
    );
    const signedTransaction = await tronWeb.trx.sign(tronTx.transaction);

    const receipt: TronTransactionReceipt = await this.tronWeb.trx.sendRawTransaction(
        signedTransaction
    return receipt.txid;
}

Track your transaction

Now you can track your transaction status

Endpoint: GET https://api-v2.rubic.exchange/api/routes/status

async function getStatus(
    // Your transaction hash, otained while executing transaction
    hash
) {
    const response = await fetch(`https://api-v2.rubic.exchange/api/info/status?srcTxHash=${hash}`);
    const data = await response.json();
    const { status, destinationTxHash } = data;
    console.log(status);
    // Current TX status can be one of
    // 'PENDING' | 'LONG_PENDING' | 'REVERT' |
    // 'REVERTED' | 'FAIL' | 'READY_TO_CLAIM' |
    // 'SUCCESS' | 'NOT_FOUND';
    console.log(status);
    // shows the hash on the target network if the transaction
    // is successfully completed
    return status;
}

You get more information about status endpoint here:

PreviousSwaps from TONNextSwaps from Bitcoin

Last updated 2 months ago

Was this helpful?

Request Quote
Request Data
Get Cross-Chain Status