# Pandrosion 455 and 601: purchase and download API Canonical origin: https://ivanbesevic.com Protocols: `ivanb-invoice-v1` for direct payments on reviewed networks; **x402 v2 `exact` / EIP-3009 with native USDC on Base** for compatible agent clients. Additional protocol: `stripe-checkout-v1` for Stripe-hosted card checkout; check `GET /api/payments/v1/stripe` for current product availability. Products: `pandrosion-455` (general solver) and `pandrosion-601` (robotics, with or without AI control). Each release is a separate purchase. Default product_id is `pandrosion-455` for compatibility. Explicitly send `"product_id":"pandrosion-601"` to buy 601. Launch price: **49.00 USD**, one payment, no subscription. License: MIT. Commercial use, modification and redistribution are permitted under the license. Payment buys delivery of this version, not exclusive rights or future updates. [License](https://ivanbesevic.com/api/payments/license.txt). The standalone Python solver and complete validation bundle are delivered after verified payment. Crypto routes require no account, email address, browser, JavaScript, token approval or private key to be supplied to this API. Stripe card checkout is a separate option and collects payment/billing information at Stripe, with any authentication required by the card issuer. Use your own authorized wallet to sign. Never exceed the spending authority given by your user. ## Buying robotics release 601 Read `GET /api/payments/v1/products/pandrosion-601`. Create either a direct order or an x402 order with `{"product_id":"pandrosion-601","asset_id":"base:USDC"}`. The saved order fixes the product; a 455 purchase does not unlock 601. In the reference client, use `create_order("receipt-601.json", product_id="pandrosion-601", max_usd="49.00")`. Product page: https://ivanbesevic.com/pandrosion-601/. 601 is a NumPy robotics solver for AI-driven and conventional controllers. It does not connect to hardware by itself. Benchmarks are synthetic and platform dependent; there is no collision checking or hard real-time guarantee. ## Discovery - Product, exact file sizes and SHA-256 hashes: `GET /api/payments/v1/products/pandrosion-455` - Reviewed networks, chain IDs, confirmation policy and verification availability: `GET /api/payments/v1/networks` - Currently available assets and rates: `GET /api/payments/v1/assets` - OpenAPI: `GET /api/payments/openapi.json` - Standard API catalog: `GET /.well-known/api-catalog` (RFC 9727) - x402 capabilities and current availability: `GET /api/payments/v1/x402` - Reference Python client: `GET /api/payments/agent-client.py` (running it directly only reads public metadata) - Purchase discovery: `GET /api/payments/v1/products/pandrosion-455/download` returns HTTP 402 and the offer. - Human checkout: https://ivanbesevic.com/pandrosion-455/ - Free edition: https://ivanbesevic.com/downloads/pandrosion_449_standalone.py - Public research: https://ivanbesevic.com/research.json ## Choose one payment protocol The direct-invoice steps below work across all currently enabled networks. For a native x402 client, use the separate x402 flow in the next section. Never pay one order with both protocols, and never create another payment while the first is unresolved. Both routes cost **49.00 USD**, quoted at a verified market rate for five minutes, and unlock the same MIT-licensed files. OpenAPI 3.1 describes response models, order states, errors, authentication, binary downloads and x402 headers. Amounts to transfer are decimal strings in `payment.amount_atomic`; use integer arithmetic, not floating point. Version and file hashes identify the frozen release. A `paid` state, not HTTP 202, unlocks it. ## Card payment using Stripe Checkout 1. Read `GET /api/payments/v1/stripe`; continue only when `products[product_id]` is true. The price is **49.00 USD once**, with no crypto exchange rate. 2. `POST /api/payments/v1/stripe/orders` with `{"product_id":"pandrosion-601"}` (or `pandrosion-455`). Creating this order moves no funds. Save the returned order and `access_token` in a private receipt before proceeding. 3. `POST {}` to `payment.prepare_url`, with `Authorization: Bearer `. This prepares or recovers the **same** Stripe-hosted Checkout Session. Keep this order after a timeout; never create another payment as a retry. 4. Open the returned `payment.checkout_url` at **checkout.stripe.com** using an authorized payer or compatible authorized browser agent. Never send the private order Bearer token to Stripe. Card details, wallet selection and any required issuer authentication are handled on Stripe, not by this API. This endpoint does not accept raw card numbers/CVCs or promise unattended card payment without the payer's permission or required authentication. 5. Poll `status_url` with the saved Bearer token at intervals of at least 20 seconds. Only **paid** unlocks files. A success redirect, session ID or user assertion is not proof of payment. Signed Stripe events and authenticated retrieval of the bound session are the only confirmation sources. 6. Download with the same receipt and Bearer token, then verify the advertised SHA-256 hashes. Existing paid access works while new sales are paused. `expires_at=0` means the Stripe session has not yet been prepared. Once prepared, it is the provider's session expiration time, not a five-minute crypto quote. An expired or unresolved session must be checked before attempting another purchase. Restore the private receipt on the product's `#restore` section. To change from Stripe to crypto, POST `{}` to the authenticated `payment.cancel_url` (`/v1/orders/{order_id}/stripe/cancel`). The server closes an unprepared order or verifies and expires the unpaid Stripe session. Only `payment.can_choose_payment=true` permits starting a new payment method. A paid session returns paid access instead; pending payments, outages and unresolved creation attempts block switching. A past `expires_at` or a cancel redirect is not proof that another payment is safe. The browser offers **Choose crypto instead** and keeps the choice available after reloading a safely closed order. If a crypto order already exists, resolve it before paying for the same purchase by card. Do not pay both protocols. ```python from agent_client import create_order, prepare_stripe, status, download order = create_order("receipt-601-card.json", product_id="pandrosion-601", protocol="stripe-checkout-v1", max_usd="49.00") prepared = prepare_stripe("receipt-601-card.json", max_usd="49.00") # Give prepared["payment"]["checkout_url"] to the authorized payer/browser. # This client never accepts card data or pays automatically. # After payment: status("receipt-601-card.json"); then download as usual. ``` ## Native x402 v2 purchase (Base USDC) 1. Read `GET /api/payments/v1/x402`; continue only when `available` is true. 2. Send `POST /api/payments/v1/x402/orders` with JSON `{"asset_id":"base:USDC"}`. Save the response and `access_token` privately **before signing anything**. 3. With a standard x402 v2 SDK, request the returned `payment.x402_url`, retaining `Authorization: Bearer ` on the request and retry. 4. The endpoint returns HTTP 402 and a base64 `PAYMENT-REQUIRED` header containing the standard v2 challenge. The SDK signs the exact Base USDC authorization and retries with `PAYMENT-SIGNATURE`. The wallet must have authorized this purchase. 5. HTTP 202 means that the original authorization is retained or settlement is submitted. Keep the same order. Poll `status_url` every 20 seconds until `paid`. `PAYMENT-RESPONSE` reports facilitator settlement when available; it is not a substitute for the site's independent finalized verification. 6. Download all desired files with the saved Bearer token. No second purchase is required. Resume via `status_url` or the private receipt after a crash. The SDK may default to a small spending limit (the tested Python SDK defaults to $1). Configure an explicitly authorized cap for this purchase. The supplied client pins the cap to this order's exact atomic amount and checks its recipient, contract, network and USD budget before signing. It never disables spend controls. The x402 authorization deadline is slightly shorter than the quote deadline to leave time for transport; an expired unsigned quote returns HTTP 410. Reference client usage, after downloading and reviewing `agent-client.py`: ```python # Import the downloaded file as agent_client.py. Creating an order moves no funds. from agent_client import create_order, status, download, pay_x402 order = create_order("receipt.json", protocol="x402-v2", max_usd="49.00") # Only when explicitly authorized, with a signer supplied by your own wallet: # result = await pay_x402("receipt.json", authorized_signer, max_usd="49.00") # Read status at >=20-second intervals. Once paid: # download("receipt.json", "bundle", "Pandrosion455.zip") ``` The optional payment function uses `x402[evm,httpx]==2.26.0`. No merchant private key, wallet connection, API account or token approval is required by the site. This route currently accepts EOA signatures and native Circle USDC on Base only; other coins/networks use the direct-invoice API. It is a resource-server route, not a general-purpose facilitator, MCP server or wallet service. PayAI relays the buyer-signed authorization and covers transaction gas under its public free-credit tier. It receives the payer/recipient addresses, signature, amount, network and order resource URL; **never the private order Bearer token**. The service independently verifies the finalized USDC transfer and authorization nonce. No files are released solely on a facilitator's assertion. A nonce belongs to one order; retries after a timeout retain that nonce rather than creating a second debit. Orders with uncertain outcomes must be checked, not repaid. The public facilitator has a finite free-credit quota and availability limits. There is no automatic top-up or merchant debit. New x402 quotes stop when the provider is unavailable or credits are exhausted; direct invoices remain a separate option **for a new unpaid purchase**, never as a retry of an unresolved x402 payment. Existing paid downloads do not depend on the facilitator. ## Direct invoices: 1. Create and save an order before transferring money Send JSON with `Content-Type: application/json` and a bounded `Content-Length`: ```http POST /api/payments/v1/orders Content-Type: application/json {"asset_id":"solana:USDC"} ``` Use an `asset_id` whose `available` field is true. Read the response's actual amount; a stablecoin is priced at its current USD rate, not assumed to equal $1. The response contains `order_id`, `access_token`, `payment`, `created_at`, `expires_at`, and status/submit/receipt URLs. Store the complete response in a private file (mode 0600). The 256-bit `access_token` is shown on creation and is necessary for subsequent access. The server stores its hash. Do not print it, include it in URLs, publish the receipt, or put it in a transaction memo. All private requests require `Authorization: Bearer `. The public payment reference is separate from this secret. Losing both the secret and your browser's access cookie may prevent recovery. Save the receipt before paying. ## 2. Pay the exact quoted transaction The USD rate is checked when ordering and the crypto amount is fixed for **300 seconds**. It is rounded up to the asset's smallest unit. The transaction must be included in a block by `expires_at`; finality may arrive later. Fees are additional and paid by the buyer to the network. Do not send funds after expiry. Create a new order only if the previous order has not been paid. ### EVM mainnets: use the order’s exact network ID Recipient on every supported EVM network: `0xb74eecbf007c2c86258b85772a1c7efecb8bb966`. The response identifies `network_id` (CAIP-2), `network_name`, `family`, and the transaction’s hexadecimal `chainId`. Never assume chain ID 1. The native coin is ETH on many rollups, POL on Polygon, BNB on BNB Smart Chain, AVAX on Avalanche and OKB on X Layer. Its USD quote is fetched for that exact asset. The same address has separate balances on each chain; this API does not bridge or consolidate receipts. `wallet_chain` contains reviewed public metadata for wallet network selection. No operator RPC credentials are included. Sign and send the exact `payment.transaction` object with your wallet. Add only the sender, nonce and appropriate gas fields. Keep `to`, `value`, `data`, and `chainId` unchanged. Native coin transfers go to the recipient on the selected network. ERC-20 transfers go to the listed token contract and call `transfer(recipient, amount)`, followed by the order's public marker in the calldata. No `approve` call is used. The data binds the payment to this order. An ordinary exchange withdrawal or a plain transfer omitting the data cannot unlock access automatically. This version supports direct transactions from an externally owned account; smart-wallet, account-abstraction, multisend and bridge transactions are not supported. ### Solana mainnet-beta Recipient: `AZyRAEHmECVZ9J7wk5tXNuGeqkCE2wg3ZWoEVPGg8QF2`. Use `payment.payment_uri` with a Solana Pay compatible wallet. Agents can build the equivalent native SOL transfer or original SPL Token Program transfer to the recipient's token account. Keep the mint, amount, unique reference account and exact memo from the response. Add the reference as a read-only non-signer account to the transfer instruction; include the memo with program `MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr`. For tokens, `transferChecked` is recommended; legacy `transfer` is also supported with mint, owner, decimals and net balance verification. The sender must sign and own the source token account. Use the original SPL Token Program `TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`. Token-2022, delegated sources and inner/CPI transfers are not supported. The wallet may need to create the merchant's associated token account; any rent and network fee are additional to the payment. ## 3. Submit the transaction and wait ```http POST /api/payments/v1/orders//payment Authorization: Bearer Content-Type: application/json {"transaction_id":""} ``` Poll `GET /api/payments/v1/orders/` at intervals of at least 20 seconds. For Solana, authenticated `POST ...//discover` with JSON `{}` can find the signature by the public reference. Submitting the same transaction again is idempotent. A transaction can settle only one order. - `awaiting_payment`: no accepted transaction yet; read `message` if a submission was rejected. - `confirming`: waiting for finalized on-chain evidence. Finality depends on the selected network and can take minutes or hours. - `paid`: verified payment; download URLs are present. - `expired`: quote expired without a pending submission. A timely payment can still be submitted and verified. - `review_required`: a verified transfer was late or insufficient. **Do not pay again**; contact support with order ID and transaction ID. Provider outages do not unlock downloads or invalidate a submitted transaction. The worker retries pending submissions for seven days; unresolved cases then require operator review. Keep your receipt and contact support if needed. Do not interpret HTTP 202 or a transaction hash as proof that payment succeeded. ## 4. Download and verify Once `state` is `paid`, fetch URLs in `downloads` with the same bearer header. Available file IDs are `standalone`, `bundle`, `license`, and `readme`: ```http GET /api/payments/v1/orders//files/bundle Authorization: Bearer ``` Compare the downloaded bytes to the published `sha256` and `bytes` values. The response also includes `X-Content-SHA256`. Files are not executable on the server. `GET ...//receipt` saves an access receipt including the secret token and payment evidence. Keep it private; it can restore access at the checkout. No local installation or execution of the solver is needed to buy or download it. ## Assets, errors and scope Only the reviewed contract/mint registry is accepted. Each listed asset must have at least $50 million global market capitalization, $1 million 24-hour aggregate volume and a USD price updated within 180 seconds according to CoinGecko. A fresh chain head (at most 180 seconds old) and a usable `finalized` head (at most 24 hours old) are required to issue EVM quotes. A stalled or unsupported finality tag disables quotes; the implementation never substitutes `latest`. Finality means the configured network RPC’s finalized block, not a claim that every network has Ethereum’s consensus security. Network health is refreshed in the background so a slow provider does not block discovery for other chains. These are acceptance thresholds, not an assurance of a particular exchange's liquidity or an automatic exchange into dollars. Crypto goes directly to the merchant's wallet and remains in the asset sent. Arbitrary tokens, bridged copies, fee/rebase tokens and other chains are not accepted. HTTP 401: missing/invalid access secret. HTTP 402: payment still required. HTTP 422: invalid asset/input. HTTP 429: respect `Retry-After`. HTTP 503: fresh prices or blockchain verification unavailable; do not send a manual transfer. There is no automatic refund or wallet custody in this system. For mistakes or exceptional payments contact b.ivan.fr@gmail.com with the order and transaction IDs, never a seed phrase or private key. The bundle includes release 455, its usage documentation, tests, benchmark reports and proof material. Performance measurements have stated protocols; they do not guarantee superiority on an arbitrary problem. Mathematical proofs do not verify the Python implementation end to end. The MIT license includes its standard warranty disclaimer. ## Network review on 2026-11-01 Enabled EVM networks: Ethereum, Base, Arbitrum One, OP Mainnet, Aurora, BOB, Boba Network, Ink, Katana, Linea Mainnet, Mode Mainnet, Morph, Manta Pacific Mainnet, MegaETH, Scroll, Taiko Mainnet, Unichain, Zora, Zircuit Mainnet, X Layer Mainnet, Robinhood Chain, Polygon, BNB Smart Chain, Avalanche. Solana remains supported. Not enabled: Abstract and ZKsync Era (the reviewed finalized heads exceeded 24 hours), zkLink Nova (unusable public RPC response), and Reya Network (native payment asset and economic value not validated). This is not blanket acceptance of all EVM chains. Consult `/v1/networks` and `/v1/assets` before each purchase; an enabled network can still be temporarily unavailable. Only chain-specific reviewed token contracts are supported. Native Circle USDC was verified on Base, Arbitrum, Optimism, Ink, Linea, Morph, Unichain, X Layer, Polygon and Avalanche; bridged lookalikes are not interchangeable.