Raw Transaction Construction

The blxr_tx endpoint is expecting raw transaction bytes. Constructing the transaction is typically done using a library like web3 or ethers. The below examples demonstrate constructing a raw transaction and submitting it to blxr_tx .

Examples - Create a Simple Transfer raw transaction and submit it to blxr_tx api

const WebSocket = require('ws')
const EthereumTx = require('ethereumjs-tx').Transaction
// Needed for BSC and Polygon 
// const Common = require('ethereumjs-common').default
const Web3 = require('web3')

const web3 = new Web3('PROVIDER_URL')

const account = 'YOUR_ADDRESS'

const privateKey = Buffer.from(
  'YOUR_PRIVATE_KEY',
  'hex',
)

// const Polygon = Common.forCustomChain(
//     'mainnet',
//     {
//       name: "polygon-mainnet",
//       networkId: 137,
//       chainId: 137,
//     },
//     'petersburg'
//   )

// const BSC = Common.forCustomChain(
//   'mainnet',
//   {
//       name: 'Binance Smart Chain Mainnet',
//       networkId: 56,
//       chainId: 56,
//       url: 'https://bsc-dataseed.binance.org/'
//   },
//   'istanbul',
// )

const main = async () => {
  const tx = new EthereumTx({
      to: 'TO_ADDRESS',
      nonce: nonce,
      // Pass in decimal number for fields below
      gasPrice: web3.utils.toHex(),
      gas: web3.utils.toHex(),
      value: web3.utils.toHex(),
      chainId: 1
      // If using BSC
      // chainId: 56
      // If using Polygon 
      // chainId : 137
    } //, { common: BSC } 
      //, { common: Polygon }
  )
  tx.sign(privateKey)

  const serializedTx = tx.serialize()
  const rawTx = serializedTx.toString('hex')
  
  const ws = new WebSocket(
    "ws://127.0.0.1:28333/ws", 
    {
      headers: { 
        "Authorization" : <YOUR-AUTHORIZATION-HEADER>
      },
      rejectUnauthorized: false,
    }
  );

  function proceed() {
    ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "${rawTx}"}}`)
  }

  function handle(response) {
    console.log(response.toString()) // Or process it generally
  }
  ws.on('open', proceed)
  ws.on('message', handle)
}

# Python 3.7 or higher required due to the use of asyncio.run()
import json, ssl, asyncio, websockets
from web3 import Web3

async def send_tx():
    web3 = Web3(Web3.HTTPProvider())
    private_key = "YOUR_PRIVATE_KEY"
    to_address = "TO_ADDRESS"
    gas = 21000  # Pass in correct gas
    gas_price = web3.toWei('50', 'gwei')  # Pass in correct gas_price
    nonce = web3.eth.getTransactionCount(web3.eth.defaultAccount)
    chain_id = 1  # BSC chainId is 56, Polygon chainId is 137,

    transaction = {
        "to": to_address,
        "value": 0,
        "gas": gas,
        "gasPrice": gas_price,
        "nonce": nonce,
        "chainId": chain_id
    }
    signed_tx = web3.eth.account.sign_transaction(transaction, private_key)
    raw_tx = signed_tx.rawTransaction.hex()

    async with websockets.connect(
        "wss://api.blxrbdn.com/ws",
        extra_headers=[("Authorization", "YOUR_AUTHORIZATION_HEADER")],
        ssl=ssl.SSLContext(cert_reqs=ssl.CERT_NONE)
    ) as ws:
        request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": raw_tx}})
        await ws.send(request)
        response = await ws.recv()
        print(response)

if __name__ == '__main__':
    asyncio.run(send_tx())

package main

import (
	"context"
	"crypto/ecdsa"
	"crypto/tls"
	"encoding/hex"
	"fmt"
	"log"
	"math/big"
	"net/http"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/ethereum/go-ethereum/rlp"
	"github.com/gorilla/websocket"
)

func main() {
	// go-ethereum will know the chain info base on PROVIDER_URL given
	client, err := ethclient.Dial("PROVIDER_URL")
	if err != nil {
		log.Fatal(err)
	}

	privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY")
	if err != nil {
		log.Fatal(err)
	}

	publicKey := privateKey.Public()
	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
	if !ok {
		log.Fatal("error casting public key to ECDSA")
	}

	// go-ethereum gets the public address from the private keys provided
	fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
	if err != nil {
		log.Fatal(err)
	}

	value := big.NewInt()

	toAddress := common.HexToAddress("ADDRESS_TO_SEND_TO")

	chainID, err := client.NetworkID(context.Background())

	if err != nil {
		log.Fatal(err)
	}

	gasFeeCap := big.NewInt()

	gasTipCap := big.NewInt()

	gas := uint64()

	var data []byte

	// To send EIP-1559 Transactions / Type 2 
	tx := types.NewTx(&types.DynamicFeeTx{
		Nonce:     nonce,
		GasFeeCap: gasFeeCap,
		GasTipCap: gasTipCap,
		Gas:       gas,
		To:        &toAddress,
		Value:     value,
		Data:      data})

	signedTx, err := types.SignTx(tx, types.NewLondonSigner(chainID), privateKey)

	/*
		// For Legacy Transactions / Type 0

		gasPrice, err := client.SuggestGasPrice(context.Background())
		if err != nil {
			log.Fatal(err)
		}

		tx := types.NewTx(&types.LegacyTx{
			Nonce:    nonce,
			GasPrice: gasPrice,
			Gas:      gas,
			To:       &toAddress,
			Value:    value,
			Data:     data})

		signedTx, err := types.SignTx(tx, types.NewEIP155Signer(chainID), privateKey)
	*/

	if err != nil {
		log.Fatal(err)
	}

	rawTxBytes, err := signedTx.MarshalBinary()
	rawTxHex := hex.EncodeToString(rawTxBytes)

	if err != nil {
		log.Fatal("Unable to cast to raw txn")
	}

	fmt.Printf("raw bytes: %x", rawTxBytes)

	tlsConfig := &tls.Config{
		InsecureSkipVerify: true,
	}
	dialer := websocket.DefaultDialer
	dialer.TLSClientConfig = tlsConfig
	wsSubscriber, _, err := dialer.Dial("ws://127.0.0.1:28333/ws", http.Header{"Authorization": []string{<YOUR-AUTHORIZATION-HEADER>}})

	if err != nil {
		fmt.Println(err)
		return
	}

	jsonString := fmt.Sprintf(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "%s"}}`, rawTxHex)

	request := jsonString

	err = wsSubscriber.WriteMessage(websocket.TextMessage, []byte(request))
	if err != nil {
		fmt.Println(err)
		return
	}

	for {
		_, nextNotification, err := wsSubscriber.ReadMessage()
		if err != nil {
			fmt.Println(err)
		}
		fmt.Println(string(nextNotification)) // or process it generally
	}

}

