trench.today API on Robinhood

trench.today is a meme-coin launchpad on the Robinhood network, one of the most active token factories on the chain. This guide shows how to track newly launched trench.today tokens, bonding-curve buys and sells, and live curve reserves with Bitquery GraphQL APIs, using the EVM(network: robinhood) Events cube.

API Key Required

To query or stream data outside the Bitquery IDE, you need an API access token.

Follow the steps here: How to generate Bitquery API token ➤

Related docs

• Robinhood Chain API overview — every Robinhood Chain API, launchpad guide and stream in one place
• Robinhood Trades API
• Robinhood Meme Coin Launches API
• Flap.sh API on Robinhood — another Robinhood launchpad
• Pons Launchpad API on Robinhood Chain
• Robinhood Transfers
• WebSocket subscriptions

---

trench.today contracts

All trench.today protocol events are emitted through a single factory proxy, which makes filtering simple: pin every query to one LogHeader.Address.

Role	Address	Emits
Factory / curve engine (EIP-1967 proxy)	0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d	TokenCreate, TokenPurchase, TokenSale, Sync
Implementation (behind the proxy)	0x5d15bdd2a834c66149c38c5ae19c5f4b60cbc397	Shown as Log.SmartContract in decoded events

Decoded event names exist on the realtime dataset only

On dataset: realtime (the default) the four events carry decoded names and Arguments, and every query on this page works as written. On dataset: archive and dataset: combined the same rows are stored undecoded, so a Log.Signature.Name filter returns zero rows there, silently. For history, filter by topic0 instead and decode the payload client-side:

Event	topic0 (Log.Signature.SignatureHash)
TokenCreate	e2eb7016a2fc7f0aec441cc8bc9a7ecd75d29d94478782bab1cfa9c5b0dbdf1b
TokenPurchase	b284604a447841f5b5ee1495033bc7db1ab2f84c2624a7b7a3e9f014f32e8e7b
TokenSale	fe41490121bfbd4555a4f9aabe1e789de1641611b7edd2a0dc1c594f684ba193
Sync	27efe2fec96cb0ff68b9206e3dca402a919bb7172e2f2d12d49b633df3eabc4f

{
  EVM(network: robinhood, dataset: archive) {
    Events(
      limit: {count: 10}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
        Log: {Signature: {SignatureHash: {is: "e2eb7016a2fc7f0aec441cc8bc9a7ecd75d29d94478782bab1cfa9c5b0dbdf1b"}}}
      }
    ) {
      Block { Time }
      Transaction { Hash }
      LogHeader { Address Data }
      Log { Signature { SignatureHash } }
    }
  }
}

The four events cover the full bonding-curve lifecycle:

Event	Meaning	Key arguments
TokenCreate	New token launched	creator, curve, token, quote, name, symbol, timestamp, tokenURI
TokenPurchase	Buy on the curve	token, buyer, amountOut, quoteAmountUsed, protocolFee, extraFee, extraFeeReceiver, extraFeeRate
TokenSale	Sell on the curve	token, seller, amountIn, netQuoteOut, protocolFee, extraFee, extraFeeReceiver
Sync	Post-trade curve reserves	token, realQuoteReserves, realTokenReserves, virtualQuote, virtualToken

Amounts are raw on-chain integers

Event argument values (amountOut, quoteAmountUsed, reserves, fees) are the raw on-chain integers — divide by 1e18 for whole-token / native amounts. The quote argument of TokenCreate is the zero address, meaning the curve quotes in the chain's native token.

---

Newly launched tokens

Every launch emits a decoded TokenCreate event with the creator, the new token address, its bonding curve contract, and full metadata (name, symbol, tokenURI).

▶️ Run in IDE · WebSocket stream

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 20}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
        Log: {Signature: {Name: {is: "TokenCreate"}}}
      }
    ) {
      Block {
        Time
        Number
      }
      Transaction {
        Hash
        From
      }
      Log {
        Signature {
          Name
        }
        SmartContract
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_String_Value_Arg {
            string
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
        }
      }
    }
  }
}

Stream the same query

Change the operation type from a query to a subscription in the Bitquery IDE (and drop limit/orderBy) to receive every new trench.today launch in real time over WebSocket.

---

Token buys (TokenPurchase)

Each buy on the bonding curve emits TokenPurchase with the buyer, tokens received (amountOut), native spent (quoteAmountUsed), and the protocol fee.

