Swapping Native Tokens - GlueX Documentation

Prerequisites

Before running the script, ensure you have the following installed: Python:

Python 3.10
Web3 (pip install web3)
Requests (pip install requests)

TypeScript:

Node.js 18+
TypeScript (npm install -g typescript)
Web3 (npm install web3)
Axios (npm install axios)

JavaScript:

Node.js 18+
Web3 (npm install web3)
Axios (npm install axios)

Additionally, you need access to an Ethereum-compatible blockchain node, such as an Infura or Tenderly RPC endpoint.

How GlueX Router Works

The GlueX Router simplifies the token swap process by:

Fetching a price quote for swapping native tokens.
Generating the appropriate calldata for the swap.
Executing the transaction on-chain to swap the native token for the desired output token.

Script Overview

1. Setup and Configuration

The following script initializes the necessary configurations:

from web3 import Web3
import requests
import json
import os
import time

# Configuration
API_KEY = "your_api_key"
UNIQUE_PID = "your_unique_pid"
QUOTE_ENDPOINT = "https://router.gluex.xyz/v1/quote"
RPC_URL = "https://mainnet.gateway.co/your_rpc_url"
PRIVATE_KEY = "your_private_key"

# Token Information
NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"  # Represents native ETH
TOKEN_IN = NATIVE_TOKEN_ADDRESS
TOKEN_OUT = "0xTokenOutAddress"  # Replace with the desired output token address
INPUT_AMOUNT = 1000000000000000000  # Example: 1 ETH in Wei

# Initialize Web3
web3 = Web3(Web3.HTTPProvider(RPC_URL))
account = web3.eth.account.from_key(PRIVATE_KEY)
COMPUTATION_UNITS = 1000000
COMPUTATION_COST = web3.eth.gas_price

2. Fetching a Swap Quote

Before executing the swap, obtain a quote from the GlueX Router. This ensures that you get the best rate available:

def fetch_quote(body, headers):
    """Fetch a quote from the GlueX Router."""
    response = requests.post(QUOTE_ENDPOINT, json=body, headers=headers)
    return response.json()

This function sends a request to the GlueX Router to retrieve a quote for swapping native tokens.

3. Executing the Swap Transaction

Once the quote is retrieved, execute the swap transaction by sending the appropriate calldata:

def execute_transaction(calldata, router_address, account, value=0):
    """Execute transaction on the GlueX Router."""
    txn = {
        "from": account.address,
        "to": Web3.to_checksum_address(router_address),
        "data": calldata,
        "gas": COMPUTATION_UNITS,
        "gasPrice": web3.eth.gas_price,
        "nonce": web3.eth.get_transaction_count(account.address),
        "value": value,
        "chainId": 1
    }
    signed_txn = web3.eth.account.sign_transaction(txn, account.key)
    txn_hash = web3.eth.send_raw_transaction(signed_txn.raw_transaction)
    print(f"Transaction Hash: {web3.to_hex(txn_hash)}")
    return txn_hash

This function constructs and signs the transaction, ensuring it is sent to the Ethereum blockchain for processing.

4. End-to-End Swap Execution

The main() function ties everything together by fetching a quote and executing the transaction:

def main():
    headers = {"x-api-key": API_KEY}
    body = {
        "chainID": "ethereum",  # Ethereum Mainnet
        "userAddress": account.address,
        "outputReceiver": account.address,
        "uniquePID": UNIQUE_PID,
        "inputToken": TOKEN_IN,
        "outputToken": TOKEN_OUT,
        "inputAmount": INPUT_AMOUNT,
        "isPermit2": False
    }
    
    print("============================================================================")
    print("Fetching swap quote...")
    print(body)
    quote_data = fetch_quote(body, headers)
    
    if quote_data.get('statusCode') != 200:
        print("Error fetching quote:", quote_data)
        return
    
    print("Quote received successfully:")
    print(quote_data)
    
    router_address = quote_data["result"]["router"]
    calldata = quote_data["result"]["calldata"]
    
    print("Executing transaction...")
    execute_txn = execute_transaction(calldata, router_address, account, value=INPUT_AMOUNT)
    
    receipt = web3.eth.wait_for_transaction_receipt(execute_txn)
    print("Transaction confirmed. Receipt:")
    print(receipt)
    print("")