Examples - Create a Token Swap raw transaction and submit it to blxr_tx api

const fs = require('fs')
const WebSocket = require('ws')
const EthereumTx = require('ethereumjs-tx').Transaction
const Common = require('ethereumjs-common').default
const Web3 = require('web3')

const web3 = new Web3('PROVIDER_URL')

const account = 'YOUR_ADDRESS'

const privateKey = Buffer.from(
  'PRIVATE_KEY',
  'hex',
)

// Network you would like to connect to, in this case BSC Mainnet
const BSC_FORK = Common.forCustomChain(
  'mainnet',
  {
      name: 'Binance Smart Chain Mainnet',
      networkId: 56,
      chainId: 56,
      url: 'https://bsc-dataseed.binance.org/'
  },
  'istanbul',
)


const main = async () => {
  const bnb = 'WBNB_TOKEN_ADDRESS'
  const token = 'TOKEN_ADDRESS_TO_SWAP_FOR'

  const pair = [bnb, token]

  // Amount of BNB to swap
  const tokenAmountIn = web3.utils.toHex()
  // Desired amount of token returned
  const amountOutMin = web3.utils.toHex()

  const pancakeSwapRouterAddress = 'PANCAKESWAP_ROUTER_ADDRESS'

  // Export Pancakeswap ABI to json file in same directory
  const abi = JSON.parse(fs.readFileSync('pancake-router-abi.json', 'utf-8'));
  const contract = new web3.eth.Contract(abi, pancakeSwapRouterAddress, {from: account})
    
  const data = contract.methods.swapExactETHForTokens(
    amountOutMin,
    pair,
    account,
    Date.now() + 1000 * 60 * 10,
    )

    const tx = new EthereumTx({
        to: pancakeSwapRouterAddress,
        nonce: nonce,
        // Desired gas usage in decimal format
        gasPrice: web3.utils.toHex(),
        gas: web3.utils.toHex(),
        value: tokenAmountIn,
        data: data.encodeABI(),
        chainId: 56
      }, {common: BSC_FORK}
    )

  tx.sign(privateKey)

  const serializedTx = tx.serialize()
  const rawTx = serializedTx.toString('hex')
    
  const ws = new WebSocket(
    "ws://127.0.0.1:28333/ws", 
    {
      headers: { 
        "Authorization" : <YOUR-AUTHORIZATION-HEADER>
      },
      rejectUnauthorized: false,
    }
  );

  function proceed() {
    ws.send(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "${rawTx}", "blockchain_network": "BSC-Mainnet"}}`)
  }

  function handle(response) {
    console.log(response.toString()) // Or process it generally
  }
  ws.on('open', proceed)
  ws.on('message', handle)
}

# Python 3.7 or higher required due to the use of asyncio.run()
import json, time, websocket
from web3 import Web3

web3 = Web3(Web3.HTTPProvider("https://bsc-dataseed.binance.org/"))

private_key = "YOUR_PRIVATE_KEY"
account = "YOUR_ADDRESS"

wbnb_address = "WBNB_TOKEN_ADDRESS"
token_address = "TOKEN_ADDRESS_TO_SWAP_FOR"

pair = [wbnb_address, token_address]

# Amount of BNB to swap
token_amount_in = 1
# Desired amount of token returned
amount_out_min = 2

pancake_swap_router_address = "PANCAKESWAP_ROUTER_ADDRESS"

# Export Pancakeswap ABI to json file in same directory
with open("./pancake-router-abi.json") as f:
    abi = json.load(f)
contract = web3.eth.contract(pancake_swap_router_address, abi=abi)

data = contract.functions.swapExactETHForTokens(
    amount_out_min,
    pair,
    account,
    int(time.time()) + 60 * 10
).buildTransaction({"chainId": 56, "gas": 100, "gasPrice": 35000000000})["data"]

transaction = {
    "to": pancake_swap_router_address,
    "value": token_amount_in,
    "gas": gas, # Pass in correct gas
    "gasPrice": gas_price, # Pass in correct gas_price
    "nonce": nonce, # Pass in correct nonce
    "chainId": 56,
    "data": data
}
signed_tx = web3.eth.account.sign_transaction(transaction, private_key)
raw_tx = signed_tx.rawTransaction.hex()[2:]

headers = {"Authorization": <YOUR-AUTHORIZATION-HEADER>}

try:
    ws = websocket.create_connection(
        'wss://bx-api.blxrbdn.com/ws',
        header=["Authorization:{}".format(headers["Authorization"])],
        subprotocols=['binary']
    )

    request = json.dumps({"id": 1, "method": "blxr_tx", "params": {"transaction": raw_tx}})
    ws.send(request)

    while True:
        response = json.loads(ws.recv())
        print(response)
except Exception as e:
    print(f'Connection failed, Reason: {e}')
finally:
    ws.close()

package main

import (
	"context"
	"crypto/ecdsa"
	"crypto/tls"
	"encoding/hex"

	"fmt"
	"log"
	"math/big"
	"net/http"
	"time"

	store "Pancake" // abi created go script

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/ethclient"
	"github.com/ethereum/go-ethereum/rlp"
	"github.com/gorilla/websocket"
)

func main() {
	client, err := ethclient.Dial("PROVIDER_URL")
	if err != nil {
		log.Fatal(err)
	}

	// BSC network chain id is 56
	chainId := big.NewInt(56)

	if err != nil {
		log.Fatal(err)
	}

	privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY")
	if err != nil {
		log.Fatal(err)
	}

	publicKey := privateKey.Public()
	publicKeyECDSA, ok := publicKey.(*ecdsa.PublicKey)
	if !ok {
		log.Fatal("cannot assert type: publicKey is not of type *ecdsa.PublicKey")
	}

	fromAddress := crypto.PubkeyToAddress(*publicKeyECDSA)
	nonce, err := client.PendingNonceAt(context.Background(), fromAddress)
	if err != nil {
		log.Fatal(err)
	}

	gasPrice, err := client.SuggestGasPrice(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainId)
	if err != nil {
		fmt.Println(err)
	}
	auth.Nonce = big.NewInt(int64(nonce))
	auth.Value = big.NewInt(0)     // in wei
	auth.GasLimit = uint64(0)      // in units
	auth.GasPrice = gasPrice

	address := common.HexToAddress("PANCAKESWAP_ROUTER_ADDRESS")
	instance, err := store.NewStore(address, client)
	if err != nil {
		log.Fatal(err)
	}
	const (
		WETH        = "WBNB_TOKEN_ADDRESS"
		tokenWanted = "TOKEN_ADDRESS_TO_SWAP_FOR"
	)

	tokenWantedAddress := common.HexToAddress(tokenWanted)
	wethTokenAddress := common.HexToAddress(WETH)
	path := []common.Address{wethTokenAddress, tokenWantedAddress}
	// You ethereum address where tokens will be receive 
	myAddress := common.HexToAddress("YOUR_WALLET_ADDRESS")
	// The minimum amount tokens to receive.
	amountOutMin := big.NewInt(0)
	currentTime := big.NewInt(time.Now().UTC().UnixNano()/1e6 + 1000*60*10)

	tx, err := instance.SwapExactETHForTokens(auth, amountOutMin, path, myAddress, currentTime)
	if err != nil {
		log.Fatal(err)
	}

	ts := types.Transactions{tx}
	rawTxBytes, _ := ts[0].MarshalBinary()
	rawTxHex := hex.EncodeToString(rawTxBytes)

	tlsConfig := &tls.Config{
		InsecureSkipVerify: true,
	}
	dialer := websocket.DefaultDialer
	dialer.TLSClientConfig = tlsConfig
	wsSubscriber, _, err := dialer.Dial("ws://127.0.0.1:28333/ws", http.Header{"Authorization": []string{<YOUR-AUTHORIZATION-HEADER>}})

	if err != nil {
		fmt.Println(err)
		return
	}

	jsonString := fmt.Sprintf(`{"jsonrpc": "2.0", "id": 1, "method": "blxr_tx", "params": {"transaction": "%s"}}`, rawTxHex)

	request := jsonString

	err = wsSubscriber.WriteMessage(websocket.TextMessage, []byte(request))
	if err != nil {
		fmt.Println(err)
		return
	}

	for {
		_, nextNotification, err := wsSubscriber.ReadMessage()
		if err != nil {
			fmt.Println(err)
		}
		fmt.Println(string(nextNotification)) // or process it generally
	}
}

PreviousSending Transactions NextSemi-Private Transaction

Last updated 2 months ago