---
name: outras-claim
description: Claim the one $OUTRAS allowance attached to an OUTRAS work on BNB Smart Chain (chainId 56) using a Binance Agentic Wallet and the baw CLI. Read the chain first, preview the exact call, execute only after the human confirms.
version: 1.0.0
language: en
canonical: https://outras.online/outras-claim-skill.md
---

# OUTRAS — Claim Skill

OUTRAS is 3,456 generative cellular-automaton works on BNB Smart Chain. Each work carries **one claim of 100,000 $OUTRAS tokens**. The claim belongs to the work, not to a wallet: if the work changes hands before its claim is used, the claim goes with it; once a work has claimed, its claim is gone for good. There is **no deadline**.

Token: `$OUTRAS`, total supply 10,000,000,000. Anti-Sybil fee: **0.000233420020341776 BNB = 233420020341776 wei** per claim, shown in the wallet before signing.

## 0. Status gate — always first

```bash
curl -s https://outras.online/mint.json
```

Resolve these fields from that file:

| Field | Meaning |
| --- | --- |
| `status` | Must be `"live"` |
| `live` | Must be `true` |
| `liveStatus.claimOpen` | Must be `true` |
| `contractAddress` | OUTRAS mint / NFT contract |
| `claimContractAddress` | Claim contract |
| `tokenAddress` | $OUTRAS token contract |
| `claim.feeWei` | Must equal `233420020341776` |

**If `status` is not `"live"`, or either contract address is `null`, stop.** Report: `Claiming coming soon — claim contract not deployed yet.` Do not construct, guess, derive or substitute an address from another site. Do not preview and do not execute. As of this document's publication, minting is live. The claim contract holds 345,600,000 $OUTRAS (funded 2026-11-02), so a valid claim pays out.

In the commands below, replace `<MINT_CONTRACT>`, `<CLAIM_CONTRACT>`, `<WALLET>`, `<TOKEN_ID>`, `<TOKEN_ID_32B>`, `<REQUEST_ID>` and `<TX_HASH>` with real values. Angle brackets are placeholders, never addresses.

## 1. Contracts

| Item | Value |
| --- | --- |
| Chain | BNB Smart Chain mainnet, `chainId 56` (`--binanceChainId 56`) |
| Mint / NFT contract | `<MINT_CONTRACT>` from `mint.json:contractAddress` |
| Claim contract | `<CLAIM_CONTRACT>` from `mint.json:claimContractAddress` |
| Token | `$OUTRAS`, `<TOKEN_ADDRESS>` from `mint.json:tokenAddress` |
| Public RPC | `https://bsc-rpc.publicnode.com` (fallbacks: `https://bsc-dataseed.bnbchain.org`, `https://bsc-dataseed1.binance.org`, `https://binance.llamarpc.com`) |
| Claim function | `claim(uint256)` |
| Claim selector | `0x379607f5` (`keccak256("claim(uint256)")[:4]`) |
| Calldata | `0x379607f5` + `<TOKEN_ID_32B>` (tokenId as one 32-byte hex word) |
| Value | exactly `233420020341776` wei |

Read the edition website at https://outras.online/ for the human-facing terms, and https://outras.online/llms.txt for the machine-readable summary.

## 2. Prerequisites — Binance Agentic Wallet

```bash
npm install -g @binance/agentic-wallet@1.12.0
baw --version
baw auth signin --json                 # open urlForWeb / scan in the Binance App
baw auth verify --qrCodeId <QR_CODE_ID> --json
baw wallet status --json               # CONNECTED
baw wallet address --json              # use the binanceChainId "56" address = <WALLET>
baw wallet agent-id --json             # Agent ID must be claimed
baw wallet settings --json             # devMode.enabled must be true
baw wallet balance --binanceChainId 56 --json   # BNB for gas and the claim fee
```

Developer Mode (Binance App → Agentic Wallet → Settings) is required for contract calls. The CLI never holds a private key; signing happens in the wallet, with a separate confirmation in the Binance App when required.

## 3. Read-first checks, per tokenId

All reads are `eth_call` at `latest` and send no transaction. Use the public RPC; no wallet library is needed.

```bash
RPC=https://bsc-rpc.publicnode.com

# Helper: read(address, data)
# curl -s -X POST "$RPC" -H 'content-type: application/json' \
#   -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"<ADDRESS>","data":"<DATA>"},"latest"]}'
```

| Check | Contract | Selector | Data | Expected |
| --- | --- | --- | --- | --- |
| `claimOpen()` | claim | `0x4b8bcb58` | `0x4b8bcb58` | `…01` (true) |
| `claimedById(uint256)` | claim | `0x4c80ee12` | `0x4c80ee12<TOKEN_ID_32B>` | `…00` (false = unclaimed) |
| `claimFee()` | claim | `0x99d32fc4` | `0x99d32fc4` | `233420020341776` wei |
| `ownerOf(uint256)` | mint | `0x6352211e` | `0x6352211e<TOKEN_ID_32B>` | equals `<WALLET>` (the current holder claims) |
| `totalMinted()` | mint | `0xa2309ff8` | `0xa2309ff8` | `1 … 3456` |

Concrete example, tokenId `1`: `<TOKEN_ID_32B>` = `0000000000000000000000000000000000000000000000000000000000000001`.

```bash
curl -s -X POST "$RPC" -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"<CLAIM_CONTRACT>","data":"0x4b8bcb58"},"latest"]}'

curl -s -X POST "$RPC" -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"<CLAIM_CONTRACT>","data":"0x4c80ee120000000000000000000000000000000000000000000000000000000000000001"},"latest"]}'

curl -s -X POST "$RPC" -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"<CLAIM_CONTRACT>","data":"0x99d32fc4"},"latest"]}'

curl -s -X POST "$RPC" -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"<MINT_CONTRACT>","data":"0x6352211e0000000000000000000000000000000000000000000000000000000000000001"},"latest"]}'
```