if __name__ == "__main__":
    main()

5. Complete Code Implementation

Complete Python Implementation

from web3 import Web3
import requests
import json
import os
import time

# Configuration
API_KEY = "your_api_key"
UNIQUE_PID = "your_unique_pid"
QUOTE_ENDPOINT = "https://router.gluex.xyz/v1/quote"
RPC_URL = "https://mainnet.gateway.co/your_rpc_url"
PRIVATE_KEY = "your_private_key"

# Token Information
NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"  # Represents native ETH
TOKEN_IN = NATIVE_TOKEN_ADDRESS
TOKEN_OUT = "0xTokenOutAddress"  # Replace with the desired output token address
INPUT_AMOUNT = 1000000000000000000  # Example: 1 ETH in Wei

# Initialize Web3
web3 = Web3(Web3.HTTPProvider(RPC_URL))
account = web3.eth.account.from_key(PRIVATE_KEY)
COMPUTATION_UNITS = 1000000
COMPUTATION_COST = web3.eth.gas_price

def fetch_quote(body, headers):
    """Fetch a quote from the GlueX Router."""
    response = requests.post(QUOTE_ENDPOINT, json=body, headers=headers)
    return response.json()

def execute_transaction(calldata, router_address, account, value=0):
    """Execute transaction on the GlueX Router."""
    txn = {
        "from": account.address,
        "to": Web3.to_checksum_address(router_address),
        "data": calldata,
        "gas": COMPUTATION_UNITS,
        "gasPrice": web3.eth.gas_price,
        "nonce": web3.eth.get_transaction_count(account.address),
        "value": value,
        "chainId": 1
    }
    signed_txn = web3.eth.account.sign_transaction(txn, account.key)
    txn_hash = web3.eth.send_raw_transaction(signed_txn.raw_transaction)
    print(f"Transaction Hash: {web3.to_hex(txn_hash)}")
    return txn_hash

def main():
    headers = {"x-api-key": API_KEY}
    body = {
        "chainID": "ethereum",  # Ethereum Mainnet
        "userAddress": account.address,
        "outputReceiver": account.address,
        "uniquePID": UNIQUE_PID,
        "inputToken": TOKEN_IN,
        "outputToken": TOKEN_OUT,
        "inputAmount": INPUT_AMOUNT,
        "isPermit2": False
    }
    
    print("============================================================================")
    print("Fetching swap quote...")
    print(body)
    quote_data = fetch_quote(body, headers)
    
    if quote_data.get('statusCode') != 200:
        print("Error fetching quote:", quote_data)
        return
    
    print("Quote received successfully:")
    print(quote_data)
    
    router_address = quote_data["result"]["router"]
    calldata = quote_data["result"]["calldata"]
    
    print("Executing transaction...")
    execute_txn = execute_transaction(calldata, router_address, account, value=INPUT_AMOUNT)
    
    receipt = web3.eth.wait_for_transaction_receipt(execute_txn)
    print("Transaction confirmed. Receipt:")
    print(receipt)
    print("")

if __name__ == "__main__":
    main()

Complete TypeScript Implementation

import { Web3 } from 'web3';
import axios from 'axios';

// Configuration
const API_KEY = "your_api_key";
const UNIQUE_PID = "your_unique_pid";
const QUOTE_ENDPOINT = "https://router.gluex.xyz/v1/quote";
const RPC_URL = "https://mainnet.gateway.co/your_rpc_url";
const PRIVATE_KEY = "your_private_key";

