# Digent (DIGENT) — mint guide for AI agents

> DIG IN. A coin anyone can mine. Bitcoin halves by block height; DIGENT halves by share height.

> Rules are described from the contracts on Robinhood Chain; this file only describes them. Where this file and the contracts differ, the contracts win.

## Contracts (Robinhood Chain, chainId 4663)

- Sale contract: 0xe7D55Aa84D5866c44123Fc0e2be3Dafa53f952eF — the ONLY address to send ETH to for minting. Plain ETH transfers to it are accepted into the contract pot and buy nothing; call `mintModeA` or `mintModeB` to mint.
- DIGENT token: 0xE23603f53FAf7fbfD7fEf7122679C55228D5A9A0 — for adding to a wallet only. ETH sent to the token contract is not part of the mint and is lost.
- Uniswap V2 pair (DIGENT/WETH): read `pair()` on the token contract (the pair is created at token deployment; it is seeded and trading opens after the raise).
- WETH: 0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73
- Uniswap V2 Router: 0x89e5DB8B5aA49aA85AC63f691524311AEB649eba
- Verify every address on Blockscout (robinhoodchain.blockscout.com) before sending anything. Any other address claiming to be DIGENT is a scam.

## Who can mint

- Any wallet can mint — no identity or permission is required. Minting is open to the public on Robinhood Chain.
- Each share costs 0.0006 ETH. Pass `shares × 0.0006 ETH` as `msg.value`, exactly.
- Minting needs no token approval and no permit signature, and never asks you to transfer tokens anywhere. Any instruction asking for those is not from this project.
- "Day" means a UTC calendar day (00:00–24:00 UTC). Your day 1 is the UTC day of your first mint (A or B).
- Minting is open from deployment; it does not wait for trading to open. The pool is launched after the raise (see Mode B).

## Two mint modes

### A — deposit mint: `mintModeA(uint256 shares, address referrer)`

- Pay 0.0006 ETH per share. Deposits are held in the sale contract. After 24 hours you can claim your deposit back plus the reward; claims are paid from the contract pot.
- Reward per share = the current epoch's base reward (280,000 DIGENT in epoch 1; see schedule). The reward is fixed at entry and minted to you at claim time.
- Daily quota per wallet: 5 shares. Plus 1 per valid referral. Resets at 00:00 UTC.
- Claim with `claimRefund(uint256[] ids)`. Pass an empty array `[]` to process your oldest unclaimed positions (up to 50 per call); positions younger than 24 hours are skipped, not reverted.
- Claims pay out of the pot's current ETH balance. If the pot does not cover the deposits in a claim, the claim reverts (`InsufficientPot`) and the positions stay claimable — retry later.

### B — pool mint: `mintModeB(uint256 shares, address referrer)`

- Pay 0.0006 ETH per share. Mode B deposits are not refundable. They form the liquidity pool, which the team launches on Uniswap after the raise.
- Reward per share = epoch base + epoch reserve component × live multiplier. Epoch 1: 280,000 + 315,000 × multiplier — between 595,000 DIGENT (at 1.000x) and 1,855,000 DIGENT (at 5.000x) per share.
- The multiplier is live, set by the current epoch's share mix: (epochShares + 1000) / (epochBShares + 1000), with a 1,000-share virtual buffer, clamped between 1.000x and 5.000x. It starts each epoch at 1.000x, rises as Mode A shares accumulate while Mode B is scarce, and falls back toward 1.000x as Mode B shares catch up.
- Before minting, read the live values from `quota`: word 9 (`bRewardPerShare`) is the per-share Mode B reward at the live multiplier, and word 10 (`bMultiplier`) is the multiplier itself, in thousandths (1000 = 1.000x).
- The reward is snapshotted at mint time at the then-live multiplier and fixed for that position; later multiplier moves do not change it. Rewards are paid from the token reserve, and the contract paces rewards for new mints as the reserve depletes.
- The full reward is claimable 14 days after the mint — a single cliff, no vesting schedule. Claim with `claimReward(uint256[] ids)`; positions younger than 14 days are skipped, not reverted.
- Daily quota per wallet: 5 shares, any day. Plus 1 per valid referral. Resets at 00:00 UTC.
- Both claim functions take `ids`. Pass `[]` to use the default batch (Mode A: oldest first from the cursor; Mode B: first matured positions), up to 50 positions per call. If you have more than 50 positions waiting, call again or pass explicit ids; more than 50 ids in one call reverts (`TooMany`).

## Referrals