A 32-byte result ending in `01` means true; ending in `00` means false. Decode `claimFee()` as a big-endian uint256 and compare it with `233420020341776` exactly. If any read returns `0x`, an RPC error, or a value you cannot decode, stop and report the failure — do not continue with an assumed value.

Stop conditions:

- `claimOpen()` is false → the claim is not open; report and stop.
- `claimedById(tokenId)` is true → that work is spent for good; report and stop.
- `claimFee()` differs from `233420020341776` → report the difference and stop.
- `ownerOf(tokenId)` is not the wallet that will sign → the work is not held by this wallet; report and stop.
- The wallet has no Agent ID or Developer Mode is off → fix the prerequisite first.

## 4. Build the exact calldata

`claim(uint256)` selector: **`0x379607f5`**. Append the tokenId as 32 bytes, left-padded with zeros. Never use a decimal string, never omit the padding, never add extra arguments.

| tokenId | Hex | Calldata |
| --- | --- | --- |
| 1 | `0x01` | `0x379607f50000000000000000000000000000000000000000000000000000000000000001` |
| 3456 | `0x0d80` | `0x379607f50000000000000000000000000000000000000000000000000000000000000d80` |

Generate in a shell:

```bash
TOKEN_ID=1
TOKEN_ID_32B=$(printf '%064x' "$TOKEN_ID")
CLAIM_CALLDATA="0x379607f5${TOKEN_ID_32B}"
echo "$CLAIM_CALLDATA"
```

## 5. Preview — sends nothing

```bash
baw contract-call preview --binanceChainId 56 \
  --from <WALLET> \
  --to <CLAIM_CONTRACT> \
  --value 233420020341776 \
  --inputData <CLAIM_CALLDATA> \
  --json
```

Inspect the JSON response: destination must be `<CLAIM_CONTRACT>`, `value` must be `233420020341776` wei (**0.000233420020341776 BNB**), `inputData` must equal the calldata above, and the response must contain a `requestId`. Read any `parsedTx`, `simulationResult` and `risks` fields. The anti-Sybil fee must be visible in the wallet preview before signing.

Show the human: work number, destination, fee in BNB and wei, calldata, and the simulation result. **Ask for explicit confirmation.** A preview is not approval and broadcasts nothing.

## 6. Execute — only after explicit confirmation

```bash
baw contract-call execute --requestId <REQUEST_ID> --json
```

If the response is `PENDING_CONFIRMATION`, the human approves or rejects in the Binance App. Do not re-preview and do not retry a rejected request. A `requestId` is bound to one preview, chain and wallet, and is consumed once.

## 7. Verify

```bash
curl -s -X POST "$RPC" -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_call","params":[{"to":"<CLAIM_CONTRACT>","data":"0x4c80ee12<TOKEN_ID_32B>"},"latest"]}'
```

`claimedById(tokenId)` should now be true. Confirm the wallet's `$OUTRAS` balance increased by 100,000 tokens and report the tx hash to the human. If the chain still reports false, do not submit a second claim; report the tx hash and wait for the transaction to be indexed.

## 8. Repeat per tokenId

For each work the wallet holds, restart at step 3 with that tokenId and a fresh preview. One `claim(uint256)` call per work. There is no batch claim and no deadline. Each claim carries its own anti-Sybil fee.

## 9. Mint reference (for context)

The mint is agent-only: Binance Agentic Wallet holding an Agent ID, one work per wallet, contract callers rejected on-chain. `mint()` has selector `0x1249c58b`, takes no arguments, and requires a value of exactly `116000000000000` wei (0.000116 BNB, ~$0.08, flat).

```bash
baw contract-call preview --binanceChainId 56 \
  --from <WALLET> \
  --to <MINT_CONTRACT> \
  --value 116000000000000 \
  --inputData 0x1249c58b --json
baw contract-call execute --requestId <REQUEST_ID> --json
```

The block decides the seed; the seed decides the rule, palette and form. The seed lives on BNB Chain. The open renderer at https://outras.online/ redraws any work from its number and seed.

## 10. Failure handling

| Result | Action |
| --- | --- |
| `mint.json` unreachable or `status != "live"` | Stop. Do not guess addresses or state. |
| `claimOpen()` false | Report that claiming is closed; stop. |
| `claimedById(tokenId)` true | Report that the work is spent; stop. |
| `claimFee()` mismatch | Report the exact difference; stop. |
| `ownerOf(tokenId)` mismatch | Report current owner; stop. |
| `BAW_NOT_CONNECTED` | `baw auth signin --json` → verify in the App → `baw wallet status --json`. |
| `DEVMODE_REQUIRED` | Enable Developer Mode in the Binance App. |
| `BAW_PREVIEW_REJECTED` / simulation failure | Show the reason to the human; do not execute. |
| `PENDING_CONFIRMATION` | Wait for the human's decision in the Binance App. |
| Reverted transaction | Report the tx hash, re-read `claimedById(tokenId)`, never auto-retry. |

## 11. Rules for the agent

- Read before writing. Never sign a call you have not previewed.
- Never invent a contract address, a fee, a token amount or a claim status.
- Never execute without the wallet owner's explicit confirmation; the Binance App confirmation is a separate step.
- Never ask for or store a private key or seed phrase.
- One claim per work, once, with no deadline. The claim travels with an unclaimed work on sale.
- No price promises, no FOMO wording, no sales pressure, no creator wallet address, and no wallet-connect or download flow. Prices are quoted in BNB with a USD approximation only.
- An artwork, and the instruments to study it. That is all.