// Token Information
const NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"; // Represents native ETH
const TOKEN_IN = NATIVE_TOKEN_ADDRESS;
const TOKEN_OUT = "0xTokenOutAddress"; // Replace with the desired output token address
const INPUT_AMOUNT = BigInt("1000000000000000000"); // Example: 1 ETH in Wei

// Initialize Web3
const web3 = new Web3(RPC_URL);
const account = web3.eth.accounts.privateKeyToAccount(PRIVATE_KEY);
const COMPUTATION_UNITS = 1000000;

// Types
interface QuoteBody {
    chainID: string;
    userAddress: string;
    outputReceiver: string;
    uniquePID: string;
    inputToken: string;
    outputToken: string;
    inputAmount: bigint;
    isPermit2: boolean;
}

interface QuoteRequestBody {
    chainID: string;
    userAddress: string;
    outputReceiver: string;
    uniquePID: string;
    inputToken: string;
    outputToken: string;
    inputAmount: string;
    isPermit2: boolean;
}

interface QuoteResponse {
    statusCode: number;
    result?: {
        router: string;
        calldata: string;
    };
}

const fetchQuote = async (body: QuoteRequestBody, headers: { [key: string]: string }): Promise<QuoteResponse> => {
    console.log("Fetch a quote from the GlueX Router.");
    const response = await axios.post(QUOTE_ENDPOINT, body, { headers });
    return response.data;
};

const executeTransaction = async (
    calldata: string,
    routerAddress: string,
    account: any,
    value: bigint = BigInt(0)
): Promise<string> => {
    const txn = {
        from: account.address,
        to: web3.utils.toChecksumAddress(routerAddress),
        data: calldata,
        gas: COMPUTATION_UNITS,
        gasPrice: await web3.eth.getGasPrice(),
        nonce: await web3.eth.getTransactionCount(account.address),
        value: value,
        chainId: 1
    };

    const signedTxn = await account.signTransaction(txn);
    const receipt = await web3.eth.sendSignedTransaction(signedTxn.rawTransaction);
    const txHash = web3.utils.toHex(receipt.transactionHash);
    console.log(`Transaction Hash: ${txHash}`);
    return txHash;
};

const main = async (): Promise<void> => {
    const headers = { "x-api-key": API_KEY };
    const body: QuoteBody = {
        chainID: "ethereum", // Ethereum Mainnet
        userAddress: account.address,
        outputReceiver: account.address,
        uniquePID: UNIQUE_PID,
        inputToken: TOKEN_IN,
        outputToken: TOKEN_OUT,
        inputAmount: INPUT_AMOUNT,
        isPermit2: false
    };

    // Convert BigInt to string for axios serialization
    const requestBody = {
        ...body,
        inputAmount: body.inputAmount.toString()
    };

    console.log("============================================================================");
    console.log("Fetching swap quote...");
    console.log(requestBody);
    
    const quoteData = await fetchQuote(requestBody, headers);

    if (quoteData.statusCode !== 200) {
        console.log("Error fetching quote:", quoteData);
        return;
    }

    console.log("Quote received successfully:");
    console.log(quoteData);

    const routerAddress = quoteData.result!.router;
    const calldata = quoteData.result!.calldata;

    console.log("Executing transaction...");
    const executeTxn = await executeTransaction(calldata, routerAddress, account, INPUT_AMOUNT);

    const receipt = await web3.eth.getTransactionReceipt(executeTxn);
    console.log("Transaction confirmed. Receipt:");
    console.log(receipt);
    console.log("");
};

// Run the main function
main().catch(console.error);

Complete JavaScript Implementation

import { Web3 } from 'web3';
import axios from 'axios';

// Configuration
const API_KEY = "your_api_key";
const UNIQUE_PID = "your_unique_pid";
const QUOTE_ENDPOINT = "https://router.gluex.xyz/v1/quote";
const RPC_URL = "https://mainnet.gateway.co/your_rpc_url";
const PRIVATE_KEY = "your_private_key";

