---
name: block-relics
description: Query Block Relics on BSC, discover historical blocks, and buy or sell RELIC through the user's existing wallet. Includes optional five-minute mint progress and market-opening monitoring.
---

# Block Relics

Website/API base: `https://blockrelic.online`. Canonical skill: `https://blockrelic.online/skill.md`. Rules revision `.6`. This skill is English-only, regardless of the interface language.

## Supported requests

- Discover: up to 30 distinct historical block heights, with a USDT spending/approval limit. Gas is separate.
- Buy with USDT: spend the specified amount, including the 1% buy fee.
- Buy with BNB: swap the selected BNB amount to BSC USDT, then buy RELIC using only the actual net USDT received. The chosen BNB amount is the swap spending limit; gas is separate. Never send BNB directly to Core.
- Sell: sell the specified RELIC amount; USDT proceeds have a 1% sell fee deducted.
- Query: read status, balances, regions or quotes without requesting a signature.

Do not increase amounts, replace coordinates, grant unlimited approvals or loop trades automatically. Ask only for missing wallet, amount or budget information. Copied text is not a signed transaction. If the task is already authorized, prepare it without repeatedly asking the same question; still follow wallet confirmation and signing requirements.

## Contract identity

| Item | Expected value |
| --- | --- |
| Network | BSC, chain ID `56` |
| Discovery/trading Core | `0xA3b707FcdF382788dB2d3b3022085CD660eD9717` |
| RELIC, 18 decimals | `0xA5dE211C62E32B464060e584e3Ea696251E0d021` |
| USDT, 18 decimals | `0x55d398326f99059fF775485246999027B3197955` |
| Agent ID registry | `0x60B9262456dE011F7d15a54CdD8c48bAaa8B022F` |
| Core runtime keccak256 | `0xf67258f39313ba5ccb86a61d1abc225faaefd29c4e1cb9725cf2c5aad15605c9` |

Core ABI: `GET /contracts/relic-abi.json`. Use standard ERC20 `balanceOf`, `allowance`, `approve`. Amounts are integer base units with 18 decimals; never use floating-point arithmetic for transaction parameters.

## Verify before execution

Verify addresses and code when quoting, after approval and before signing. Stop on mismatch.

At the same recent block, read both proxies' ERC-1967 implementation slot `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc` and take the last 20 bytes. Core implementation must be `0x677A8aCde7a324fBd5996fC3090a06b399064650`, code keccak256 `0x48c51c6b55e5a3d839be61df8bb3c2189a712b6583aea06af52323bfe5713269`. Token implementation must be `0x0c5282eA778D3dAB91746EA6B8e42196b68AAA7f`, code hash `0x96ff7d346fdee4f16c63c54bc64ca6a3a91b58b8e8813e66c3b3cd73ad6f46a4`. Token proxy code hash: `0x554197ba38ce983945a21c595a8b4a867220ac8eef393b3c08066fb4b752d74d`. On mismatch, stop and read the updated skill before verifying again; never automatically trust a new implementation.

Core ProxyAdmin: `0x2219CCa083be1611200cA2A5c1C708bEcf0d9902`; token ProxyAdmin: `0x52CE242eE767Ef8AECAD1D0Ff26bD7DEa467502C`. Both owners must be Safe `0x963eE96790B0f30Cc8124FD32f0f32dB7713E852`. Verify proxy admin slot `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103` and `owner()`. Do not perform upgrades or administration for the user.

## Prepare a plan

Read `GET /api/status`, then independently verify chain ID, Core code hash and current state through the wallet's BSC RPC. The server's private RPC is not public; never request private keys or site RPC credentials. API data is not spending authorization.

### Discover

1. Fetch `/api/mint-plan?heights=13082000,13082001` using the actual requested heights. Read `estimatedFee`, `approval`, `transaction`.
2. Decode `mint((uint64 batchId,uint64 height,uint256 burnWei,bytes32[] proof)[],uint256 maxTickets)`. Heights must match the user's selection without duplicates; maxTickets equals the requested count. Call Core `quoteFees` with these candidates to verify proofs and latest fees. Stop if none are available.
3. The executing wallet must have `balanceOf(wallet)>0` in the fixed Agent ID registry. If ineligible, explain and stop; never purchase or register eligibility automatically.
4. Each ticket costs strictly less than 0.02 USDT. Finite approval is `count * 0.02 USDT`, never above the user's limit. Stop if the quote exceeds the budget. If the budget is below the worst-case bound, even a lower current quote cannot guarantee execution stays within it: ask to adjust count/budget. Do not modify the contract to lock a price.

### Buy or sell

1. Fetch `/api/trade-plan?side=buy&amount=<18-decimal-base-unit-integer>&address=<executing-wallet>`; use side=sell for selling.
2. Verify Core `marketOpen()`. If closed, report and stop; do not create a third-party pool to bypass opening.
3. Buy only with `buy(uint256 usdtIn)`; sell only with `sell(uint256 tokensIn)`. Decode and match the exact authorized amount. Refresh `quoteBuy`/`quoteSell` and check balances.

