#API reference

On mainnet: JSON-RPC https://rpc.vyrechain.com, explorer REST https://explorer.vyrechain.com/api/v2/, Etherscan-style https://explorer.vyrechain.com/api. There's no faucet, and no bundler: the Face ID wallets' bundler runs on the testnet only, and /bundler on mainnet answers 404. Everything below is written with the testnet's URLs.

#JSON-RPC

Standard Ethereum JSON-RPC over HTTPS POST: the read-only and sending eth_, net_ and web3_ methods (not wallet and signing methods, filters or eth_subscribe), in batches of up to 20. Limits and costs per call are on Network and RPC.

curl -s https://testnet-rpc.vyrechain.com \
  -H 'content-type: application/json' \
  --data '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

Errors past a limit: HTTP 429 with {"error":{"code":-32005,"message":"rate limited, slow down"}} (or too many requests waiting, slow down), or HTTP 503 busy, try again; nothing was sent when the line is full (a plain busy, try again is the server's room for answers being used up), with a Retry-After header (seconds) when waiting helps; the error carries the request's own id (a list, one per call, for a batch). A method the public RPC doesn't serve: -32601; something that is not a call, or a call with no method that is a string: -32600; a call with a member other than jsonrpc, id, method and params, or an id that isn't a string (up to 256 characters), a whole number up to 9007199254740991 or null: -32600 (invalid request, under id null when the id is the fault); params that are neither a list nor an object: -32602. A list of more than 20 calls is refused with -32600 under every call's own id (HTTP 200, so a library shows the reason); one of more than 1,000 calls, or a request nested more than 32 levels deep, is refused with one -32600 error and HTTP 400 before it is parsed. In a batch only the refused calls get these errors: the others are served. A batch may cost more than the burst (seven eth_calls are 70 points against a burst of 60): it is served once and the rate then pays the cost off, so the next request waits. With ethers v6, create a provider that only reads with { batchMaxCount: 10 } (its default of 100 calls per batch is over the 20 allowed), and one that sends transactions with { batchMaxCount: 1 }: a send batched with a read is refused whole.

#Bundler

This section is the testnet's. There's no bundler on mainnet (/bundler answers 404), so there are no Face ID wallets there.

POST https://testnet-api.vyrechain.com/bundler: ERC-4337 JSON-RPC for Face ID wallets, one request at a time: eth_chainId, eth_supportedEntryPoints, eth_estimateUserOperationGas, eth_sendUserOperation, eth_getUserOperationReceipt and eth_getUserOperationByHash. It takes only operations for EntryPoint v0.6, with no paymaster (the wallet pays its own gas), from a wallet made by VYRE's Smart Wallet factory (made by the operation itself, or already made and still on the factory's implementation). Limits: 600 operations an hour per caller, 300 sends an hour per wallet, 64 KB a request; past them, HTTP 429.

#Transaction check

POST https://testnet-api.vyrechain.com/txcheck: what would this call do? An app can ask before it opens a wallet's signing prompt. VYRE runs the call on its own node, without sending it, and tells you whether it would fail, what it would do to the sender's USDC and tokens, and which allowances it would leave behind. It also looks up the addresses involved with GoPlus's address check.

It is advisory. It never blocks, delays or refuses anything: a flag is information for the person signing, not a reason to stop a trade or a launch. When the service is slow, busy or unreachable, go on without it. Treat what it says as one more thing to show, not a promise: a simulation is of the chain's state at that moment, an address check can miss things, and an event is what a contract chose to emit.

Body (JSON; data and value are optional):

{ "from": "0xSenderWallet", "to": "0xContract", "data": "0x…", "value": "1000000000000000000" }

value is wei of USDC (18 decimals), as a decimal or 0x-hex string; data is up to 24 KB. The chain is always VYRE's own: you may send "chainId": 7357, and any other value is refused. Nothing else is accepted: no gas, block or tracer settings; the server chooses them.

Answer (200):

{
  "advisory": true,
  "chainId": 7357,
  "simulated": true,
  "reverts": false,
  "revertReason": null,
  "gasLimit": 32000000,
  "gasEstimate": "152340",
  "nativeChange": "-1000000000000000000",
  "transfers": [
    { "token": "0x…", "direction": "out", "counterparty": "0x…", "amount": "5000000" }
  ],
  "approvals": [
    { "kind": "erc20", "token": "0x…", "spender": "0x…", "amount": "115792089237316195423570985008687907853269984665640564039457584007913129639935", "unlimited": true }
  ],
  "addressChecks": {
    "source": "goplus",
    "available": true,
    "checked": [ { "address": "0x…", "flagged": false, "categories": [] } ]
  },
  "flags": [
    { "code": "unlimited_approval", "message": "This gives a contract an unlimited allowance to move a token (or every token of a collection) from this wallet.", "token": "0x…", "spender": "0x…" }
  ]
}

Errors: 400 {"error": "…"} for anything that isn't a valid check; 403 from a browser page that isn't one of VYRE's own sites; 405 for anything but POST; 408 when the request took too long to arrive; 413 for a body over 64 KB; 415 for a request that isn't application/json; 429 with "busy": true when the node is working on other checks, or when it was busy for more than half of the last minute and your network had a large part of that (try again in a moment, or go on), or with retryAfter (seconds) after 600 checks an hour from one caller. A caller has one check at a time. Browsers may call it from VYRE's own sites; from anywhere else, call it from your server.

curl -s -X POST https://testnet-api.vyrechain.com/txcheck \
  -H 'content-type: application/json' \
  --data '{"from":"0xYourWallet","to":"0x60A2E571f0272151a23Cd0d5EC814A67fBf9bf34","data":"0x","value":"0"}'

What is sent to GoPlus: only addresses (the destination, anyone given an allowance, anyone who gets tokens), to its public address-security API, which works for any chain: never amounts, call data, or the sender's own address. GoPlus's own transaction simulation covers a short list of other chains and not VYRE, so the simulation here is VYRE's own and nothing in it comes from GoPlus. GoPlus is a separate company with its own terms and privacy policy; VYRE uses its public service and the check is not endorsed or certified by it. Answers are kept in memory for ten minutes.

The SDK has a helper for this call, checkTransaction (since version 0.5.0): it waits at most four seconds and returns { available: false } instead of an error, so an app can always go on.

#Explorer REST API

The explorer runs Blockscout, whose REST API v2 serves indexed history: addresses, transactions, token transfers, logs, contracts and chain stats. Every endpoint, with a way to try it: https://testnet-explorer.vyrechain.com/api-docs.

A few useful ones:

Paged lists return next_page_params: pass its fields back as query parameters for the next page.

Read the numbers in /api/v2/stats with these in mind:

• Transactions include ArbOS's own. The chain makes one bookkeeping transaction in every block and one for every batch posted (type 106, sent from 0x00000000000000000000000000000000000a4b05, fee 0). total_transactions counts them with everyone else's, which is about half of it; take the address's transactions_count from /api/v2/addresses/0x00000000000000000000000000000000000a4b05/counters off the total for the transactions people and contracts sent.
• gas_prices is not a fee cap. It is an estimate worked out by Ethereum's rule for the next base fee, shown rounded (the floor: 0.01 gwei on the testnet), and the true next base fee can sit below the chain's minimum, so a transaction capped at it can be refused. Take the fee from eth_gasPrice or the latest block's baseFeePerGas; the explorer has no gas tracker page for the same reason.
• Utilization and gas-limit figures don't move. Every block reports a gas limit of 2^50 (the chain's real limits are its speed limit and a per-transaction cap), so network_utilization_percentage stays near 0 and a block's "gas limit" is that number.
• transactions_today and gas_used_today are not reliable. They are the explorer's running count of the current day and have read 0, null and a partial day's count, depending on the explorer's settings and restarts; the all-time total_gas_used is counted (CACHE_TOTAL_GAS_USAGE_COUNTER_ENABLED). The daily charts of the stats service (which fill in a day later) are the figures to quote.
• Fees on the explorer's lists are rounded to five decimals (0.00001 USDC), so a trade that cost 0.0000062 USDC shows as 0.00001 there; the transaction's own page and fee in the API carry the exact figure.