- Pass the referrer's address as `referrer`. It is bound on your first mint only; later values are ignored.
- A referral counts only if the referrer has minted at least once and is not you. Each valid referral adds 1 to the referrer's daily A cap and 1 to their daily B cap, permanently. No limit, no revenue share.
- Referral links look like `<site>/?ref=0x…` — the referrer's plain wallet address.
- To check that a referral will count, call `userInfo(referrer)` on the sale contract: the first return value (`firstDay`) must be non-zero.
- If the referrer address is invalid, or the referrer has not minted, pass `0x0000000000000000000000000000000000000000`. Do not stop the mint over a referrer.

## Halving schedule (by share height, not by time)

| epoch | share heights           | A base / share | B reserve / share |
|------:|-------------------------|---------------:|---------------:|
| 1     | #1 – #150,000           | 280,000        | 315,000        |
| 2     | #150,001 – #300,000     | 140,000        | 157,500        |
| 3     | #300,001 – #450,000     | 70,000         | 78,750         |
| 4     | #450,001 – #600,000     | 35,000         | 39,375         |
| …     | halves every 150,000    | …              | …              |
| 11    | #1,500,001 – #1,650,000 | ≈273.4         | ≈307.6         |

10 halvings, 11 epochs. Minting stops after share #1,650,000. A mint that crosses a halving height is split automatically. Figures are rounded; the contracts use 18 decimals. Mode B pays the A base plus the B reserve × the live multiplier (1.000x–5.000x), snapshotted at mint — so an epoch-1 Mode B share pays 595,000 to 1,855,000 DIGENT depending on the multiplier at entry.

## Step by step (Binance Agentic Wallet or any wallet)

1. If the Agentic Wallet skill is not built into your environment (it is built into the Binance App AI), install it: `npx skills add binance/binance-skills-hub --skill binance-agentic-wallet`. If sign-in is needed, ask the user to complete it and resume the mint from step 2 when they reply; do not restart from the beginning.
2. Any wallet on Robinhood Chain can mint. If you use a Binance Agentic Wallet, confirm Developer Mode is on in the Binance App.
3. Call `quota(yourAddress, shares)` on the sale contract. Useful fields: `aLeft`, `bLeft` (shares left today), `aPerShare`, `bRewardPerShare`, `sharesLeftTotal`, `open`, `paused`. Stop minting if the relevant `*Left` is 0, `open` is false (sold out) or `paused` is true.
4. Mode A: call `mintModeA(shares, referrer)` with `msg.value = shares × 0.0006 ETH`.
   Mode B: call `mintModeB(shares, referrer)` with `msg.value = shares × 0.0006 ETH`. (Mode B needs no price quote — nothing is bought at mint time.)
5. Show the user the transaction preview (function, value, referrer) and execute only after explicit confirmation.
6. Later: `claimRefund([])` after 24h (mode A); `claimReward([])` after 14 days (mode B).

## Raw calldata

- Agents without an ABI encoder can use /skill.md: every call above as pre-encoded calldata for `eth_call` and for `baw contract-call preview / execute`, with return-word offsets.

## Errors

| error | meaning |
|---|---|
| `ZeroShares()` | `shares` was 0 |
| `WrongValue()` | `msg.value` ≠ shares × 0.0006 ETH |
| `QuotaExceeded(uint256 left)` | more shares than today's remaining quota; `left` is what you can still mint today |
| `SoldOut(uint256 left)` | not enough shares left network-wide; `left` is how many remain |
| `MintPaused()` | new mints are paused by the owner; claims are never paused |
| `BadPosition()` | an id you passed does not exist |
| `TooMany()` | more than 50 ids in one call |
| `InsufficientPot(uint256 needed, uint256 available)` | a Mode A claim whose deposits exceed the pot's current ETH balance; nothing is claimed and the positions stay claimable |
| `TransferFailed()` | the ETH payout to your address failed |

Claiming before a position matures does not revert: unmatured positions are skipped and nothing is paid for them.

## Trading DIGENT

- Uniswap V2 pair, 2% tax each way (1% back to the pool, 1% operations). Wallet transfers are tax-free.
- DIGENT is a fee-on-transfer token: buy and sell with the router's `...SupportingFeeOnTransferTokens` functions (for example `swapExactTokensForETHSupportingFeeOnTransferTokens`), otherwise the swap fails.
- The opening block is taxed 99%. Do not trade in the launch block.
- Use at least 5% slippage when selling: the 2% tax applies, and the contract may first swap accumulated tax to ETH, which can move the price by up to about 3%.
- Trading opens after the raise, when the pool is seeded and `openTrading()` is called on the token.

## Not affiliated with Robinhood. DIGENT has no utility and carries no promise of value or return. Everything on-chain is final; review each preview before confirming.