// Token Information
const NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"; // Represents native ETH
const TOKEN_IN = NATIVE_TOKEN_ADDRESS;
const TOKEN_OUT = "0xTokenOutAddress"; // Replace with the desired output token address
const INPUT_AMOUNT = BigInt("1000000000000000000"); // Example: 1 ETH in Wei

// Initialize Web3
const web3 = new Web3(RPC_URL);
const account = web3.eth.accounts.privateKeyToAccount(PRIVATE_KEY);
const COMPUTATION_UNITS = 1000000;

const fetchQuote = async (body, headers) => {
    console.log("Fetch a quote from the GlueX Router.");
    const response = await axios.post(QUOTE_ENDPOINT, body, { headers });
    return response.data;
};

const executeTransaction = async (
    calldata,
    routerAddress,
    account,
    value = BigInt(0)
) => {
    const txn = {
        from: account.address,
        to: web3.utils.toChecksumAddress(routerAddress),
        data: calldata,
        gas: COMPUTATION_UNITS,
        gasPrice: await web3.eth.getGasPrice(),
        nonce: await web3.eth.getTransactionCount(account.address),
        value: value,
        chainId: 1
    };

    const signedTxn = await account.signTransaction(txn);
    const receipt = await web3.eth.sendSignedTransaction(signedTxn.rawTransaction);
    const txHash = web3.utils.toHex(receipt.transactionHash);
    console.log(`Transaction Hash: ${txHash}`);
    return txHash;
};

const main = async () => {
    const headers = { "x-api-key": API_KEY };
    const body = {
        chainID: "ethereum", // Ethereum Mainnet
        userAddress: account.address,
        outputReceiver: account.address,
        uniquePID: UNIQUE_PID,
        inputToken: TOKEN_IN,
        outputToken: TOKEN_OUT,
        inputAmount: INPUT_AMOUNT,
        isPermit2: false
    };

    // Convert BigInt to string for axios serialization
    const requestBody = {
        ...body,
        inputAmount: body.inputAmount.toString()
    };

    console.log("============================================================================");
    console.log("Fetching swap quote...");
    console.log(requestBody);
    
    const quoteData = await fetchQuote(requestBody, headers);

    if (quoteData.statusCode !== 200) {
        console.log("Error fetching quote:", quoteData);
        return;
    }

    console.log("Quote received successfully:");
    console.log(quoteData);

    const routerAddress = quoteData.result.router;
    const calldata = quoteData.result.calldata;

    console.log("Executing transaction...");
    const executeTxn = await executeTransaction(calldata, routerAddress, account, INPUT_AMOUNT);

    const receipt = await web3.eth.getTransactionReceipt(executeTxn);
    console.log("Transaction confirmed. Receipt:");
    console.log(receipt);
    console.log("");
};

// Run the main function
main().catch(console.error);

6. Running the Script

To execute the swap, run the script as follows:

python swap_native_tokens.py

6. Understanding the Workflow

User provides their private key and RPC URL.
The script fetches a quote for the native token swap from the GlueX Router.
The appropriate calldata is generated for the transaction.
The transaction is executed on-chain, sending native tokens and receiving the desired token in return.
The transaction hash is displayed, which users can verify on Etherscan or their preferred blockchain explorer.

Conclusion

By following this tutorial, users can seamlessly swap native tokens for any available token on the blockchain using the GlueX Router. The script automates fetching quotes, signing transactions, and executing swaps securely. Users can modify this script to suit their specific needs, such as swapping different tokens, changing input amounts, or integrating it into larger applications. For further enhancements, users can implement error handling, dynamic user input, or even integrate this functionality into a larger trading bot or DeFi application.

​Prerequisites

​How GlueX Router Works

​Script Overview

​1. Setup and Configuration

​2. Fetching a Swap Quote

​3. Executing the Swap Transaction

​4. End-to-End Swap Execution

​5. Complete Code Implementation

​6. Running the Script

​6. Understanding the Workflow

​Conclusion