curl -s 'https://testnet-explorer.vyrechain.com/api/v2/addresses/0x60A2E571f0272151a23Cd0d5EC814A67fBf9bf34'

#Explorer, Etherscan-style API

The same explorer answers Etherscan's module/action API at https://testnet-explorer.vyrechain.com/api for reads, so tools written for Etherscan can read from it. No API key. It takes no writes: contract source is published through the explorer's form (see Deploy and verify), not from Foundry's or Hardhat's verify commands.

# a balance, in wei of USDC (18 decimals)
curl -s 'https://testnet-explorer.vyrechain.com/api?module=account&action=balance&address=0xYourAddress'
# a verified contract's ABI
curl -s 'https://testnet-explorer.vyrechain.com/api?module=contract&action=getabi&address=0x60A2E571f0272151a23Cd0d5EC814A67fBf9bf34'

#Faucet API

Sends test USDC on VYRE Testnet: 2 USDC per wallet and per IP address every 24 hours (6 for a wallet that sent back at least 2 USDC since its last drip), with hourly and daily caps across everyone.

#GET https://testnet-rpc.vyrechain.com/faucet/status

{ "address": "0x35dB…36bd", "balance": "19.5", "drip": "2", "cooldownHours": 24,
  "returnCooldownHours": 6, "open": true, "dripsLeftToday": 150, "givenBack": "12.5" }

