Skip to main content
Monitor your DA Builder account to track GasTank balance, outstanding charges, and transaction status. Use the dab_accountInfo RPC method to check account details and eth_getTransactionReceipt to track transaction status.

​
Account Information

The dab_accountInfo method returns your current GasTank balance and any outstanding charges that haven’t been settled yet. This method requires authentication using a Flashbots-style header. The X-Flashbots-Signature header should contain your address and an EIP-191 signature of the JSON-RPC request body.

​
Example Request

curl -X POST https://da-builder.mainnet.spire.dev/ \
  -H "Content-Type: application/json" \
  -H "X-Flashbots-Signature: 0xYourAddress:0xSignature" \
  --data '{
    "jsonrpc": "2.0",
    "method": "dab_accountInfo",
    "params": ["0xYourAccountAddress"],
    "id": 1
  }'

​
Example Response

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "balance": "1000000000000000000",
    "outstanding_charge": "50000000000000000",
    "whitelisted": true
  }
}
Response Fields:
  • balance: Current balance in the GasTank (in wei)
  • outstanding_charge: Charges pending settlement (in wei)
  • whitelisted: Whether the account is whitelisted to submit transactions

​
Authentication Header Implementation

The X-Flashbots-Signature header requires an EIP-191 signature of the JSON-RPC request body. The format is X-Flashbots-Signature: <address>:<signature>. Implementation steps:
  1. Create the JSON-RPC request body as a string
  2. Compute the keccak256 hash of the body
  3. Sign the hash using EIP-191 (Ethereum signed message format)
  4. Format as address:signature in the header
The code examples below show the authentication flow. For complete, tested implementations that match the sample integration repository, see the links above. 
use alloy::primitives::{keccak256, utils::eip191_hash_message, Address};
use alloy::signers::{local::PrivateKeySigner, Signer};
use reqwest::Client;
use serde_json::json;
use std::str::FromStr;

#[tokio::main]
async fn main() -> eyre::Result<()> {
    let wallet = PrivateKeySigner::from_str("0xYOUR_PRIVATE_KEY")?;
    let address = wallet.address();
    let account: Address = "0xYourAccountAddress".parse()?;
    
    // Create the JSON-RPC request body
    let request_body = json!({
        "jsonrpc": "2.0",
        "method": "dab_accountInfo",
        "params": [account.to_string()],
        "id": 1
    });
    
    let body_string = serde_json::to_string(&request_body)?;
    
    // Compute keccak256 hash of the body
    let body_hash = keccak256(body_string.as_bytes());
    
    // Apply EIP-191 formatting and hash again
    let eth_message_hash = eip191_hash_message(body_hash);
    
    // Sign the EIP-191 formatted hash
    let signature = wallet.sign_hash_sync(&eth_message_hash).await?;
    
    // Format header: address:signature (lowercase address)
    let auth_header = format!("{}:{}", address.to_string().to_lowercase(), signature);
    
    // Make authenticated request
    let client = Client::new();
    let response = client
        .post("https://da-builder.mainnet.spire.dev")
        .header("Content-Type", "application/json")
        .header("X-Flashbots-Signature", auth_header)
        .body(body_string)
        .send()
        .await?;
    
    let result: serde_json::Value = response.json().await?;
    println!("Account info: {:?}", result);
    Ok(())
}
For complete authentication implementation: See the fetch_account_info_via_rpc function↗ in the sample integration repository for the working Rust/Alloy implementation with proper EIP-191 signing.

​
Understanding Balance and Charges

​
Balance

Your GasTank balance represents deposited funds available to cover transaction costs. When transactions are included onchain, costs are automatically deducted from this balance. See Cost Structure for details on how costs are calculated.

​
Outstanding Charges

Outstanding charges are costs that have been calculated but not yet settled. These represent transactions that have been included in blocks but charges haven’t been finalized yet. Outstanding charges will be deducted from your balance once settlement completes.

​
Whitelist Status

The whitelisted field indicates whether your account is authorized to submit transactions to DA Builder. Only whitelisted accounts can submit transactions. If you need to be whitelisted, contact us↗.

​
Low Balance Warnings

If your balance becomes insufficient:
  • New transactions may be rejected
  • You’ll receive an “Insufficient balance” error
  • Deposit additional funds to the GasTank to continue

​
Transaction Status Tracking

Track individual transaction status using eth_getTransactionReceipt with your DA Builder Request ID.

​
Checking Transaction Status

curl -X POST https://da-builder.mainnet.spire.dev/ \
  -H "Content-Type: application/json" \
  --data '{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionReceipt",
    "params": ["0xYourDABuilderRequestID"],
    "id": 1
  }'

​
Transaction Lifecycle

  1. Submitted: Transaction received by DA Builder, Request ID returned
  2. Pending: Transaction in mempool, waiting for aggregation
  3. Included: Transaction included in aggregated onchain transaction
  4. Confirmed: Transaction confirmed on Ethereum
The receipt contains the actual blockchain transaction hash once included.

​
Monitoring Best Practices

  • Check balance regularly: Monitor your GasTank balance to ensure sufficient funds
  • Track outstanding charges: Understand pending costs before they settle
  • Monitor transaction status: Use Request IDs to track transaction progress
  • Set up alerts: Implement monitoring for low balance conditions

​
Common Issues

​
Account Not Found

Error: Account not found
Solution: Deposit funds to the GasTank to create an account

​
Insufficient Balance

Error: Insufficient balance
Solution: Add more funds to your GasTank account

​
Transaction Not Found

Error: Transaction not found
Solution: Transaction may not be included yet. Wait and retry, or verify the Request ID is correct

​
Next Steps