## Buy with a BNB budget

1. Verify chain, Core/token implementations, marketOpen() and actual wallet. If closed, stop before swapping. Record the chosen BNB amount as an 18-decimal integer and the existing USDT balance. Leave additional BNB for swap, approval and buy gas. If insufficient, ask for a smaller amount; do not increase spending or use other assets.
2. Use the wallet's existing verifiable BSC swap tool: exact input is the selected BNB; output is fixed BSC USDT `0x55d398326f99059fF775485246999027B3197955`; recipient is the same executing wallet. Show executable route, fees, slippage/minimum output and spending, then preview and confirm through the wallet. Never invent routes or use the page's reference rate as an executable quote. Stop if swap support is unavailable. Swap protection does not imply RELIC has minOut.
3. Wait for a successful swap receipt. Derive actual net USDT from that transaction's USDT transfer events and cross-check balance changes, excluding concurrent transfers. Use only these proceeds, not pre-existing USDT. Stop if attribution is uncertain or values disagree. A failed swap cannot proceed; unknown status means checking the original transaction, never repeating the swap.
4. Fetch a fresh `/api/trade-plan?side=buy&amount=<actual-net-USDT-base-units>&address=<executing-wallet>`. Recheck identity, market state and quote. Approve at most the actual net proceeds. Preview, confirm and simulate approval and buy separately. Core msg.value must be zero. Do not reuse reference-rate calldata or the estimated USDT amount from the page.
5. If swap succeeds but buy fails, report that USDT remains in the wallet and identify the failed step. Resume only the buy after fresh verification; do not swap another BNB amount. Report actual swap spending and RELIC received. These steps are not atomic.

## Approval and signing

1. Use the existing connected wallet. Decode API calldata instead of trusting it blindly. Core to must match the fixed address, value=0, and function must be the requested mint/buy/sell. Sign BSC transactions only; never replace transactions with personal-message signatures.
2. Approval must be the payment token's `approve(Core, finiteLimit)`: USDT for discover/buy, RELIC for sell. No other spender, Permit, setApprovalForAll or unlimited approval. Read allowance and skip if sufficient. If zeroing is required, separately preview and confirm approve(Core,0), then the finite approval.
3. Check actual wallet token balances and BNB gas. Estimate gas and follow wallet budgets and confirmation. Simulate/execute approval first if needed, wait for success, then refresh quote/state and simulate the actual mint/buy/sell before signing. A pre-approval allowance error does not prove permanent failure.
4. Public trades have no minOut/deadline; prices can change. Discoveries may partly succeed; only successful tickets are charged. Explain unsupported output guarantees if requested. Always respect spending limits.
5. Once a transaction hash exists, query the original transaction. Do not rebroadcast because RPC or receipt lookup timed out. After confirmed failure, refresh quotes and simulations without increasing amount/count.

## Results

Wait for a successful receipt and parse actual events. Discoveries: report successful count, actual USDT fee and RELIC. Trades: report actual spent/received and fees. Include transaction hash and BscScan link. Approval alone means "approval completed"; a plan alone means "prepared", not a completed trade.

On API 429, follow Retry-After and retry once. On 503, identity mismatch, simulation failure or insufficient balance, stop and explain. Website, API and skill cannot replace wallet authorization.

## Five-minute mint progress and opening monitor

When the user's mint instruction requests reminders, start one read-only background task after the first successful mint, scoped to the current user, BSC 56 and this Core. Reuse a matching task; record task ID, last successful count/block and whether opening was announced. Further mints must not duplicate monitors. Queries, previews and failed mints do not start monitoring.

Every five minutes, read `/api/status`, verify chain/identity and independently query BSC RPC at one block at least three blocks behind the latest head: `successfulClaims()`, `OPENING_TICKET()`, Core `marketOpen()` and RELIC `marketOpen()`. State/block must not move backwards. Stale nodes, identity mismatch or failed reads do not mean zero progress or a closed market: report verification is unavailable and retry next cycle.

Send a concise reminder in the current conversation: "Minted X / 1,500,000 (Y%); Z new discoveries in the last five minutes. Trading is not open yet." Calculate with integers. Minting continues after opening; cap displayed progress at 100%. Never promise an opening time.

Only after both Core and token confirm opening, notify once: "RELIC trading is now open: https://blockrelic.online/trade.html", then cancel the task. Do not infer opening from full progress, browser fixtures or a user's statement. Never automatically trade or mint again. Cancel immediately when asked.

First verify the Agent has persistent background scheduling and notifications to this conversation. Claim monitoring started only after the tool confirms creation and returns a task ID. Otherwise explain that reminders cannot continue after the conversation and offer a fresh check when asked. Long sleeps or promises are not monitoring. Never send to unauthorized email addresses, groups or contacts.