▶️ Run in IDE

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 20}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
        Log: {Signature: {Name: {is: "TokenPurchase"}}}
      }
    ) {
      Block {
        Time
      }
      Transaction {
        Hash
        From
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
        }
      }
    }
  }
}

Token sells (TokenSale)

Sells mirror buys: amountIn is the tokens sold, netQuoteOut the native returned to the seller after fees.

▶️ Run in IDE

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 20}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
        Log: {Signature: {Name: {is: "TokenSale"}}}
      }
    ) {
      Block {
        Time
      }
      Transaction {
        Hash
        From
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
        }
      }
    }
  }
}

Live trades stream (buys + sells)

Subscribe to both trade events in one WebSocket stream — the backbone of a trench.today trading bot or live feed.

▶️ Run in IDE

subscription {
  EVM(network: robinhood) {
    Events(
      where: {
        LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
        Log: {Signature: {Name: {in: ["TokenPurchase", "TokenSale"]}}}
      }
    ) {
      Block {
        Time
      }
      Transaction {
        Hash
        From
      }
      Log {
        Signature {
          Name
        }
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
        }
      }
    }
  }
}

Log.Signature.Name tells you whether each message is a buy (TokenPurchase) or a sell (TokenSale).

---

Bonding-curve reserves (Sync)

After every trade the curve emits Sync with its current state: realQuoteReserves / realTokenReserves (actual balances) and virtualQuote / virtualToken (the constant-product virtual reserves). The instantaneous curve price is virtualQuote / virtualToken, and real reserves show how far a token has progressed along its curve.

▶️ Run in IDE

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 20}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
        Log: {Signature: {Name: {is: "Sync"}}}
      }
    ) {
      Block {
        Time
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
        }
      }
    }
  }
}

---

All events for a single token

Every trench.today event carries a token argument, so one Arguments.includes filter follows a token through its whole lifecycle — creation, every buy and sell, and each reserve update. Replace the address with the token you're tracking.

▶️ Run in IDE

{
  EVM(network: robinhood) {
    Events(
      limit: {count: 50}
      orderBy: {descending: Block_Time}
      where: {
        LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
        Arguments: {
          includes: {
            Name: {is: "token"}
            Value: {Address: {is: "0xe6052a3eb17590ceac6652bc751065224749cccc"}}
          }
        }
      }
    ) {
      Block {
        Time
      }
      Transaction {
        Hash
        From
      }
      Log {
        Signature {
          Name
        }
      }
      Arguments {
        Name
        Value {
          ... on EVM_ABI_Address_Value_Arg {
            address
          }
          ... on EVM_ABI_String_Value_Arg {
            string
          }
          ... on EVM_ABI_BigInt_Value_Arg {
            bigInteger
          }
        }
      }
    }
  }
}

---

FAQ

How do I detect a newly launched trench.today token?

Filter events by Log.Signature.Name: "TokenCreate" on the factory address 0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d. The decoded arguments include the token address, its creator, the bonding curve contract, and metadata (name, symbol, tokenURI). Run it as a subscription for real-time launch alerts.

How do I get trench.today trades?

Query the same factory address for TokenPurchase (buys) and TokenSale (sells), or subscribe to both at once with Name: {in: ["TokenPurchase", "TokenSale"]}. Amounts are raw integers — divide by 1e18.

How do I compute a token's bonding-curve price?

Use the Sync event: the curve price in native terms is virtualQuote / virtualToken. Sync fires after every trade, so streaming it gives you a live price and reserve feed per token.

Why is there one contract address instead of separate factory and curve contracts?

trench.today runs everything through a single EIP-1967 proxy (0x77dc…f9d). Each token still gets its own curve contract (reported in TokenCreate), but events are emitted by the proxy, so a single LogHeader.Address filter captures the entire protocol. Decoded events report the implementation 0x5d15…397 as Log.SmartContract.

Can I use the Trading cube for trench.today trades?

Bonding-curve trades live in the EVM Events cube queries shown on this page. Once a token migrates to a DEX pool, its trading appears under Uniswap markets on Robinhood — follow it with the Robinhood Trades API.

---

Next steps

• Stream TokenCreate for real-time launch alerts, then follow each token with the all-events-for-a-token query.
• Track other Robinhood launchpads with the Robinhood Meme Coin Launches API.
• Explore prices, OHLCV, whale trades, and top traders in the Robinhood Trades API.
• Inspect holder and wallet flows with Robinhood Transfers.