address is the faucet's own wallet. Anyone can refill it: send it test USDC on VYRE, or on Arc testnet (the faucet bridges that over by itself within a few minutes). open is false while it's too low to pay a drip. dripsLeftToday counts down the daily cap; givenBack is everything sent back to it since it started counting.

#GET https://testnet-rpc.vyrechain.com/faucet/givers

{ "givers": [{ "address": "0x…", "given": "20", "received": "2" }] }

The top 20 givers: wallets that sent USDC to the faucet on VYRE (a plain transfer, or a Face ID wallet's operation), by what they gave beyond what they got. Gifts under 0.01 USDC aren't counted. Updated every 30 seconds at most.

Each network may read /status and /givers 60 times a minute in all; past that they answer 429 with {"error": "…", "retryAfter": 60} (seconds) until the minute is over. Drip requests have a budget of their own.

#POST https://testnet-rpc.vyrechain.com/faucet/drip

Body: {"address": "0x…"} (JSON). Answers:

curl -s -X POST https://testnet-rpc.vyrechain.com/faucet/drip \
  -H 'content-type: application/json' \
  --data '{"address":"0xYourAddress"}'

Scripts and servers can call it; the limits are per wallet and per IP. From a web browser, only the faucet page can: a request from another website's page is refused (403), so no site can have its visitors ask for test USDC on its behalf and use up the day's cap. Send the body as JSON (content-type: application/json, at most 1 KB: a longer body gets the connection closed). The status and the givers can be read from any page. The SDK wraps both calls (getFaucetStatus, requestTestUsdc); requestTestUsdc works from a script or a server. An app that wants to offer its users test USDC links them to the faucet page.

#Contract ABIs

The launchpad's ABIs as JSON, from the code deployed on the testnet:

Until the testnet is redeployed, its contracts are from an earlier build than the contracts' current code, which the SDK's ABIs (vyrePadAbi and the others) follow: VyrePad there lacks OPENING_MARKET_CAP and still has MAX_STARTING_MARKET_CAP and MIN_STARTING_MARKET_CAP; VyreAppRouter there lacks GasInfoChanged, GasRefund, MAX_REFUND_CALLDATA, REFUND_BASE_GAS, REFUND_MARGIN_BPS, REFUND_OVERHEAD_GAS, gasInfo and setGasInfo; VyrePool there lacks LaunchFee, launchFeeConfig and launchFees. Calls to the functions they lack revert there.

Mainnet's launch contract is VyrePadV2: its ABI is VyrePadV2.json, from the code it was deployed from. Mainnet has no VyreAppRouter or VyreReferrals; the SwapRouter, QuoterV2, VyreToken, VyrePool and WUSDC ABIs above are the ones mainnet's contracts use.

Addresses are on Contract addresses. The verified source is on the explorer once each contract is verified there.