From 1d86244881912c3c9edafd6ef7e029e374b1c82f Mon Sep 17 00:00:00 2001 From: Philip Mataras Date: Mon, 20 Apr 2026 19:33:24 -0400 Subject: [PATCH 01/53] docs: add Solana migration audit of all documentation pages MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Comprehensive page-by-page analysis of what needs updating in docs.ar.io for the AO→Solana migration. Covers ~97 pages across learn/, build/, sdks/, apis/, and glossary. Identifies 6 full rewrites, 8 major updates, 16 partial updates, and 7 new pages needed. Co-Authored-By: Claude Opus 4.6 (1M context) --- SOLANA_MIGRATION_AUDIT.md | 708 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 708 insertions(+) create mode 100644 SOLANA_MIGRATION_AUDIT.md diff --git a/SOLANA_MIGRATION_AUDIT.md b/SOLANA_MIGRATION_AUDIT.md new file mode 100644 index 000000000..2ea9242b8 --- /dev/null +++ b/SOLANA_MIGRATION_AUDIT.md @@ -0,0 +1,708 @@ +# AR.IO Documentation — Solana Migration Audit + +This document catalogs every page in `docs.ar.io` that needs updating to reflect the AR.IO Network migration from AO to Solana. It is organized by priority tier, with specific references and recommended actions for each file. + +--- + +## How to Use This Document + +- **Priority tiers** indicate suggested sequencing, not importance. All changes are required before public launch. +- **Action types**: `FULL REWRITE` = page premise changes; `MAJOR UPDATE` = significant sections change; `PARTIAL UPDATE` = targeted edits; `MINOR UPDATE` = terminology swaps; `NO CHANGE` = content is chain-agnostic. +- **References** cite the Solana migration docs (`BEHAVIORAL_DIFFERENCES.md`, `WHITEPAPER_SOLANA_CHANGES.md`, `FEATURE_MATRIX.md`, `WORKFLOWS.md`) for traceability. + +--- + +## Tier 1 — CRITICAL (Core Identity & Getting Started) + +These pages define what AR.IO *is* to new visitors. Incorrect information here undermines trust immediately. + +### 1. `content/learn/token/index.mdx` — FULL REWRITE + +**Current state:** Positions ARIO as "the multifunction AO Computer based token." The entire "Built on AO Computer" section (lines 67-87) describes AO-based architecture, computational permanence, and AO ecosystem integration. + +**What changes:** +- ARIO is now an SPL Token on Solana (mint address TBD for docs) +- Remove all "Native AO Token" and "AO Computer" framing +- Key features should reference: SPL Token standard, Solana program execution, Solana wallet ecosystem (Phantom, Solflare, Backpack) +- Staking and multi-utility descriptions remain conceptually valid but need Solana framing +- Token decimals unchanged (6 decimals, 1 ARIO = 1,000,000 mARIO) + +**Action:** Full rewrite. New positioning: "ARIO is the native token of the ar.io network, implemented as an SPL Token on Solana." + +--- + +### 2. `content/learn/token/architecture.mdx` — FULL REWRITE + +**Current state:** Describes ARIO smart contract on AO with mermaid diagram showing "External AO Processes" including ANT Registry and ANT processes. + +**What changes:** +- Architecture is now 3+1 Solana programs: ario-core, ario-gar, ario-arns, ario-ant +- CPI flow: ario-gar and ario-arns call into ario-core for token operations +- ANTs are Metaplex Core NFTs (not AO processes) +- Zero-copy registries: GatewayRegistry (3,000 slots), NameRegistry (50,000 slots) +- Mermaid diagram needs complete redesign showing Solana programs + CPI arrows + +**Action:** Full rewrite with new architecture diagram. + +--- + +### 3. `content/learn/token/get-the-token.mdx` — FULL REWRITE + +**Current state:** Two-tab layout (AO canonical / Base bridged). AO tab references contract ID `qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE`, Permaswap DEX, Wander wallet for AO, and testnet process IDs. + +**What changes:** +- Canonical ARIO is now on Solana (new mint address, Solana explorers) +- DEX access: Jupiter, Raydium (replace Permaswap) +- Wallet support: Phantom, Solflare, Backpack (replace Wander for AO) +- Base bridged ARIO status TBD (may still exist as secondary) +- Testnet: Solana devnet faucet replaces AO testnet process +- All contract/process IDs change completely + +**Action:** Full rewrite. Restructure tabs as Solana (canonical) / Base (bridged, if retained). + +--- + +### 4. `content/learn/token/add-to-wander.mdx` — FULL REWRITE or REPLACE + +**Current state:** Step-by-step guide for adding AO-based ARIO to Wander wallet with process ID `qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE`. + +**What changes:** +- ARIO is now an SPL Token — Solana wallets auto-detect it (no manual "add token" step for most wallets) +- Guide should cover: Phantom/Solflare setup, viewing ARIO balance, ARIO mint address +- Wander guide may still be relevant if Wander adds Solana support, otherwise replace entirely + +**Action:** Replace with "Add ARIO to Your Wallet" covering Solana wallets. If Wander supports Solana, include it as one option. + +--- + +### 5. `content/learn/(introduction)/what-is-ario.mdx` — MAJOR UPDATE + +**Current state:** "A decentralized infrastructure layer built on Arweave and AO." + +**What changes:** +- Remove "and AO" from the foundational description +- ar.io still serves Arweave data (gateway role unchanged) but protocol execution is on Solana +- Update to: "built on Arweave for permanent data storage, with protocol execution on Solana" + +**Action:** Update foundational description and any AO references. Core value proposition (decentralized gateways, permanent data) stays. + +--- + +### 6. `content/sdks/ar-io-sdk/(ario-contract)/configuration.mdx` — FULL REWRITE + +**Current state:** Shows `AOProcess` class, `@permaweb/aoconnect` import, AO infrastructure URLs (MU_URL, CU_URL, GRAPHQL_URL). + +**What changes:** +- SDK now defaults to Solana backend (`SolanaARIOReadable` / `SolanaARIOWriteable`) +- `ARIO.init()` with no args → Solana mainnet RPC +- `ARIO.init({ process: '...' })` → AO backend (legacy, opt-in) +- Configuration is now RPC URL + optional Solana connection params +- `AOProcess`, `@permaweb/aoconnect` → legacy only, not default examples + +**Action:** Full rewrite showing Solana-first configuration. Add legacy AO section for backwards compatibility. + +--- + +### 7. `content/sdks/ar-io-sdk/(ario-contract)/networks.mdx` — MAJOR UPDATE + +**Current state:** References `ARIO_MAINNET_PROCESS_ID`, `ARIO_TESTNET_PROCESS_ID`, `ARIO_DEVNET_PROCESS_ID`. Testnet faucet references "ar.io Testnet process (tARIO)." + +**What changes:** +- Process IDs → Solana program addresses +- Testnet → Solana devnet +- `ARIO.mainnet()` / `ARIO.testnet()` now connect to Solana clusters +- Faucet mechanism changes (Solana devnet airdrop vs AO testnet) + +**Action:** Update all process ID terminology, network references, and faucet documentation. + +--- + +### 8. `content/build/run-a-gateway/manage/environment-variables.mdx` — MAJOR UPDATE + +**Current state:** Contains `IO_PROCESS_ID` defaulting to AO process ID. Entire "AO (Autonomous Objects)" section (lines 233-242) with `AO_CU_URL`, `NETWORK_AO_CU_URL`, `ANT_AO_CU_URL`, `AO_MU_URL`, `AO_GATEWAY_URL`, `AO_GRAPHQL_URL`. Observer section also references these. + +**What changes:** +- `IO_PROCESS_ID` → Solana program address (or replaced with `ARIO_PROGRAM_ID`) +- Entire AO section → replaced with Solana RPC configuration (`SOLANA_RPC_URL`, program addresses) +- Circuit breaker variables prefixed `ARIO_PROCESS_*` → update naming +- Observer contract interaction variables → Solana transaction submission + +**Action:** Major update. Replace AO infrastructure block with Solana RPC configuration. Update all process ID defaults. + +--- + +### 9. `content/build/run-a-gateway/join-the-network.mdx` — MAJOR UPDATE + +**Current state:** CLI examples use `--wallet-file ./path/to/wallet.json` (Arweave JWK), mARIO amounts, Arweave wallet addresses. References Wander/Metamask/Beacon wallet connections. `IO_PROCESS_ID` referenced. + +**What changes:** +- Wallet format: Solana keypair (Ed25519) replaces Arweave JWK (RSA-4096) +- Wallet options: Phantom, Solflare, Backpack (replace Wander for signing) +- CLI flags: `--rpc-url` for Solana RPC, `--ao` flag for legacy +- Observer wallet: Solana pubkey format +- Token amounts: Still mARIO (decimals unchanged), but SOL needed for transaction fees + +**Action:** Major update. New wallet setup instructions, updated CLI examples, note about SOL for fees. + +--- + +### 10. `content/learn/gateways/gateway-registry.mdx` — MAJOR UPDATE + +**Current state:** References "registered Arweave wallet addresses" stored in the smart contract. + +**What changes:** +- Wallet addresses are now Solana pubkeys (Ed25519, not RSA) +- Gateway registry capped at 3,000 slots (new constraint) +- Observer address must be unique across all gateways (new constraint) +- Pruning: 30 consecutive failed epochs → 100% minimum stake slashed (new mechanic) + +**Action:** Update wallet address references, add capacity limits, document observer uniqueness and pruning. + +--- + +## Tier 2 — HIGH (SDK, ArNS & Staking Mechanics) + +These pages are used by developers building on ar.io and operators managing gateways. + +### 11. `content/sdks/ar-io-sdk/index.mdx` — PARTIAL UPDATE + +**Current state:** References "AO contract operations" in description. + +**What changes:** +- Remove "AO contract operations" → "Solana program interactions" (or just "ar.io protocol") +- Code examples structurally unchanged (`ARIO.mainnet()`, method calls) +- Note that SDK abstracts the backend — same API, Solana underneath + +**Action:** Update description text. Code examples remain valid. + +--- + +### 12. `content/sdks/ar-io-sdk/token-conversion.mdx` — PARTIAL UPDATE + +**Current state:** "The ARIO process stores all values as mARIO" and "All process interactions expect values in mARIO." + +**What changes:** +- "ARIO process" → "ARIO program" or "ARIO protocol" +- "process interactions" → "protocol operations" +- Conversion logic (mARIO ↔ ARIO) unchanged + +**Action:** Terminology swap. Logic unchanged. + +--- + +### 13. `content/sdks/ar-io-sdk/(ario-contract)/general.mdx` — PARTIAL UPDATE + +**Current state:** Signer examples show `ArConnectSigner` and `ArweaveSigner` exclusively. + +**What changes:** +- Add Solana signer examples (Phantom wallet adapter, Solana keypair) +- Arweave signers remain valid for legacy AO backend +- Default examples should show Solana-first + +**Action:** Add Solana signer examples as primary. Move Arweave signers to "Legacy AO Backend" section. + +--- + +### 14. `content/sdks/ar-io-sdk/(ario-contract)/arweave-name-system-arns.mdx` — PARTIAL UPDATE + +**Current state:** Line 62 references "ANT process spawned." Callback events reference AO-specific lifecycle (`spawning-ant`, `registering-ant`). + +**What changes:** +- ANT is now a Metaplex Core NFT (minted, not "spawned as process") +- Callback events may use different names for Solana flow +- `processId` parameter → ANT mint address on Solana + +**Action:** Update terminology (process → NFT mint), verify callback event names match Solana SDK. + +--- + +### 15. `content/sdks/ar-io-sdk/(ant-contracts)/initialize.mdx` — PARTIAL UPDATE + +**Current state:** `processId` parameter shown for AO process initialization. + +**What changes:** +- `processId` → Solana mint address of the Metaplex Core NFT +- Add `backend: 'solana'` parameter example +- `ANT.init({ backend: 'solana', processId, connection })` → Solana ANT + +**Action:** Update initialization examples to show Solana-first, legacy AO second. + +--- + +### 16. `content/sdks/ar-io-sdk/(ant-contracts)/spawn.mdx` — PARTIAL UPDATE + +**Current state:** "Spawns a new ANT process on the AO network." + +**What changes:** +- "AO network" → "Solana" (ANT is minted as Metaplex Core NFT) +- "Spawns" → "Creates" or "Mints" +- Underlying SDK call may be different + +**Action:** Update blockchain reference and creation terminology. + +--- + +### 17. `content/sdks/ar-io-sdk/(ant-contracts)/static-methods.mdx` — PARTIAL UPDATE + +**Current state:** `ANT.fork()` spawns new ANT processes. References `ARIO_MAINNET_PROCESS_ID`. + +**What changes:** +- Fork → creates new Solana NFT +- Process ID constants → Solana program addresses + +**Action:** Update terminology and constant references. + +--- + +### 18. `content/sdks/ar-io-sdk/(ant-contracts)/upgrade.mdx` — PARTIAL UPDATE + +**Current state:** References "ARIO process ID" and "ANT registry process ID." + +**What changes:** +- Process IDs → Solana program addresses +- Upgrade mechanism differs (Metaplex Core NFT schema versioning via `migrate_ant` with `realloc`) + +**Action:** Update terminology and explain new upgrade mechanism. + +--- + +### 19. `content/sdks/ar-io-sdk/(ant-contracts)/transfer.mdx` — MINOR UPDATE + +**Current state:** "Target MUST be an Arweave address." + +**What changes:** +- Target must be a Solana address (for Solana backend) +- ANT transfers are Metaplex Core NFT transfers + +**Action:** Update address format requirement. + +--- + +### 20. `content/sdks/ar-io-sdk/(ant-contracts)/ario-integrations.mdx` — PARTIAL UPDATE + +**Current state:** References `ARIO_MAINNET_PROCESS_ID` (lines 15, 28, 43, 56). + +**What changes:** +- Process ID constants → Solana program addresses + +**Action:** Update all constant references. + +--- + +### 21. `content/learn/arns/ants.mdx` — MAJOR UPDATE + +**Current state:** "Name Tokens are unique AO Computer based tokens/processes." "Each ANT is its own AO process with autonomous functionality." + +**What changes:** +- ANTs are Metaplex Core NFTs on Solana +- Tradeable on Tensor, Magic Eden (NFT marketplaces) +- Max 10 controllers per ANT (was unlimited) +- @ record cannot be removed (only updated) +- Lazy reconciliation on marketplace transfer (controllers cleared on next write) +- No "AO process" — it's an NFT with on-chain state in a PDA + +**Action:** Major update. Reframe ANTs from AO processes to Solana NFTs. Document new constraints and marketplace compatibility. + +--- + +### 22. `content/learn/arns/index.mdx` — PARTIAL UPDATE + +**Current state:** "Registry is stored permanently on Arweave via AO." + +**What changes:** +- Registry is now on Solana (NameRegistry zero-copy account, 50,000 slots) +- ArNS resolution mechanism unchanged for end users +- Mermaid diagram references "ar.io Smart Contract" → now Solana programs + +**Action:** Update storage layer reference and diagram. + +--- + +### 23. `content/learn/arns/name-registration.mdx` — PARTIAL UPDATE + +**Current state:** Registration rules, pricing, lease mechanics. + +**What changes:** +- New: 43-character names prohibited (Arweave TX ID collision prevention) +- New: Lowercase enforced at submission (not auto-lowercased) +- Registry capped at 50,000 names +- Returned name Dutch auction: 50x→1x over 14 days, 50%/50% revenue split +- Grace period: 14 days (unchanged but now in seconds) + +**Action:** Add new validation rules, capacity limits, and returned name auction mechanics. + +--- + +### 24. `content/learn/token/staking.mdx` — PARTIAL UPDATE + +**Current state:** Staking mechanics for operators and delegators. + +**What changes:** +- Operator rewards always auto-compound (no toggle — must `decrease_operator_stake` to realize) +- Delegate rewards use reward-per-share accumulator (not instant distribution) +- Operator cannot self-delegate +- Redelegation fee resets after 7 days (wall-clock, not epoch count) +- Gateway cap: 3,000 (registry can fill) +- Expedited withdrawal penalty: linear decay 50%→10% over 90 days + +**Action:** Update reward mechanics, add new constraints, document expedited withdrawal formula. + +--- + +### 25. `content/learn/oip/reward-distribution.mdx` — PARTIAL UPDATE + +**Current state:** Reward distribution formulas using ARIO. + +**What changes:** +- 6-step epoch pipeline (create → tally → prescribe → save observations → distribute → close) +- Operator rewards auto-compound; delegate rewards use accumulator pattern +- Missed observation penalty: 25% reduction +- Leaving gateways receive 0 rewards +- Reward rate: linear decay 0.1%→0.05% over epochs 365-547 + +**Action:** Update reward flow to reflect 6-step pipeline and accumulator pattern. + +--- + +### 26. `content/build/guides/working-with-arns/register-arns-programmatically.mdx` — MAJOR UPDATE + +**Current state:** SDK initialization with `ArweaveSigner(jwk)`, `processId` in registration. + +**What changes:** +- Signer: Solana keypair or wallet adapter (not Arweave JWK) +- `processId` → ANT mint address (Solana Metaplex Core NFT) +- `ARIO.mainnet()` default is now Solana +- Gateway operator discount: now enforced (180+ day tenure, 90%+ pass rate, status=Joined) + +**Action:** Update all code examples for Solana signers, update processId references. + +--- + +### 27. `content/build/guides/working-with-arns/set-arns-records-programmatically.mdx` — MAJOR UPDATE + +**Current state:** ANT initialization with AO process patterns. + +**What changes:** +- ANT init: `ANT.init({ backend: 'solana', processId: mintAddress, connection })` +- Signer: Solana wallet adapter +- Transaction IDs for records remain Arweave TX IDs (unchanged — records still point to Arweave data) + +**Action:** Update SDK initialization examples and signer patterns. + +--- + +### 28. `content/build/run-a-gateway/quick-start.mdx` — PARTIAL UPDATE + +**Current state:** `AR_IO_WALLET=`, `OBSERVER_WALLET=`. + +**What changes:** +- Wallet addresses are now Solana pubkeys +- Observer wallet: unique constraint (no two gateways share observer address) +- SOL needed in wallet for transaction fees (in addition to ARIO for staking) + +**Action:** Update wallet format references, add SOL fee note. + +--- + +## Tier 3 — MEDIUM (Conceptual & Reference Pages) + +### 29. `content/learn/arns/pricing-model.mdx` — MINOR UPDATE + +**Current state:** Pricing formulas in ARIO. + +**What changes:** +- Fee halving: when demand factor stays at minimum (0.5x) for 7 consecutive periods, all base fees permanently halved (new mechanism) +- `get_token_cost` view instruction available for cost simulation + +**Action:** Add fee halving note and cost simulation reference. + +--- + +### 30. `content/learn/oip/index.mdx` — MINOR UPDATE + +**Current state:** "Distribute ARIO token rewards automatically." + +**What changes:** +- Rewards not "automatic" — requires cranker bot to drive 6-step pipeline +- Add reference to permissionless cranker role + +**Action:** Minor wording update to reflect cranker-driven distribution. + +--- + +### 31. `content/learn/oip/observer-selection.mdx` — MINOR UPDATE + +**Current state:** Weighted random selection with hashchain entropy. + +**What changes:** +- Entropy source: `SHA256(slot || epoch_index || timestamp)` (Solana-specific) +- Up to 50 observers per epoch +- 4-factor composite weight: stake, tenure, gateway performance, observer performance +- Collision handling: 10x retry multiplier (up to 500 iterations) + +**Action:** Update entropy source description and add Solana-specific details. + +--- + +### 32. `content/learn/(introduction)/permaweb.mdx` — NO CHANGE + +AO is correctly described as the compute layer in the permaweb stack. This remains true — AO still exists for compute; ar.io protocol execution moved to Solana. The permaweb description is about the broader ecosystem, not ar.io specifically. + +--- + +### 33. `content/sdks/ar-io-sdk/(ario-contract)/epochs.mdx` — MINOR UPDATE + +**Current state:** Epoch API responses and examples. + +**What changes:** +- Response structure may include new fields (6-step pipeline status) +- Core epoch data (observations, rewards) structurally similar + +**Action:** Verify response examples match Solana epoch structure. Update if fields changed. + +--- + +### 34. `content/sdks/ar-io-sdk/(ario-contract)/gateways.mdx` — MINOR UPDATE + +**Current state:** Gateway operations using Arweave signers in examples. + +**What changes:** +- Add Solana signer examples +- Address format in examples should show Solana pubkeys +- All gateway methods (join, leave, update, stake, delegate) remain functionally identical + +**Action:** Update signer examples, add Solana address format in outputs. + +--- + +### 35. `content/sdks/ar-io-sdk/(ario-contract)/primary-names.mdx` — MINOR UPDATE + +**Current state:** Primary name operations. + +**What changes:** +- Fee: 0.2 ARIO × demand_factor +- Two flows: direct set vs async request/approve +- Request expires after 7 days +- Uniqueness enforced by PrimaryNameReverse PDA + +**Action:** Verify fee and flow documentation matches new mechanics. + +--- + +### 36. `content/sdks/ar-io-sdk/(ario-contract)/vaults.mdx` — MINOR UPDATE + +**Current state:** Vault operations. + +**What changes:** +- Minimum vault size: 100 ARIO (new constraint) +- Duration: 14 days – 200 years +- Revoke: strict `<` check (cannot revoke at exact expiry) + +**Action:** Add minimum size constraint if not already documented. + +--- + +### 37. `content/sdks/ar-io-sdk/pagination.mdx` — PARTIAL UPDATE + +**Current state:** Pagination patterns for SDK queries. + +**What changes:** +- On-chain pagination removed on Solana +- SDK pagination now uses off-chain indexer (Helius DAS or custom) +- Zero-copy registries available for direct enumeration but not paginated + +**Action:** Update to reflect off-chain pagination model. + +--- + +### 38. `content/glossary/index.mdx` — PARTIAL UPDATE + +**Current state:** "AO Computer... provides the compute layer for ar.io's smart contracts and token operations." + +**What changes:** +- AO no longer provides compute for ar.io contracts — Solana does +- AO definition should remain (it's still a real thing) but ar.io-specific claim must be removed +- Add Solana-specific terms: PDA, SPL Token, Metaplex Core, CPI, Cranker + +**Action:** Update AO definition, add Solana glossary entries. + +--- + +### 39. `content/build/guides/working-with-arns/index.mdx` — MINOR UPDATE + +**Current state:** "The smart contract system that manages ArNS name ownership." + +**What changes:** +- "Smart contract" → "Solana program" (ario-arns) +- ANT description → Metaplex Core NFT + +**Action:** Terminology update. + +--- + +### 40. `content/build/guides/working-with-arns/manage-arns-ui.mdx` — PARTIAL UPDATE + +**Current state:** UI-based ArNS management guide. + +**What changes:** +- Wallet connection: Solana wallet (Phantom etc.) instead of Arweave wallet +- UI may look different with Solana backend +- Screenshots may need updating + +**Action:** Update wallet instructions and verify screenshots. + +--- + +### 41. `content/build/guides/working-with-arns/purchase-arns-ui.mdx` — PARTIAL UPDATE + +**Current state:** UI-based ArNS purchase guide. + +**What changes:** +- Same wallet/UI changes as manage-arns-ui.mdx +- Payment: ARIO from Solana wallet + SOL for fees + +**Action:** Update wallet and payment instructions. + +--- + +### 42. `content/build/guides/arns-marketplace.mdx` — MAJOR UPDATE + +**Current state:** ANT trading and marketplace explanation. + +**What changes:** +- ANTs are now Metaplex Core NFTs — tradeable on Tensor, Magic Eden +- Lazy reconciliation: marketplace transfer clears controllers on next write +- Standard NFT marketplace UX (no special ar.io marketplace needed) + +**Action:** Rewrite marketplace section for NFT marketplace integration. + +--- + +## Tier 4 — LOW (Minimal or No Changes) + +### Pages requiring NO CHANGES (chain-agnostic content): + +| File | Reason | +|------|--------| +| `content/learn/gateways/architecture.mdx` | Gateway tech stack is chain-agnostic | +| `content/learn/gateways/data-retrieval.mdx` | Data retrieval from Arweave, not chain-specific | +| `content/learn/gateways/data-verification.mdx` | Merkle verification, chain-agnostic | +| `content/learn/gateways/index.mdx` | Conceptual gateway overview | +| `content/learn/gateways/x402-payments.mdx` | USDC on Base, independent of ARIO chain | +| `content/learn/oip/performance-evaluation.mdx` | Weight calculations, implementation-agnostic | +| `content/learn/oip/reporting.mdx` | Reporting mechanics, chain-agnostic | +| `content/learn/(introduction)/what-is-arweave.mdx` | Arweave storage layer description | +| `content/learn/(introduction)/ans-104-bundles.mdx` | Bundle standard, protocol-agnostic | +| `content/learn/(introduction)/index.mdx` | Navigation page | +| `content/learn/wayfinder/*` | Routing infrastructure, chain-agnostic | +| `content/build/access/fetch-data.mdx` | Data fetching from Arweave | +| `content/build/access/find-data.mdx` | Data discovery | +| `content/build/upload/*` | Upload to Arweave via Turbo (independent) | +| `content/build/extensions/*` | Gateway extensions (Grafana, ClickHouse, etc.) | +| `content/build/advanced/*` | ArFS, sandboxing, normalized addresses | +| `content/build/run-a-gateway/manage/ssl-certs.mdx` | Infrastructure config | +| `content/build/run-a-gateway/manage/content-moderation.mdx` | Gateway policy | +| `content/build/run-a-gateway/manage/troubleshooting.mdx` | General troubleshooting | +| `content/build/run-a-gateway/manage/upgrading-a-gateway.mdx` | Node upgrades | +| `content/build/run-a-gateway/manage/setting-apex-domain.mdx` | DNS config | +| `content/build/run-a-gateway/manage/index-snapshots.mdx` | Index management | +| `content/build/run-a-gateway/manage/cdb64.mdx` | Database index | +| `content/build/run-wayfinder-router/*` | Router config, chain-agnostic | +| `content/build/guides/hosting-decentralised-apps/*` | Deployment guides | +| `content/build/guides/using-turbo-in-a-browser/*` | Turbo integration | +| `content/build/guides/depin.mdx` | DePIN concepts | +| `content/build/guides/application-distribution.mdx` | App distribution | +| `content/build/guides/encrypted-data-nillion.mdx` | Encryption guide | +| `content/build/guides/crossmint-nft-minting-app.mdx` | NFT minting | +| `content/build/guides/storing-nfts.mdx` | NFT storage | +| `content/apis/ar-io-node/*` | Gateway API endpoints (chain-agnostic) | +| `content/apis/turbo/*` | Turbo service APIs | +| `content/sdks/turbo-sdk/*` | Turbo SDK (already has Solana signer) | +| `content/sdks/ardrive-core-js/*` | ArDrive SDK | +| `content/sdks/(clis)/ardrive-cli/*` | ArDrive CLI | +| `content/sdks/wayfinder/*` | Wayfinder SDK | +| `content/sdks/ar-io-sdk/(ant-contracts)/metadata.mdx` | ANT metadata ops | +| `content/sdks/ar-io-sdk/(ant-contracts)/records.mdx` | ANT record ops | +| `content/sdks/ar-io-sdk/(ant-contracts)/controllers.mdx` | ANT controller ops | +| `content/sdks/ar-io-sdk/(ant-contracts)/balances.mdx` | ANT balance ops | +| `content/sdks/ar-io-sdk/(ant-contracts)/state.mdx` | ANT state queries | +| `content/sdks/ar-io-sdk/(ant-contracts)/undername-ownership.mdx` | Undername ops | +| `content/sdks/ar-io-sdk/(ant-contracts)/versions.mdx` | ANT versions | +| `content/sdks/ar-io-sdk/logging.mdx` | SDK logging config | + +--- + +## New Content Needed + +These pages don't exist yet and should be created for the Solana migration: + +### New Pages + +1. **`content/learn/token/migration.mdx`** — Migration guide: Arweave→Solana address attestation, import-then-claim flow, wallet mapping +2. **`content/learn/token/solana-wallets.mdx`** — How to set up Phantom/Solflare/Backpack for ARIO (replaces add-to-wander.mdx) +3. **`content/learn/oip/epoch-pipeline.mdx`** — 6-step epoch pipeline overview (create → tally → prescribe → observe → distribute → close) +4. **`content/learn/oip/cranker.mdx`** — Permissionless cranker bot: what it does, why it matters, how to run one +5. **`content/learn/gateways/pruning.mdx`** — Gateway pruning/slashing: 30 failed epochs, stake slash, removal mechanics +6. **`content/learn/arns/returned-names.mdx`** — Returned name Dutch auction: 50x→1x decay, revenue split, lifecycle phases +7. **`content/build/guides/working-with-arns/arns-on-nft-marketplaces.mdx`** — Buying/selling ArNS names on Tensor, Magic Eden via Metaplex Core NFTs + +### New Glossary Entries + +- **SPL Token** — Solana Program Library token standard (ARIO is an SPL Token) +- **PDA (Program Derived Address)** — Deterministic Solana account addresses derived from program seeds +- **Metaplex Core** — NFT standard used for ANTs on Solana +- **CPI (Cross-Program Invocation)** — How Solana programs call each other +- **Cranker** — Permissionless bot that drives the epoch pipeline +- **Epoch Pipeline** — 6-step process for observation, reward calculation, and distribution +- **Reward Accumulator** — Pattern for distributing delegate rewards (settled on interaction) + +--- + +## Key Terminology Changes (Global Find & Replace) + +These terms should be updated consistently across ALL documentation: + +| Old Term | New Term | Context | +|----------|----------|---------| +| AO Computer based token | SPL Token on Solana | Token description | +| AO process | Solana program | Contract references | +| process ID | program address / mint address | Identifiers | +| smart contract (singular) | Solana programs (3+1) | Architecture | +| Arweave wallet address | Solana wallet address | User identifiers | +| Wander wallet | Phantom / Solflare / Backpack | Wallet recommendations | +| `AOProcess` | `SolanaARIOReadable` / legacy | SDK classes | +| `@permaweb/aoconnect` | `@solana/web3.js` | SDK dependencies | +| `ArweaveSigner` / `ArConnectSigner` | Solana wallet adapter | Default signers | +| spawned (ANT) | minted (ANT as NFT) | ANT creation | +| ANT process | ANT (Metaplex Core NFT) | ANT references | + +--- + +## Cross-Cutting Concerns + +### Time Units +All durations in documentation that reference protocol timings should use seconds (not milliseconds). The SDK handles conversion transparently, but any raw protocol references should note seconds. + +### SOL Fee Requirement +Any page that documents an ARIO-spending operation should note that SOL is also required for Solana transaction fees. This is a new concept for users coming from AO (where fees were abstracted). + +### Dual-Backend Period +During the transition period, documentation should acknowledge the `--ao` flag / AO backend option for legacy compatibility, while making Solana the default in all examples. + +### Screenshots & UI +Any screenshots of arns.app, the gateway management portal, or wallet interfaces will need updating to show Solana wallet connections and Solana-based interfaces. + +--- + +## Summary Statistics + +| Category | Count | +|----------|-------| +| **Full Rewrite** | 6 pages | +| **Major Update** | 8 pages | +| **Partial Update** | 16 pages | +| **Minor Update** | 8 pages | +| **No Change** | ~65 pages | +| **New Pages Needed** | 7 pages | +| **New Glossary Entries** | 7 entries | +| **Total pages audited** | ~97 pages | From 83676d4aa00718ee3094b50348a8093477d1ef7e Mon Sep 17 00:00:00 2001 From: Philip Mataras Date: Wed, 29 Apr 2026 11:13:15 -0400 Subject: [PATCH 02/53] docs: migrate all documentation from AO to Solana Complete documentation migration reflecting ar.io's protocol execution move from AO (Arweave compute) to Solana. The ARIO token is now an SPL Token, ANTs are Metaplex Core NFTs, and epochs are driven by a permissionless 6-step cranker pipeline. Changes across 63 files (255 pages audited): Rewritten (7): token overview, architecture, get-the-token, staking, SDK configuration, networks, general New pages (6): wallet setup, migration guide, epoch pipeline, cranker, gateway pruning, returned name auctions Deleted (2): AO compute-unit extension, add-to-wander guide Updated (48): ArNS docs (ANTs as Metaplex Core NFTs, 50K name cap, Dutch auctions), gateway registry (3K cap, observer uniqueness, pruning), OIP (Solana Programs terminology, reward accumulator, on-chain observations), SDK examples (Solana signers via @solana/kit, removed ArweaveSigner from all ar.io SDK code examples), environment variables (removed AO sections, added Solana RPC), turbo-credits (ARIO on Solana), join-the-network (Solana keypair CLI), glossary (7 new Solana terms) Co-Authored-By: Claude Opus 4.6 (1M context) --- CLAUDE.md | 176 +++++---- MIGRATION_STATUS.md | 305 +++++++++++++++ .../build/advanced/normalized-addresses.mdx | 2 +- content/build/extensions/bundler.mdx | 6 - content/build/extensions/clickhouse.mdx | 6 - content/build/extensions/compute-unit.mdx | 364 ------------------ content/build/extensions/grafana.mdx | 6 - content/build/extensions/index.mdx | 3 - content/build/extensions/meta.json | 2 +- content/build/guides/arns-marketplace.mdx | 45 ++- .../build/guides/working-with-arns/index.mdx | 4 +- .../register-arns-programmatically.mdx | 18 +- .../set-arns-records-programmatically.mdx | 16 +- .../build/run-a-gateway/join-the-network.mdx | 16 +- .../manage/environment-variables.mdx | 37 +- .../build/run-a-gateway/manage/filters.mdx | 6 - content/build/upload/turbo-credits.mdx | 13 +- content/glossary/index.mdx | 34 +- content/learn/(introduction)/what-is-ario.mdx | 2 +- content/learn/arns/ants.mdx | 16 +- content/learn/arns/index.mdx | 16 +- content/learn/arns/meta.json | 2 +- content/learn/arns/name-registration.mdx | 10 +- content/learn/arns/pricing-model.mdx | 4 +- content/learn/arns/returned-names.mdx | 76 ++++ content/learn/gateways/gateway-registry.mdx | 11 +- content/learn/gateways/index.mdx | 4 +- content/learn/gateways/meta.json | 1 + content/learn/gateways/pruning.mdx | 55 +++ content/learn/oip/cranker.mdx | 62 +++ content/learn/oip/epoch-pipeline.mdx | 99 +++++ content/learn/oip/index.mdx | 12 +- content/learn/oip/meta.json | 2 + content/learn/oip/observer-selection.mdx | 4 +- content/learn/oip/performance-evaluation.mdx | 12 +- content/learn/oip/reporting.mdx | 8 +- content/learn/oip/reward-distribution.mdx | 21 +- content/learn/token/add-to-wander.mdx | 161 -------- content/learn/token/architecture.mdx | 175 +++++---- content/learn/token/get-the-token.mdx | 50 +-- content/learn/token/index.mdx | 61 +-- content/learn/token/meta.json | 3 +- content/learn/token/migration.mdx | 123 ++++++ content/learn/token/staking.mdx | 43 ++- content/learn/token/wallets.mdx | 107 +++++ .../(ant-contracts)/ario-integrations.mdx | 10 +- .../ar-io-sdk/(ant-contracts)/initialize.mdx | 12 +- .../sdks/ar-io-sdk/(ant-contracts)/spawn.mdx | 33 +- .../(ant-contracts)/static-methods.mdx | 20 +- .../ar-io-sdk/(ant-contracts)/transfer.mdx | 2 +- .../(ant-contracts)/undername-ownership.mdx | 2 +- .../ar-io-sdk/(ant-contracts)/upgrade.mdx | 5 +- .../arweave-name-system-arns.mdx | 14 +- .../(ario-contract)/configuration.mdx | 25 +- .../sdks/ar-io-sdk/(ario-contract)/epochs.mdx | 2 +- .../ar-io-sdk/(ario-contract)/gateways.mdx | 25 +- .../ar-io-sdk/(ario-contract)/general.mdx | 27 +- .../ar-io-sdk/(ario-contract)/networks.mdx | 21 +- .../(ario-contract)/primary-names.mdx | 5 +- .../sdks/ar-io-sdk/(ario-contract)/vaults.mdx | 10 +- content/sdks/ar-io-sdk/index.mdx | 6 +- content/sdks/ar-io-sdk/token-conversion.mdx | 4 +- content/sdks/index.mdx | 2 +- 63 files changed, 1395 insertions(+), 1029 deletions(-) create mode 100644 MIGRATION_STATUS.md delete mode 100644 content/build/extensions/compute-unit.mdx create mode 100644 content/learn/arns/returned-names.mdx create mode 100644 content/learn/gateways/pruning.mdx create mode 100644 content/learn/oip/cranker.mdx create mode 100644 content/learn/oip/epoch-pipeline.mdx delete mode 100644 content/learn/token/add-to-wander.mdx create mode 100644 content/learn/token/migration.mdx create mode 100644 content/learn/token/wallets.mdx diff --git a/CLAUDE.md b/CLAUDE.md index e3a631485..1dad44878 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -1,78 +1,112 @@ -# CLAUDE.md - Repository Assistant Guide +# CLAUDE.md + +This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository. ## Repository Overview -This is the ar-io/docs repository, which manages the documentation for the ar.io Developer Platform. It references various services, SDKs and tools for building on and with ar.io. It also includes documentation for interacting with ArDrive - a flagship consumer dApp that stores data on Arweave. + +Documentation site for the ar.io Developer Platform, covering services, SDKs, and tools for building on ar.io and Arweave. Built with [Fumadocs](https://fumadocs.dev/) on Next.js. Live site: [docs.ar.io](https://docs.ar.io) + +## Key Commands + +```bash +npm run dev # Start dev server (uses Turbo, standalone mode) +npm run build # Production build (static export to out/) +npm run lint # ESLint (src/ and content/, .ts/.tsx/.mdx) +npx tsc --noEmit # TypeScript type checking +npm run check-links # Validate internal/external links + +# Content generation +npm run generate-api-docs # Generate OpenAPI docs from ar-io-node + turbo services +npm run generate-sdk-docs # Generate SDK reference from external repo READMEs +npm run generate-llm-text # Generate public/llms-full.txt +npm run generate-sdk-llm-texts # Generate per-SDK llm.txt files +npm run generate-all-docs # Run all generation scripts (except API docs) +``` + +Note: The `postinstall` script runs `fumadocs-mdx` to generate the `.source/` directory (content type definitions and index). This must run before the dev server or build will work. If `.source/` is missing, run `npm install` or `npx fumadocs-mdx`. ## Architecture -This repository is built with [Fumadocs](https://fumadocs.dev/), a documentation framework. The general architecture is as follows: -### UI Components -All UI should use Fumadocs available UI components by default. This ensures consistency with the framework's design system and maintains a cohesive user experience throughout the documentation. +### Build Modes +- **Development** (`npm run dev`): Runs as standalone Next.js server with hot reload +- **Production** (`npm run build`): Static export (`output: "export"`) with trailing slashes and unoptimized images. ESLint errors are ignored during production builds. +- `redirects.mjs` contains legacy URL redirects from the old docs structure; these only work in dev mode (static export doesn't support server-side redirects) -All icons should use lucide-react for consistency across the documentation site. +### Routing +- `src/app/[[...slug]]/` - Single catch-all route handles all documentation pages +- `src/app/[[...slug]]/page.tsx` - Renders MDX content, generates static params, handles metadata/OG tags +- `src/app/api/search/route.ts` - Orama full-text search endpoint +- 404s redirect to `/learn` as a fallback -## Key Commands -- **Linting**: `npm run lint` - Run ESLint to check code quality -- **Type checking**: `npm run typecheck` - Run TypeScript type checking -- **Development server**: `npm run dev` - Start the development server -- **Build**: `npm run build` - Build the documentation site - -## Repository Structure -- `/content/` - Main documentation content - - `/content/docs/` - Core documentation pages - - `/content/api/` - API documentation - - `/content/guides/` - User guides and tutorials -- `/public/` - Static assets -- `/src/` - Source code for documentation site -- `/scripts/` - Build and utility scripts - -## Documentation Guidelines -- Documentation is written in MDX format (Markdown with JSX) -- Use semantic headings (H1 for page title, H2 for main sections, etc.) -- Include code examples with proper syntax highlighting -- Add metadata frontmatter to all documentation pages -- Follow existing documentation patterns and structure - -### Documentation Philosophy -These docs intend to model documentation sites of well-established platforms like Stripe, Coinbase, and ChatGPT - where users can natively find things logically, and patterns are consistent throughout. Key principles: -- Logical information architecture -- Consistent navigation patterns -- Clear categorization of content -- Predictable documentation structure -- User-friendly search and discovery - -## Working with OpenAPI -The repository supports OpenAPI documentation import (see recent commit 33af22f2e). When working with API documentation: -- OpenAPI specs should be properly formatted YAML or JSON -- Use the import scripts to convert OpenAPI to documentation format -- Maintain consistency with existing API documentation structure - -## Git Workflow -- Main branch: `main` -- Create feature branches for new work -- Use descriptive commit messages -- Run linting and type checking before committing - -## Community Resources -- **Discord**: https://discord.com/invite/HGG52EtTc2 - Join the ar.io community for updates and discussions - -## Important Notes -- This is a documentation repository - focus on content clarity and accuracy -- Always verify technical details match the actual ar.io implementation -- Maintain consistent terminology throughout documentation -- Test all code examples before including them in documentation - -## Recent Updates -- **Access Data Documentation**: Restructured `/content/build/access/` pages with consistent patterns: - - Updated index.mdx to show three access methods (Find Data, Fetch Data, ArNS) with enhanced cards - - Renamed and reorganized find-data.mdx (GraphQL) and fetch-data.mdx (REST API) for clarity - - Enhanced ArNS documentation with practical SDK examples - - Used native Fumadocs cards with icons for consistency - - Replaced axios with fetch API in all examples - - Added proper call-to-action sections directing users to next steps -- **Upload Data Documentation**: Enhanced `/content/build/upload/index.mdx` with native cards and clear Turbo recommendation -- **Code Standards**: - - Use `fetch` instead of `axios` for HTTP requests - - Use `ARIO.mainnet()` from '@ar.io/sdk' for ArNS operations - - Call `setRecord` on ANT instances, not ARIO instances - - ArNS undernames use underscores (e.g., `api_myapp.arweave.net`) not periods +### Content Source Pipeline +- `src/lib/source.ts` - Content loader using `fumadocs-core`'s `loader()`, with: + - OpenAPI transformer for API reference pages + - Alphabetical sorting for `build/guides` folder (via `ALPHABETICALLY_SORTED_FOLDERS`) + - Icon resolution from `meta.json` - supports Lucide icon names, SVG/PNG paths, and the special `ThemeIcon` for dark/light variants +- `.source/` (generated) - TypeScript types and content index produced by `fumadocs-mdx` +- `src/mdx-components.tsx` - All MDX components registered here, including 30+ Lucide icons available as JSX in MDX files + +### Content Organization +- `content/` - All documentation in MDX format + - `content/learn/` - Conceptual documentation (ArNS, gateways, token, etc.) + - `content/build/` - Developer guides (access data, upload, run gateway) + - `content/sdks/` - SDK documentation (ar-io-sdk, turbo-sdk, ardrive-cli, wayfinder) + - `content/apis/` - API reference (ar-io-node, turbo services) +- `content/meta.json` - Root navigation structure +- Each folder uses `meta.json` to define page order and navigation +- Parenthesized folders like `(introduction)` are route groups (removed from URL) + +### Path Aliases +- `@/*` → `./src/*` +- `@/.source` → `./.source/index.ts` (Fumadocs generated content) + +### Key Components +- **Ask Arie** (`src/components/ask-arie/`) - AI chat widget with session persistence (sessionStorage), thread management, health checks against 3 backend APIs, and citation rendering +- **Page Actions** (`src/components/page-actions.tsx`) - LLM copy button (fetches raw markdown from GitHub) and "Open in AI" dropdown (ChatGPT, Claude, etc.) +- **Search** (`src/components/search.tsx`) - Orama full-text search on a static index built at build time + +### Styling +- Tailwind CSS v4 with CSS-driven configuration (no `tailwind.config.*` file) +- Theme customization in `src/app/global.css` via `@theme` directive +- Brand colors: ar.io purple `#5427C8`, accent `#DFD6F7` + +## Code Standards + +### MDX Content +- Use Fumadocs UI components: ``, ``, ``, ``, ``, `` +- Icons from lucide-react only (imported in mdx-components.tsx) +- Frontmatter required: `title`, `description` +- Optional frontmatter: `image`, `icon`, `keywords`, `author`, `full` (full-width layout) +- Custom components available: ``, ``, ``, ``, ``, `` + +### Code Examples +- Use `fetch` instead of `axios` for HTTP requests +- Use `ARIO.mainnet()` from '@ar.io/sdk' for ArNS operations +- Call `setRecord` on ANT instances, not ARIO instances +- ArNS undernames use underscores: `api_myapp.arweave.net` (not periods) + +### Navigation +- `meta.json` files control page ordering in each directory +- Format: `{ "pages": ["page-slug", "folder-name", "..."] }` +- Use `"..."` for auto-discovery of remaining pages +- Use `"!folder-name"` to exclude a folder from navigation +- Optional fields: `"icon"` (Lucide icon name), `"defaultOpen"` (expand on load) +- `build/guides` is automatically sorted alphabetically (configured in `src/lib/source.ts`) + +## OpenAPI Integration + +The site pulls OpenAPI specs from external sources via `scripts/generate-api-docs.ts`: +- ar-io-node: `https://raw.githubusercontent.com/ar-io/ar-io-node/refs/heads/main/docs/openapi.yaml` +- turbo upload-service and payment-service + +Runtime rendering uses `src/lib/openapi.ts` which fetches the ar-io-node spec directly. Generated API docs go to `content/apis/`. Use `` component in MDX for rendering. + +## LLM Text Generation + +Scripts generate AI-friendly text files from docs: +- `public/llms-full.txt` - Complete site content +- `content/sdks/*/llm.txt` - Per-SDK content (also copied to `public/sdks/`) + +## Deployment + +The site deploys to Arweave via GitHub Actions (`.github/workflows/deploy-to-arweave.yaml`) on pushes to main. The `scripts/deploy-to-arweave.mjs` script handles the actual deployment using permaweb-deploy. diff --git a/MIGRATION_STATUS.md b/MIGRATION_STATUS.md new file mode 100644 index 000000000..b80b3f7a7 --- /dev/null +++ b/MIGRATION_STATUS.md @@ -0,0 +1,305 @@ +# Solana Migration — Documentation Page Status + +Generated 2026-04-28. Tracks every content page and its migration status from AO to Solana. + +## Legend + +- **REWRITTEN** — Full rewrite with new Solana content +- **UPDATED** — Targeted edits (terminology, code examples, references) +- **NEW** — New page created for Solana features +- **DELETED** — Removed (AO-only content) +- **NO CHANGE** — Chain-agnostic, no migration needed + +--- + +## Learn Section + +| Page | Status | Notes | +|------|--------|-------| +| `learn/(introduction)/index.mdx` | NO CHANGE | Navigation page | +| `learn/(introduction)/what-is-ario.mdx` | UPDATED | "Arweave and AO" → "Arweave + Solana" | +| `learn/(introduction)/what-is-arweave.mdx` | NO CHANGE | Arweave storage layer | +| `learn/(introduction)/permaweb.mdx` | NO CHANGE | Broader ecosystem; AO refs valid | +| `learn/(introduction)/ans-104-bundles.mdx` | NO CHANGE | Bundle standard | + +### learn/token/ + +| Page | Status | Notes | +|------|--------|-------| +| `learn/token/index.mdx` | REWRITTEN | SPL Token on Solana, new architecture section | +| `learn/token/architecture.mdx` | REWRITTEN | 3+1 programs, CPI, PDA state model, new mermaid | +| `learn/token/get-the-token.mdx` | REWRITTEN | Solana canonical, Jupiter/Raydium, Phantom/Solflare | +| `learn/token/staking.mdx` | REWRITTEN | Auto-compound, accumulator, pruning, redelegation | +| `learn/token/wallets.mdx` | NEW | Phantom/Solflare/Backpack setup (replaces add-to-wander) | +| `learn/token/migration.mdx` | NEW | Import-then-claim flow, address mapping, FAQ | +| `learn/token/add-to-wander.mdx` | DELETED | Replaced by wallets.mdx | + +### learn/arns/ + +| Page | Status | Notes | +|------|--------|-------| +| `learn/arns/index.mdx` | UPDATED | Registry on Solana, mermaid diagram, ANT=NFT | +| `learn/arns/ants.mdx` | UPDATED | Metaplex Core NFTs, 10 controller max, lazy reconciliation | +| `learn/arns/name-registration.mdx` | UPDATED | 43-char prohibition, lowercase, 50K cap, Dutch auction | +| `learn/arns/pricing-model.mdx` | UPDATED | Fee halving, cost simulation | +| `learn/arns/returned-names.mdx` | NEW | Dutch auction 50x→1x, revenue split | + +### learn/gateways/ + +| Page | Status | Notes | +|------|--------|-------| +| `learn/gateways/index.mdx` | UPDATED | Solana for protocol state, not AO | +| `learn/gateways/architecture.mdx` | NO CHANGE | Gateway tech stack | +| `learn/gateways/data-retrieval.mdx` | NO CHANGE | Data from Arweave | +| `learn/gateways/data-verification.mdx` | NO CHANGE | Merkle verification | +| `learn/gateways/gateway-registry.mdx` | UPDATED | Solana pubkeys, 3K cap, observer uniqueness, pruning | +| `learn/gateways/pruning.mdx` | NEW | 30 failed epochs → slash + removal | +| `learn/gateways/x402-payments.mdx` | NO CHANGE | USDC on Base | + +### learn/oip/ + +| Page | Status | Notes | +|------|--------|-------| +| `learn/oip/index.mdx` | UPDATED | "Smart Contract" → "Solana Programs" | +| `learn/oip/epoch-pipeline.mdx` | NEW | 6-step pipeline with timing and costs | +| `learn/oip/cranker.mdx` | NEW | Standalone + observer-embedded cranker | +| `learn/oip/observer-selection.mdx` | UPDATED | Slot-based entropy, collision handling | +| `learn/oip/reporting.mdx` | UPDATED | "Smart Contract" → "Solana programs" | +| `learn/oip/performance-evaluation.mdx` | UPDATED | "Smart Contract" → "Solana programs" | +| `learn/oip/reward-distribution.mdx` | UPDATED | 6-step pipeline, auto-compound, accumulator | + +### learn/wayfinder/ + +| Page | Status | Notes | +|------|--------|-------| +| `learn/wayfinder/index.mdx` | NO CHANGE | Routing infrastructure | +| `learn/wayfinder/integration.mdx` | NO CHANGE | Chain-agnostic | +| `learn/wayfinder/use-cases.mdx` | NO CHANGE | Chain-agnostic | + +--- + +## Build Section + +| Page | Status | Notes | +|------|--------|-------| +| `build/index.mdx` | NO CHANGE | Navigation | + +### build/access/ + +| Page | Status | Notes | +|------|--------|-------| +| `build/access/index.mdx` | NO CHANGE | | +| `build/access/arns.mdx` | NO CHANGE | Data access | +| `build/access/fetch-data.mdx` | NO CHANGE | HTTP requests | +| `build/access/find-data.mdx` | NO CHANGE | GraphQL | +| `build/access/wayfinder.mdx` | NO CHANGE | Routing | + +### build/upload/ + +| Page | Status | Notes | +|------|--------|-------| +| `build/upload/index.mdx` | NO CHANGE | | +| `build/upload/turbo-credits.mdx` | UPDATED | AO→Solana for ARIO network labels, removed AO wallets | +| `build/upload/advanced-uploading-with-turbo.mdx` | NO CHANGE | Turbo SDK | +| `build/upload/bundling-services.mdx` | NO CHANGE | | +| `build/upload/encryption.mdx` | NO CHANGE | | +| `build/upload/manifests.mdx` | NO CHANGE | | +| `build/upload/receipts.mdx` | NO CHANGE | | +| `build/upload/tagging.mdx` | NO CHANGE | | +| `build/upload/x402-uploading-to-turbo.mdx` | NO CHANGE | | + +### build/run-a-gateway/ + +| Page | Status | Notes | +|------|--------|-------| +| `build/run-a-gateway/index.mdx` | NO CHANGE | | +| `build/run-a-gateway/quick-start.mdx` | NO CHANGE | | +| `build/run-a-gateway/join-the-network.mdx` | UPDATED | Solana wallets, SOL fees, DEX refs | +| `build/run-a-gateway/manage/environment-variables.mdx` | UPDATED | Removed 2 AO sections, added Solana RPC, updated IO_PROCESS_ID | +| `build/run-a-gateway/manage/filters.mdx` | UPDATED | Removed compute-unit card link | +| `build/run-a-gateway/manage/cdb64.mdx` | NO CHANGE | Data indexing (AO refs are filter values) | +| `build/run-a-gateway/manage/content-moderation.mdx` | NO CHANGE | | +| `build/run-a-gateway/manage/index.mdx` | NO CHANGE | | +| `build/run-a-gateway/manage/index-snapshots.mdx` | NO CHANGE | | +| `build/run-a-gateway/manage/setting-apex-domain.mdx` | NO CHANGE | | +| `build/run-a-gateway/manage/ssl-certs.mdx` | NO CHANGE | | +| `build/run-a-gateway/manage/troubleshooting.mdx` | NO CHANGE | | +| `build/run-a-gateway/manage/upgrading-a-gateway.mdx` | NO CHANGE | | +| `build/run-a-gateway/manage/x402-setup.mdx` | NO CHANGE | | + +### build/run-wayfinder-router/ + +| Page | Status | Notes | +|------|--------|-------| +| `build/run-wayfinder-router/index.mdx` | NO CHANGE | | +| `build/run-wayfinder-router/quick-start.mdx` | NO CHANGE | | +| `build/run-wayfinder-router/configuration.mdx` | NO CHANGE | | +| `build/run-wayfinder-router/admin-ui.mdx` | NO CHANGE | | +| `build/run-wayfinder-router/operations.mdx` | NO CHANGE | | + +### build/extensions/ + +| Page | Status | Notes | +|------|--------|-------| +| `build/extensions/index.mdx` | UPDATED | Removed compute-unit card | +| `build/extensions/grafana.mdx` | UPDATED | Removed compute-unit card | +| `build/extensions/clickhouse.mdx` | UPDATED | Removed compute-unit card | +| `build/extensions/bundler.mdx` | UPDATED | Removed compute-unit card | +| `build/extensions/compute-unit.mdx` | DELETED | AO-only | + +### build/guides/ + +| Page | Status | Notes | +|------|--------|-------| +| `build/guides/index.mdx` | NO CHANGE | | +| `build/guides/arns-marketplace.mdx` | UPDATED | Rewritten for Tensor/Magic Eden NFT trading | +| `build/guides/working-with-arns/index.mdx` | UPDATED | ANT=Metaplex Core NFT, ario-arns program | +| `build/guides/working-with-arns/register-arns-programmatically.mdx` | UPDATED | Solana signer, SOL fees | +| `build/guides/working-with-arns/set-arns-records-programmatically.mdx` | UPDATED | Solana signer, removed ArweaveSigner | +| `build/guides/working-with-arns/purchase-arns-ui.mdx` | NO CHANGE | UI guide (screenshots TBD later) | +| `build/guides/working-with-arns/manage-arns-ui.mdx` | NO CHANGE | UI guide (screenshots TBD later) | +| `build/guides/working-with-arns/arns-primary-names.mdx` | NO CHANGE | | +| `build/guides/hosting-decentralised-apps/index.mdx` | NO CHANGE | | +| `build/guides/hosting-decentralised-apps/deploying-with-arlink.mdx` | NO CHANGE | | +| `build/guides/hosting-decentralised-apps/deploying-with-permaweb-deploy.mdx` | NO CHANGE | | +| `build/guides/hosting-decentralised-apps/hosting-with-ardrive.mdx` | NO CHANGE | | +| `build/guides/hosting-decentralised-apps/using-undernames-for-versioning.mdx` | NO CHANGE | | +| `build/guides/using-turbo-in-a-browser/index.mdx` | NO CHANGE | | +| `build/guides/using-turbo-in-a-browser/html.mdx` | NO CHANGE | | +| `build/guides/using-turbo-in-a-browser/nextjs.mdx` | NO CHANGE | | +| `build/guides/using-turbo-in-a-browser/vite.mdx` | NO CHANGE | | +| `build/guides/depin.mdx` | NO CHANGE | DePIN concepts | +| `build/guides/application-distribution.mdx` | NO CHANGE | | +| `build/guides/encrypted-data-nillion.mdx` | NO CHANGE | | +| `build/guides/crossmint-nft-minting-app.mdx` | NO CHANGE | | +| `build/guides/storing-nfts.mdx` | NO CHANGE | | + +### build/advanced/ + +| Page | Status | Notes | +|------|--------|-------| +| `build/advanced/index.mdx` | NO CHANGE | | +| `build/advanced/arfs/index.mdx` | NO CHANGE | | +| `build/advanced/arfs/creating-drives.mdx` | NO CHANGE | | +| `build/advanced/arfs/data-model.mdx` | NO CHANGE | | +| `build/advanced/arfs/entity-types.mdx` | NO CHANGE | | +| `build/advanced/arfs/privacy.mdx` | NO CHANGE | | +| `build/advanced/arfs/reading-data.mdx` | NO CHANGE | | +| `build/advanced/arfs/upgrading-drives.mdx` | NO CHANGE | | +| `build/advanced/normalized-addresses.mdx` | NO CHANGE | | +| `build/advanced/sandboxing.mdx` | NO CHANGE | | +| `build/advanced/ethareum.mdx` | NO CHANGE | | + +--- + +## SDKs Section + +| Page | Status | Notes | +|------|--------|-------| +| `sdks/index.mdx` | UPDATED | "smart contracts" → "Solana programs" | + +### sdks/ar-io-sdk/ + +| Page | Status | Notes | +|------|--------|-------| +| `sdks/ar-io-sdk/index.mdx` | UPDATED | "AO contract" → "Solana program" | +| `sdks/ar-io-sdk/token-conversion.mdx` | UPDATED | "process" → "protocol" | +| `sdks/ar-io-sdk/pagination.mdx` | NO CHANGE | SDK pagination patterns | +| `sdks/ar-io-sdk/logging.mdx` | NO CHANGE | | +| `sdks/ar-io-sdk/(ario-contract)/configuration.mdx` | REWRITTEN | Solana RPC config, legacy footnote | +| `sdks/ar-io-sdk/(ario-contract)/networks.mdx` | REWRITTEN | Program addresses, Solana devnet | +| `sdks/ar-io-sdk/(ario-contract)/general.mdx` | REWRITTEN | Solana signers as default | +| `sdks/ar-io-sdk/(ario-contract)/arweave-name-system-arns.mdx` | UPDATED | mint address, minting-ant callback | +| `sdks/ar-io-sdk/(ario-contract)/epochs.mdx` | NO CHANGE | API responses (verify post-launch) | +| `sdks/ar-io-sdk/(ario-contract)/gateways.mdx` | NO CHANGE | API methods unchanged | +| `sdks/ar-io-sdk/(ario-contract)/primary-names.mdx` | NO CHANGE | API methods unchanged | +| `sdks/ar-io-sdk/(ario-contract)/vaults.mdx` | NO CHANGE | API methods unchanged | +| `sdks/ar-io-sdk/(ant-contracts)/initialize.mdx` | UPDATED | Solana wallet adapter + mint address | +| `sdks/ar-io-sdk/(ant-contracts)/spawn.mdx` | UPDATED | "Spawns AO process" → "Mints Metaplex Core NFT" | +| `sdks/ar-io-sdk/(ant-contracts)/static-methods.mdx` | UPDATED | Fork → new NFT, Solana signers | +| `sdks/ar-io-sdk/(ant-contracts)/upgrade.mdx` | UPDATED | Metaplex Core schema versioning | +| `sdks/ar-io-sdk/(ant-contracts)/transfer.mdx` | UPDATED | "Arweave address" → "Solana address" | +| `sdks/ar-io-sdk/(ant-contracts)/ario-integrations.mdx` | UPDATED | PROCESS_ID → PROGRAM_ID | +| `sdks/ar-io-sdk/(ant-contracts)/records.mdx` | NO CHANGE | API unchanged | +| `sdks/ar-io-sdk/(ant-contracts)/controllers.mdx` | NO CHANGE | | +| `sdks/ar-io-sdk/(ant-contracts)/metadata.mdx` | NO CHANGE | | +| `sdks/ar-io-sdk/(ant-contracts)/balances.mdx` | NO CHANGE | | +| `sdks/ar-io-sdk/(ant-contracts)/state.mdx` | NO CHANGE | | +| `sdks/ar-io-sdk/(ant-contracts)/undername-ownership.mdx` | NO CHANGE | | +| `sdks/ar-io-sdk/(ant-contracts)/versions.mdx` | NO CHANGE | | + +### sdks/turbo-sdk/ (11 pages) + +| Page | Status | Notes | +|------|--------|-------| +| `sdks/turbo-sdk/index.mdx` | NO CHANGE | Independent service | +| `sdks/turbo-sdk/logging.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/turbo-credit-sharing.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(apis)/turbofactory.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(apis)/turboauthenticatedclient.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(apis)/turbounauthenticatedclient.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(events)/file-upload-events.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(events)/folder-upload-events.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(signers)/arweave.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(signers)/base.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(signers)/ethereum.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(signers)/kyve.mdx` | NO CHANGE | | +| `sdks/turbo-sdk/(signers)/solana.mdx` | NO CHANGE | | + +### sdks/ardrive-core-js/ (16 pages) + +| Page | Status | Notes | +|------|--------|-------| +| All pages | NO CHANGE | ArDrive SDK, chain-agnostic | + +### sdks/(clis)/ardrive-cli/ (~40 pages) + +| Page | Status | Notes | +|------|--------|-------| +| All pages | NO CHANGE | ArDrive CLI, chain-agnostic | + +### sdks/wayfinder/ (~12 pages) + +| Page | Status | Notes | +|------|--------|-------| +| All pages | NO CHANGE | Wayfinder SDK, chain-agnostic | + +--- + +## APIs Section + +| Page | Status | Notes | +|------|--------|-------| +| `apis/index.mdx` | NO CHANGE | | +| `apis/ar-io-node/*.mdx` (13 pages) | NO CHANGE | Gateway API, chain-agnostic | +| `apis/turbo/**/*.mdx` (12 pages) | NO CHANGE | Turbo service APIs | + +--- + +## Glossary + +| Page | Status | Notes | +|------|--------|-------| +| `glossary/index.mdx` | UPDATED | Updated AO def, added 7 Solana terms | + +--- + +## Summary + +| Status | Count | +|--------|-------| +| REWRITTEN | 7 | +| UPDATED | 33 | +| NEW | 6 | +| DELETED | 2 | +| NO CHANGE | ~207 | +| **Total** | **255** | + +## Remaining TODOs + +- [ ] Replace `` and `` placeholders with final addresses before launch +- [ ] Update UI screenshots in `purchase-arns-ui.mdx` and `manage-arns-ui.mdx` once Solana UI is live +- [ ] Run `npm run build` to verify no broken MDX +- [ ] Run `npm run check-links` to validate all internal links +- [ ] Run `npm run generate-all-docs` to regenerate LLM text files +- [ ] Verify `turbo-credits.mdx` with Turbo team once ARIO payment chain is finalized diff --git a/content/build/advanced/normalized-addresses.mdx b/content/build/advanced/normalized-addresses.mdx index cc5a92517..14b548262 100644 --- a/content/build/advanced/normalized-addresses.mdx +++ b/content/build/advanced/normalized-addresses.mdx @@ -5,7 +5,7 @@ description: "Learn about normalized addresses - how different blockchain wallet ## Overview -Different blockchains use different formats for the [public keys](/glossary) of wallets, and the [native addresses](/glossary) for those wallets. In most cases, when a system in the Arweave ecosystem needs to display the wallet address of a wallet from a different blockchain, for instance in the `Owner.address` value of an AO process spawned by an ETH wallet, that address will be normalized into the format recognized by Arweave. Specifically, a 43 character base64url representation of the sha256 hash of the public key. This is done to prevent potential errors by systems in the Arweave ecosystem that expect these values to be a certain size and conform to a specific format. +Different blockchains use different formats for the [public keys](/glossary) of wallets, and the [native addresses](/glossary) for those wallets. In most cases, when a system in the Arweave ecosystem needs to display the wallet address of a wallet from a different blockchain, for instance in the `Owner.address` value of a data item signed by an ETH or Solana wallet, that address will be normalized into the format recognized by Arweave. Specifically, a 43 character base64url representation of the sha256 hash of the public key. This is done to prevent potential errors by systems in the Arweave ecosystem that expect these values to be a certain size and conform to a specific format. Essentially, normalized addresses are a way to represent public keys and wallet addresses from other blockchains in a way that is familiar to systems in the Arweave ecosystem. diff --git a/content/build/extensions/bundler.mdx b/content/build/extensions/bundler.mdx index 962fb5fe2..941cf290b 100644 --- a/content/build/extensions/bundler.mdx +++ b/content/build/extensions/bundler.mdx @@ -179,12 +179,6 @@ Now that you have a bundler set up to accept data uploads, continue building you description="Improve query performance with ClickHouse and Parquet integration" href="/build/extensions/clickhouse" /> - } - title="Run Compute Unit" - description="Execute AO processes locally for maximum efficiency" - href="/build/extensions/compute-unit" - /> } title="Buy an ArNS Name" diff --git a/content/build/extensions/clickhouse.mdx b/content/build/extensions/clickhouse.mdx index c66c028bb..3939d76b9 100644 --- a/content/build/extensions/clickhouse.mdx +++ b/content/build/extensions/clickhouse.mdx @@ -404,12 +404,6 @@ Now that you have ClickHouse set up for improved query performance, continue bui description="Accept data uploads directly through your gateway" href="/build/extensions/bundler" /> - } - title="Run Compute Unit" - description="Execute AO processes locally for maximum efficiency" - href="/build/extensions/compute-unit" - /> } title="Join the Network" diff --git a/content/build/extensions/compute-unit.mdx b/content/build/extensions/compute-unit.mdx deleted file mode 100644 index 4fada28e6..000000000 --- a/content/build/extensions/compute-unit.mdx +++ /dev/null @@ -1,364 +0,0 @@ ---- -title: "AO Compute Unit (CU)" -description: "Steps for deploying an AO Compute Unit (CU) sidecar alongside your ar.io Gateway." ---- - -## Overview - -An AO Compute Unit (CU) is a critical component in the AO ecosystem responsible for executing AO processes and maintaining their state. CUs serve as the computational backbone of the AO network by: - -- **Processing Messages**: CUs receive and process messages sent to AO processes -- **Executing WASM Modules**: CUs run the WebAssembly (WASM) code that defines process behavior -- **Maintaining State**: CUs track and update the state of AO processes -- **Creating Checkpoints**: CUs periodically save process state to the Arweave network as checkpoints - -Running a CU alongside your gateway allows you to: - -1. Process AO requests locally rather than relying on external services -2. Improve response times for AO-related queries -3. Contribute computational resources to the AO network -4. Ensure your gateway has reliable access to AO functionality - -For more detailed information about Compute Units, please refer to the [AO Cookbook: Units](https://cookbook_ao.arweave.net/concepts/units.html#summary). - -## System Requirements - -Before deploying a CU, ensure your system meets the following requirements: - -- **Recommended**: At least 16GB RAM for optimal CU operation -- **Minimum**: 4GB RAM is possible with adjusted memory limits (see resource allocation settings) -- At least 100GB disk space dedicated to CU operation -- These requirements are separate from your gateway requirements - - - Running a CU is resource-intensive. Make sure your system has sufficient - resources to handle both the gateway and the CU. While you can run a CU with - less than the recommended RAM, you'll need to adjust the memory limits - accordingly. - - -## Deploying an AO CU - - - -### Navigate to Gateway Directory - -First, navigate to the root directory of your gateway: - -```bash -cd /path/to/your/gateway -``` - - - - -### Configure Environment Variables - -Copy the example environment file: - -```bash -cp .env.ao.example .env.ao -``` - -### Default .env.ao.example Contents - -The default `.env.ao.example` file contains the following settings: - -``` -CU_WALLET='[wallet json here]' -PROCESS_CHECKPOINT_TRUSTED_OWNERS=WjnS-s03HWsDSdMnyTdzB1eHZB2QheUWP_FVRVYxkXk,-HFe6PleLxj1EdFMYMSetT2NIJioDsZIktn-Y0AwP54 -GATEWAY_URL=http://envoy:3000 -UPLOADER_URL=http://envoy:3000/bundler -``` - -These default settings are configured to work with a gateway running on the same machine, but you'll need to modify them as described below. - -Open the `.env.ao` file in your preferred text editor: - -```bash -nano .env.ao -``` - -Configure the following settings: - -1. **CU_WALLET**: Replace `'[wallet json here]'` with the JSON from an Arweave wallet. - - - The entire JSON must be placed on a single line for proper registration. - - -2. **PROCESS_CHECKPOINT_TRUSTED_OWNERS**: This is a comma-separated list of trusted wallet addresses: - - ``` - PROCESS_CHECKPOINT_TRUSTED_OWNERS=WjnS-s03HWsDSdMnyTdzB1eHZB2QheUWP_FVRVYxkXk,-HFe6PleLxj1EdFMYMSetT2NIJioDsZIktn-Y0AwP54 - ``` - - - - If you are uploading your own checkpoints, you should add your own CU wallet address after the default value, separated by a comma: - - ``` - PROCESS_CHECKPOINT_TRUSTED_OWNERS=WjnS-s03HWsDSdMnyTdzB1eHZB2QheUWP_FVRVYxkXk,-HFe6PleLxj1EdFMYMSetT2NIJioDsZIktn-Y0AwP54,YOUR_WALLET_ADDRESS_HERE - ``` - - This allows your CU to trust checkpoints from both the official source and your own wallet. - - - -3. **GATEWAY_URL**: By default, this is set to use your own gateway: - - ``` - GATEWAY_URL=http://envoy:3000 - ``` - - A gateway must be set to index all ANS-104 data items from AO or the CU will not operate properly. Most users will want to set this to: - - ``` - GATEWAY_URL=https://arweave.net - ``` - -4. **UPLOADER_URL**: By default, this is set to use a bundler sidecar run by your gateway: - - ``` - UPLOADER_URL=http://envoy:3000/bundler - ``` - - - Checkpoints are uploaded to Arweave, so the upload must be paid for. You - must ensure your wallet has sufficient funds: - If using - `https://up.arweave.net` (recommended), your CU_WALLET must contain Turbo - Credits - If using your own bundler or another service, you'll need the - appropriate token (AR or other) - Without proper funding, checkpoints will - fail to upload and your CU may not function correctly - - - The simplest option for most users is to use: - - ``` - UPLOADER_URL=https://up.arweave.net - ``` - - This requires your CU_WALLET to contain Turbo Credits. - -5. **Optional: Disable Checkpoint Creation**: If you want to disable checkpoint uploads, add: - ``` - DISABLE_PROCESS_CHECKPOINT_CREATION=true - ``` - -### Example of a Completed .env.ao File - -Here's an example of what your completed `.env.ao` file might look like with common settings: - -``` -CU_WALLET='{"kty":"RSA","e":"AQAB","n":"mYM07..."}' -PROCESS_CHECKPOINT_TRUSTED_OWNERS=WjnS-s03HWsDSdMnyTdzB1eHZB2QheUWP_FVRVYxkXk,-HFe6PleLxj1EdFMYMSetT2NIJioDsZIktn-Y0AwP54 -GATEWAY_URL=https://arweave.net -UPLOADER_URL=https://up.arweave.net -``` - -After making your changes, save and exit the nano editor: - -1. Press `Ctrl+X` to exit -2. Press `Y` to confirm saving changes -3. Press `Enter` to confirm the filename - -### Optional Resource Allocation Settings - -You can fine-tune the CU's resource usage by adding these optional environment variables: - -1. **PROCESS_WASM_MEMORY_MAX_LIMIT**: Sets the maximum memory limit (in bytes) for WASM processes. - - ``` - PROCESS_WASM_MEMORY_MAX_LIMIT=17179869184 # 16GB (16 * 1024^3) - ``` - - - - To work with the ar.io process, `PROCESS_WASM_MEMORY_MAX_LIMIT` must be at least `17179869184` (16GB). - - Note: This doesn't mean your server needs 16GB of RAM. This is the maximum memory limit the CU will support for processes. Most processes don't use their maximum allocated memory. - - You can set this value to 16GB even if your server only has 4GB of RAM. However, if a process requires more memory than your server has available, the CU will fail when evaluating messages that need more memory. - - - -2. **WASM_EVALUATION_MAX_WORKERS**: Sets the maximum number of worker threads for WASM evaluation. - - ``` - WASM_EVALUATION_MAX_WORKERS=4 # Example: Use 4 worker threads - ``` - - - This will default to (available CPUs - 1) if not specified. If you're - running a gateway and unbundling on the same server, consider setting this - to 2 or less to avoid overloading your CPU. - - -3. **PROCESS_WASM_COMPUTE_MAX_LIMIT**: The maximum Compute-Limit, in bytes, supported for ao processes (defaults to 9 billion) - - ``` - PROCESS_WASM_COMPUTE_MAX_LIMIT=9000000000 - ``` - -4. **NODE_OPTIONS**: Sets Node.js memory allocation for the Docker container. - ``` - NODE_OPTIONS=--max-old-space-size=8192 # Example: 8GB for Node.js heap - ``` - - - Start with conservative values and monitor performance. You can adjust these - settings based on your system's capabilities and the CU's performance. - - - - - -### Start the CU Container - -Once your environment file is configured, start the CU container: - -```bash -docker compose --env-file .env.ao -f docker-compose.ao.yaml up -d -``` - -This command uses the following flags: - -- `--env-file .env.ao`: Specifies the environment file to use -- `-f docker-compose.ao.yaml`: Specifies the Docker Compose file to use -- `up`: Creates and starts the containers -- `-d`: Runs containers in detached mode (background) - - - - -### Check the Logs - -To check the logs of your CU container: - -```bash -docker compose -f docker-compose.ao.yaml logs -f --tail=20 -``` - -This command uses the following flags: - -- `-f`: Follows the log output (continuous display) -- `--tail=20`: Shows only the last 20 lines of logs - -Exit the logs by pressing `Ctrl+C`. - - - - -## Connecting Your Gateway to the CU - -To make your gateway use your local CU: - -1. Add the following line to your gateway's `.env` file: - - ``` - AO_CU_URL=http://ao-cu:6363 - ``` - - This assumes the CU is running on the same machine as the gateway. - -2. Restart your gateway: - ```bash - docker compose down - docker compose up -d - ``` - - - A CU won't do anything until requests are being made of it. By connecting your - gateway to the CU, you'll start generating these requests. - - -### Accessing Your CU - -Once properly set up and connected to your gateway, you can access your CU via: - -``` -https:///ao/cu -``` - -This endpoint allows you to interact with your CU directly through your gateway's domain. - -## Important Notes - -- **Initial Processing Time**: A CU will need to process AO history before it can give valid responses. This process can take several hours. - -- **Gateway Fallback**: A gateway on release 27 or above will fallback to arweave.net if its default CU is not responding quickly enough, so gateway operations will not be significantly impacted during the initial processing. - -- **Monitoring Progress**: Check the CU logs after pointing a gateway at it to watch the process of working through AO history: - - ```bash - docker compose -f docker-compose.ao.yaml logs -f --tail=20 - ``` - -- **Resource Usage**: Running a CU is resource-intensive. Monitor your system's performance to ensure it can handle both the gateway and CU workloads. - -## Useful Docker Commands - -Monitor and manage your AO Compute Unit with these commands: - -```bash -# View all running services -docker ps - -# Start CU container with environment file -docker compose --env-file .env.ao -f docker-compose.ao.yaml up -d - -# Stop CU container -docker compose -f docker-compose.ao.yaml down - -# Pull latest CU images -docker compose -f docker-compose.ao.yaml pull - -# Follow CU logs -docker compose -f docker-compose.ao.yaml logs -f --tail=20 - -# Check CU container status -docker compose -f docker-compose.ao.yaml ps - -# Restart CU container -docker compose -f docker-compose.ao.yaml restart - -# View CU logs without following -docker compose -f docker-compose.ao.yaml logs --tail=50 - -# Start CU in foreground (for debugging) -docker compose --env-file .env.ao -f docker-compose.ao.yaml up -``` - -## Next Steps - -Now that you have a Compute Unit running alongside your gateway, continue building your infrastructure: - - - } - title="Set Up Monitoring" - description="Deploy Grafana to visualize your gateway's performance metrics" - href="/build/extensions/grafana" - /> - } - title="Add ClickHouse" - description="Improve query performance with ClickHouse and Parquet integration" - href="/build/extensions/clickhouse" - /> - } - title="Deploy Bundler" - description="Accept data uploads directly through your gateway" - href="/build/extensions/bundler" - /> - } - title="Join the Network" - description="Register your gateway and start serving the permanent web" - href="/build/run-a-gateway/join-the-network" - /> - diff --git a/content/build/extensions/grafana.mdx b/content/build/extensions/grafana.mdx index ff777c8f9..1ba86f4b0 100644 --- a/content/build/extensions/grafana.mdx +++ b/content/build/extensions/grafana.mdx @@ -414,10 +414,4 @@ Now that you have monitoring set up, continue building your gateway infrastructu description="Accept data uploads directly through your gateway" href="/build/extensions/bundler" /> - } - title="Run Compute Unit" - description="Execute AO processes locally for maximum efficiency" - href="/build/extensions/compute-unit" - /> diff --git a/content/build/extensions/index.mdx b/content/build/extensions/index.mdx index 11eb09d4f..7d636491c 100644 --- a/content/build/extensions/index.mdx +++ b/content/build/extensions/index.mdx @@ -40,9 +40,6 @@ The following sidecars are developed and maintained by the ar.io team, designed access control. - }> - Execute AO processes locally with WASM module support and state management. - **Ready to enhance your gateway?** Click any sidecar above to get started with detailed setup guides. diff --git a/content/build/extensions/meta.json b/content/build/extensions/meta.json index 215ce7eba..854d077ed 100644 --- a/content/build/extensions/meta.json +++ b/content/build/extensions/meta.json @@ -2,5 +2,5 @@ "title": "Extensions & Sidecars", "icon": "Plug", "defaultOpen": false, - "pages": ["grafana", "clickhouse", "bundler", "compute-unit"] + "pages": ["grafana", "clickhouse", "bundler"] } diff --git a/content/build/guides/arns-marketplace.mdx b/content/build/guides/arns-marketplace.mdx index 5c9c68b18..3daa64558 100644 --- a/content/build/guides/arns-marketplace.mdx +++ b/content/build/guides/arns-marketplace.mdx @@ -5,44 +5,49 @@ description: "Potential for trading and selling ArNS tokens and digital assets i import { Globe, Code, Book } from "lucide-react"; -**ArNS tokens** have the potential to be traded and sold in decentralized marketplaces. ANTs (Arweave Name Tokens) are both smart contracts and transferable tokens, making them valuable digital assets that could be bought, sold, and traded. However, no established marketplace has yet emerged as the preferred platform for ArNS trading. +**ArNS tokens** can be traded and sold on standard Solana NFT marketplaces. ANTs (Arweave Name Tokens) are Metaplex Core NFTs, making them tradeable on **Tensor**, **Magic Eden**, and other compatible platforms. -## Current State of ArNS Trading +## Trading ANTs on NFT Marketplaces -**No established marketplace exists yet** - While ANTs are technically transferable tokens, there is currently no widely adopted marketplace specifically for ArNS trading. +ANTs are standard Metaplex Core NFTs on Solana. This means they are natively supported by the Solana NFT ecosystem: -**Direct transfers are possible** - You can transfer ANTs directly between wallets, but this requires technical knowledge and direct coordination between buyer and seller. +- **[Tensor](https://tensor.trade)** — Solana's leading NFT marketplace with advanced trading features +- **[Magic Eden](https://magiceden.io)** — Popular cross-chain NFT marketplace with Solana support +- **Direct transfers** — ANTs can be sent directly between Solana wallets -**Future potential** - As the ArNS ecosystem grows, dedicated marketplaces may emerge to facilitate easier trading of ArNS tokens and domains. +### Lazy Reconciliation + +When an ANT is sold on a marketplace (outside the ar.io protocol), the existing controllers are not immediately cleared. Instead, **lazy reconciliation** occurs on the next write operation — controllers are cleared automatically, ensuring the new owner gets clean control of the name. ## What Are ANTs? **Arweave Name Tokens (ANTs)** are: -- **Smart contracts** - Define the rules and functionality of your domain -- **Transferable tokens** - Can be bought, sold, and traded -- **Digital assets** - Represent ownership of ArNS domains -- **Permanent** - Stored on Arweave forever +- **Metaplex Core NFTs** — Standard Solana NFTs with on-chain state in PDAs +- **Transferable assets** — Can be bought, sold, and traded on any compatible marketplace +- **Digital assets** — Represent ownership and control of ArNS domains +- **DNS-like routing** — Each ANT stores records pointing to Arweave transaction IDs -## How Trading Could Work +## How Trading Works ### 1. Token Ownership **When you own an ANT:** -- You control the domain name -- You can update where it points -- You can transfer ownership -- You could potentially sell it to others +- You control the domain name and its records +- You can update where it points (Arweave TX IDs or IPFS CIDs) +- You can transfer ownership via direct transfer or marketplace sale +- You can list it on Tensor, Magic Eden, or other Solana NFT marketplaces +- You can add up to 10 controllers who can manage records on your behalf -### 2. Potential Marketplace Dynamics +### 2. Marketplace Trading -**Possible trading mechanisms:** +**Trading mechanisms:** -- **Direct transfers** - Send tokens directly to another wallet -- **Marketplace platforms** - Use dedicated trading platforms (when available) -- **Auction systems** - Bid on available domains (when implemented) -- **Fixed price sales** - Set a price and wait for buyers (when supported) +- **Marketplace listings** — List your ANT on Tensor or Magic Eden with a fixed price or auction +- **Direct transfers** — Send the NFT directly to another Solana wallet +- **Collection offers** — Accept collection-wide offers from buyers +- **Instant sales** — Sell into existing bids on marketplaces ### 3. Name Characteristics diff --git a/content/build/guides/working-with-arns/index.mdx b/content/build/guides/working-with-arns/index.mdx index 4dc664d06..bbe150418 100644 --- a/content/build/guides/working-with-arns/index.mdx +++ b/content/build/guides/working-with-arns/index.mdx @@ -16,7 +16,7 @@ ArNS is a decentralized naming system that allows you to: - **Point names to content** stored on Arweave for permanent access - **Create subdomains** (undernames) for organizing different versions and components - **Establish web3 identity** with primary names linked to wallet addresses -- **Transfer ownership** of names through the ANT (Arweave Name Token) system +- **Transfer ownership** of names through the ANT (Arweave Name Token) system — ANTs are Metaplex Core NFTs tradeable on Solana marketplaces ## Getting Started @@ -80,7 +80,7 @@ ArNS names used as web3 identity that resolve to wallet addresses, enabling huma ### ANT (Arweave Name Token) -The smart contract system that manages ArNS name ownership, transfers, and record updates. +A Metaplex Core NFT on Solana that represents ownership and control of an ArNS name. Each ANT stores DNS-like records pointing to Arweave data. ANTs are managed by the `ario-ant` Solana program and are tradeable on NFT marketplaces like Tensor and Magic Eden. ## Common Use Cases diff --git a/content/build/guides/working-with-arns/register-arns-programmatically.mdx b/content/build/guides/working-with-arns/register-arns-programmatically.mdx index 20d96e78b..d6f3fb241 100644 --- a/content/build/guides/working-with-arns/register-arns-programmatically.mdx +++ b/content/build/guides/working-with-arns/register-arns-programmatically.mdx @@ -16,27 +16,19 @@ Use the **ar.io SDK** to programmatically register and purchase ArNS names. This npm install @ar.io/sdk ``` -**Required files:** +**Required:** -```bash -# Your Arweave wallet JSON file -wallet.json -``` +- A Solana wallet with ARIO tokens and SOL for transaction fees ## Basic Setup -**Initialize the SDK with your wallet:** +**Initialize the SDK with your Solana wallet:** ```javascript const { ARIO } = require("@ar.io/sdk"); -const { ArweaveSigner } = require("@ardrive/turbo-sdk"); -const fs = require("fs"); - -// Load your wallet JSON file -const jwk = JSON.parse(fs.readFileSync("./wallet.json", "utf8")); -// Initialize ARIO with signer for transactions -const ario = ARIO.mainnet({ signer: new ArweaveSigner(jwk) }); +// Initialize ARIO with a Solana signer for transactions +const ario = ARIO.mainnet({ signer: solanaKeypairSigner }); ``` ## Complete Registration Process diff --git a/content/build/guides/working-with-arns/set-arns-records-programmatically.mdx b/content/build/guides/working-with-arns/set-arns-records-programmatically.mdx index c1a2f349f..cefcac848 100644 --- a/content/build/guides/working-with-arns/set-arns-records-programmatically.mdx +++ b/content/build/guides/working-with-arns/set-arns-records-programmatically.mdx @@ -12,15 +12,12 @@ Use the **ar.io SDK** to programmatically set and manage ArNS records. This appr **Install the required packages:** ```bash -npm install @ar.io/sdk @ardrive/turbo-sdk +npm install @ar.io/sdk ``` -**Required files:** +**Required:** -```bash -# Your Arweave wallet JSON file -wallet.json -``` +- A Solana wallet with ARIO tokens and SOL for transaction fees ## Basic Setup @@ -28,15 +25,12 @@ wallet.json ```javascript const { ARIO, ANT } = require("@ar.io/sdk"); -const { ArweaveSigner } = require("@ardrive/turbo-sdk"); -const fs = require("fs"); // Initialize ARIO for mainnet const ario = ARIO.mainnet(); -// Load your wallet JSON file -const jwk = JSON.parse(fs.readFileSync("./wallet.json", "utf8")); -const signer = new ArweaveSigner(jwk); +// Use your Solana signer +const signer = solanaKeypairSigner; ``` ## Setting Base Name Records diff --git a/content/build/run-a-gateway/join-the-network.mdx b/content/build/run-a-gateway/join-the-network.mdx index ca12fff68..3d2827491 100644 --- a/content/build/run-a-gateway/join-the-network.mdx +++ b/content/build/run-a-gateway/join-the-network.mdx @@ -33,9 +33,13 @@ Take control of the permanent web by running your own **ar.io Gateway**. Join th **Acquisition Options:** - Purchase on centralized exchanges like Gate.io - - Trade on decentralized exchanges (Dexi, Botega, Vento) - - Use Wander wallet for easy exchange and swap functionality + - Trade on Solana DEXs (Jupiter, Raydium) + - Use a Solana wallet (Phantom, Solflare, Backpack) to manage tokens - Earn through network participation and community programs + + + You will also need SOL in your wallet for Solana transaction fees when joining the network. + @@ -67,7 +71,7 @@ Choose your preferred method to register your gateway: Connect Wallet - Choose your preferred wallet (Wander, Metamask, or Beacon) to connect. + Choose your preferred Solana wallet (Phantom, Solflare, or Backpack) to connect. Use the same wallet address that you configured in your gateway's `AR_IO_WALLET` environment variable. This wallet will be the owner of your gateway registration. @@ -139,7 +143,7 @@ Choose your preferred method to register your gateway: ```bash ar.io join-network \ - --wallet-file ./path/to/wallet.json \ + --wallet-file ./path/to/solana-keypair.json \ --qty 10000000000 \ --auto-stake true \ --allow-delegated-staking true \ @@ -147,7 +151,7 @@ Choose your preferred method to register your gateway: --delegate-reward-share-ratio 10 \ --label "My Test Gateway" \ --note "Test gateway for development" \ - --observer-wallet 0VE0wIhDy90WiQoV3U2PeY44FH1aVetOoulPGqgYukj \ + --observer-wallet 7xKXtR2qpZm8FjvKNsG3kL9p5yMnYhVdEbxQ4oWc2Rn \ --fqdn my-gateway.example.com \ --port 443 \ --protocol https \ @@ -155,7 +159,7 @@ Choose your preferred method to register your gateway: ``` - The wallet file used in the `--wallet-file` parameter must be the same wallet configured in your ar.io Gateway's `AR_IO_WALLET` environment variable. This ensures your gateway registration is properly linked to your running gateway instance. + The wallet file must be a Solana keypair JSON file (Ed25519). The public key derived from this keypair must match the `AR_IO_WALLET` environment variable configured in your gateway. The observer wallet must also be a unique Solana address — no two gateways can share the same observer. **Parameter explanations:** diff --git a/content/build/run-a-gateway/manage/environment-variables.mdx b/content/build/run-a-gateway/manage/environment-variables.mdx index acf83c39c..8363a7dd7 100644 --- a/content/build/run-a-gateway/manage/environment-variables.mdx +++ b/content/build/run-a-gateway/manage/environment-variables.mdx @@ -162,7 +162,7 @@ For detailed configuration and usage, see [CDB64 Root TX Index](/build/run-a-gat | Variable | Type | Default | Description | | -------------------------- | ------ | --------------------------------------------- | -------------------------- | | `AR_IO_WALLET` | string | - | Gateway wallet | -| `IO_PROCESS_ID` | string | `qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE` | ar.io process ID | +| `IO_PROCESS_ID` | string | `` | ar.io Solana program address | | `AR_IO_NODE_RELEASE` | string | `33` | ar.io node release version | | `APEX_TX_ID` | string | - | Apex transaction ID | | `APEX_ARNS_NAME` | string | - | Apex ArNS name | @@ -230,16 +230,11 @@ For detailed configuration and usage, see [CDB64 Root TX Index](/build/run-a-gat | `LEGACY_PSQL_PASSWORD_FILE` | string | - | Path to PostgreSQL password file | | `LEGACY_PSQL_SSL_REJECT_UNAUTHORIZED` | boolean | `true` | Reject unauthorized SSL connections | -### AO (Autonomous Objects) +### Solana -| Variable | Type | Default | Description | -| ------------------- | ------ | ------- | ----------------- | -| `AO_CU_URL` | string | - | AO CU URL | -| `NETWORK_AO_CU_URL` | string | - | Network AO CU URL | -| `ANT_AO_CU_URL` | string | - | ANT AO CU URL | -| `AO_MU_URL` | string | - | AO MU URL | -| `AO_GATEWAY_URL` | string | - | AO Gateway URL | -| `AO_GRAPHQL_URL` | string | - | AO GraphQL URL | +| Variable | Type | Default | Description | +| ----------------- | ------ | ------------------------------------------ | ----------------------------- | +| `SOLANA_RPC_URL` | string | `https://api.mainnet-beta.solana.com` | Solana RPC endpoint | ### Circuit Breaker @@ -316,14 +311,14 @@ For detailed configuration and usage, see [CDB64 Root TX Index](/build/run-a-gat | `PORT` | number | `5050` | Observer service port | | `LOG_LEVEL` | string | - | Observer log level | | `OBSERVER_WALLET` | string | - | Observer wallet | -| `IO_PROCESS_ID` | string | - | ar.io process ID | +| `IO_PROCESS_ID` | string | - | ar.io Solana program address | | `AR_IO_NODE_RELEASE` | string | `33` | ar.io node release version | ### Observer Operation | Variable | Type | Default | Description | | ------------------------------------- | ------- | ------- | ------------------------------------------ | -| `SUBMIT_CONTRACT_INTERACTIONS` | boolean | `true` | Submit contract interactions | +| `SUBMIT_CONTRACT_INTERACTIONS` | boolean | `true` | Submit observations to Solana programs | | `NUM_ARNS_NAMES_TO_OBSERVE_PER_GROUP` | number | `8` | Number of ArNS names per observation group | | `REPORT_GENERATION_INTERVAL_MS` | string | - | Report generation interval | | `REPORT_DATA_SINK` | string | - | Report data sink | @@ -350,11 +345,11 @@ For detailed configuration and usage, see [CDB64 Root TX Index](/build/run-a-gat | ------------------------------------- | ------ | ------- | ------------------------------------------ | | `NUM_ARNS_NAMES_TO_OBSERVE_PER_GROUP` | number | `8` | Number of ArNS names per observation group | -### Contract Interaction +### On-Chain Observations -| Variable | Type | Default | Description | -| ------------------------------ | ------- | ------- | ---------------------------- | -| `SUBMIT_CONTRACT_INTERACTIONS` | boolean | `true` | Submit contract interactions | +| Variable | Type | Default | Description | +| ------------------------------ | ------- | ------- | ------------------------------------- | +| `SUBMIT_CONTRACT_INTERACTIONS` | boolean | `true` | Submit observations to Solana programs | ### Offset Observation @@ -362,16 +357,6 @@ For detailed configuration and usage, see [CDB64 Root TX Index](/build/run-a-gat | ------------------------------- | ------ | ------- | -------------------------- | | `REPORT_GENERATION_INTERVAL_MS` | string | - | Report generation interval | -### AO (Autonomous Objects) - -| Variable | Type | Default | Description | -| ------------------- | ------ | ------- | ----------------- | -| `AO_CU_URL` | string | - | AO CU URL | -| `NETWORK_AO_CU_URL` | string | - | Network AO CU URL | -| `AO_MU_URL` | string | - | AO MU URL | -| `AO_GATEWAY_URL` | string | - | AO Gateway URL | -| `AO_GRAPHQL_URL` | string | - | AO GraphQL URL | - ### Data Paths | Variable | Type | Default | Description | diff --git a/content/build/run-a-gateway/manage/filters.mdx b/content/build/run-a-gateway/manage/filters.mdx index cac849ecf..0f915d3e6 100644 --- a/content/build/run-a-gateway/manage/filters.mdx +++ b/content/build/run-a-gateway/manage/filters.mdx @@ -762,10 +762,4 @@ Now that you understand gateway filtering, continue building your infrastructure description="Accept data uploads directly through your gateway" href="/build/extensions/bundler" /> - } - title="Run Compute Unit" - description="Execute AO processes locally for maximum efficiency" - href="/build/extensions/compute-unit" - /> diff --git a/content/build/upload/turbo-credits.mdx b/content/build/upload/turbo-credits.mdx index 1a53e22af..e1a2825a9 100644 --- a/content/build/upload/turbo-credits.mdx +++ b/content/build/upload/turbo-credits.mdx @@ -51,11 +51,10 @@ Top up any address of a [supported wallet type](#supported-wallet-types) by payi | Network | Tokens | | ----------- | -------------- | | Arweave | [AR](https://www.coingecko.com/en/coins/arweave) | -| AO | [ARIO](https://www.coingecko.com/en/coins/ar-io-network) | -| Base | [ARIO](https://basescan.org/token/0x138746adfA52909E5920def027f5a8dc1C7EfFb6), [ETH](https://www.coingecko.com/en/coins/ethereum), [USDC](https://basescan.org/token/0x833589fcd6edb6e08f4c7c32d4f71b54bda02913), [ARIO](https://basescan.org/token/0x138746adfA52909E5920def027f5a8dc1C7EfFb6)| +| Solana | [ARIO](https://www.coingecko.com/en/coins/ar-io-network), [SOL](https://www.coingecko.com/en/coins/solana) | +| Base | [ARIO](https://basescan.org/token/0x138746adfA52909E5920def027f5a8dc1C7EfFb6), [ETH](https://www.coingecko.com/en/coins/ethereum), [USDC](https://basescan.org/token/0x833589fcd6edb6e08f4c7c32d4f71b54bda02913) | | Ethereum | [ETH](https://www.coingecko.com/en/coins/ethereum), [USDC](https://etherscan.io/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48) | | Polygon | [POL](https://www.coingecko.com/en/coins/polygon), [USDC](https://polygonscan.com/address/0x3c499c542cef5e3811e1192ce70d8cc03d5c3359) | -| Solana | [SOL](https://www.coingecko.com/en/coins/solana) | | Cosmos | [KYVE](https://www.coingecko.com/en/coins/kyve-network) | ### Supported Payment Wallets @@ -63,8 +62,6 @@ Top up any address of a [supported wallet type](#supported-wallet-types) by payi | Network Type | Signature Types | Supported Wallets | | ------------ | -------------- | ------------------------------------------------------ | | Arweave | RSA | JWK Keyfile, [Wander](https://www.wander.app/), [Beacon](https://getbeaconapp.com/) | -| AO | RSA | JWK Keyfile, [Wander](https://www.wander.app/), [Beacon](https://getbeaconapp.com/) | -| AO | ECDSA (secp256k1) | JSON Keystore File, [MetaMask](https://metamask.io/), [Rainbow](https://rainbow.me/), [Brave](https://brave.com/wallet/), [WalletConnect](https://walletconnect.com/), [Privy](https://www.privy.io/) | | EVM | ECDSA (secp256k1) | JSON Keystore File, [MetaMask](https://metamask.io/), [Rainbow](https://rainbow.me/), [Brave](https://brave.com/wallet/), [WalletConnect](https://walletconnect.com/), [Privy](https://www.privy.io/) | | Solana | ED25519 | JSON Keypair File, [Phantom](https://phantom.com/), [Solflare](https://www.solflare.com/) | | Cosmos | secp256k1 | Keyfile | @@ -124,7 +121,7 @@ Direct API integration is available at [payment.ardrive.io/api-docs](https://pay | **ETH (Base)** | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | | **SOL** | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | | **POL** | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | -| **ARIO (AO)** | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | +| **ARIO (Solana)** | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | | **ARIO (Base)** | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | | **USDC (L1)** | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ | | **USDC (Base)** | ✅ | ✅ | ✅ | ✅ | ❌ | ✅ | @@ -139,7 +136,7 @@ JIT payments are available via the Turbo SDK, CLI, or direct HTTP API integratio | Token / Currency | Network | JIT Supported | | ---------------------- | -------- | ------------- | -| ARIO | AO | ✅ | +| ARIO | Solana | ✅ | | ARIO | Base | ✅ | | SOL | Solana | ✅ | | ETH | Base | ✅ | @@ -208,7 +205,7 @@ Credits can be shared via the Turbo App at [turbo.ar.io](https://turbo.ar.io) or | Currency | Top Up Fee Percentage | | ----------------- | --------------------- | -| ARIO (AO or Base) | NO FEE | +| ARIO (Solana or Base) | NO FEE | | KYVE | 50% | | All others | 23.4% | diff --git a/content/glossary/index.mdx b/content/glossary/index.mdx index ca3fd569e..0b999036c 100644 --- a/content/glossary/index.mdx +++ b/content/glossary/index.mdx @@ -5,7 +5,35 @@ description: "Key terms and definitions for the ar.io ecosystem" ## AO Computer -AO (Actor Oriented) is a hyper-parallel computing platform built on Arweave that enables decentralized applications to run with unlimited computational capacity. AO provides the compute layer for ar.io's smart contracts and token operations. +AO (Actor Oriented) is a hyper-parallel computing platform built on Arweave that enables decentralized applications to run with unlimited computational capacity. AO continues to exist as an independent compute layer in the broader Arweave ecosystem. The ar.io protocol previously ran on AO and has since migrated protocol execution to Solana. + +## SPL Token + +Solana Program Library token standard. ARIO is implemented as an SPL Token on Solana, making it compatible with the full Solana wallet and DeFi ecosystem. + +## PDA (Program Derived Address) + +Deterministic Solana account addresses derived from a program ID and a set of seeds. The ar.io protocol uses PDAs extensively — for gateways, delegations, withdrawals, vaults, ArNS records, ANT configs, and more. + +## Metaplex Core + +The NFT standard used for Arweave Name Tokens (ANTs) on Solana. Metaplex Core assets are tradeable on standard NFT marketplaces like Tensor and Magic Eden. + +## CPI (Cross-Program Invocation) + +The mechanism by which Solana programs call into each other. The ar.io architecture uses CPI for token operations — ario-gar and ario-arns call into ario-core for SPL Token transfers. + +## Cranker + +A permissionless bot that drives the 6-step epoch pipeline on Solana. Anyone can run a cranker — the instructions are idempotent and safe to execute multiple times. Crankers can run as standalone bots or be embedded in ar.io observers. + +## Epoch Pipeline + +The 6-step process for observation, reward calculation, and distribution each epoch: create_epoch → tally_weights → prescribe_epoch → save_observations → distribute_epoch → close_epoch. + +## Reward Accumulator + +A pattern for distributing delegate rewards on Solana. Rather than distributing to each delegate individually each epoch, the protocol tracks a cumulative reward-per-token on each gateway. Pending rewards are settled when the delegator interacts with the protocol. ## Winston @@ -17,11 +45,11 @@ Winston Credits (`winc`) are the unit used by Turbo to represent upload purchasi ## Public Key -A cryptographic key that can be shared publicly and is used to verify digital signatures or encrypt data. In the ar.io context, public keys are used to identify wallet addresses and verify transactions. +A cryptographic key that can be shared publicly and is used to verify digital signatures or encrypt data. In the ar.io context, Solana public keys (Ed25519, base58-encoded) are used to identify wallet addresses and verify transactions. ## Native Address -An address format that uses the raw public key bytes directly, without additional encoding or transformation. This is the most basic form of an Arweave address. +An address format that uses the raw public key bytes directly, without additional encoding or transformation. ## Normalized Address diff --git a/content/learn/(introduction)/what-is-ario.mdx b/content/learn/(introduction)/what-is-ario.mdx index 24a3e71ba..d6521d44c 100644 --- a/content/learn/(introduction)/what-is-ario.mdx +++ b/content/learn/(introduction)/what-is-ario.mdx @@ -7,7 +7,7 @@ import { Code, Server, Globe, Database } from 'lucide-react'; Ar.io is the first permanent cloud network. -A decentralized infrastructure layer built on Arweave and AO, making permanent data accessible, discoverable, and usable. Think of it as the gateway to Arweave's permaweb, turning its tamper-proof storage into a fully functional, user-friendly ecosystem for apps, websites, and data. +A decentralized infrastructure layer built on Arweave for permanent data storage, with protocol execution on Solana. Think of it as the gateway to Arweave's permaweb, turning its tamper-proof storage into a fully functional, user-friendly ecosystem for apps, websites, and data.
diff --git a/content/learn/arns/ants.mdx b/content/learn/arns/ants.mdx index a79102532..fcee17be1 100644 --- a/content/learn/arns/ants.mdx +++ b/content/learn/arns/ants.mdx @@ -6,19 +6,21 @@ description: "Learn about Arweave Name Tokens (ANTs) - the ownership and control import { Card, Cards } from 'fumadocs-ui/components/card'; import { Calculator, FileText, Code } from 'lucide-react'; -To establish ownership of a record in the ArNS Registry, each record contains both a friendly name and a reference to an Arweave Name Token, ANT. Name Tokens are unique AO Computer based tokens/processes that give their owners the ability to update the Arweave Transaction IDs that their associated friendly names point to. +To establish ownership of a record in the ArNS Registry, each record contains both a friendly name and a reference to an Arweave Name Token (ANT). ANTs are [Metaplex Core](https://developers.metaplex.com/core) NFTs on Solana that give their owners the ability to update the Arweave Transaction IDs that their associated friendly names point to. ## What is an ANT? -The ANT smart contract process is a standardized contract that implements the specific Arweave Name Process specification required by ar.io gateways who resolve ArNS names and their Arweave Transaction IDs. It also contains other basic functionality to establish ownership and the ability to transfer ownership and update the Arweave Transaction ID. +An ANT is a Metaplex Core NFT managed by the `ario-ant` Solana program. It implements the Arweave Name Token specification required by ar.io gateways who resolve ArNS names and their Arweave Transaction IDs. It also contains functionality to establish ownership, transfer ownership (including via NFT marketplaces like Tensor and Magic Eden), and update the Arweave Transaction ID. Name Tokens have an owner, who can transfer the token and control its modifiable settings. These settings include modifying the address resolution time to live (ttl) for each name contained in the ANT, and other settings like the ANT Name, Ticker, and an ANT Controller. ## Ownership and Control -The controller can only manage the ANT and set and update records, name, and the ticker, but cannot transfer the ANT. Note that ANTs are initially created in accordance with network standards by an end user who then has the ability to transfer its ownership or assign a controller as they see fit. +The controller can only manage the ANT and set and update records, name, and the ticker, but cannot transfer the ANT. Each ANT supports up to 10 controllers. The root (@) record cannot be removed, only updated — ensuring the name always resolves. -Owners of names should ensure their ANT supports evolve ability if future modifications are desired. Loss of a private key for a permanently purchased name can result in the name being "bricked". +ANTs are initially minted in accordance with network standards by an end user who then has the ability to transfer its ownership or assign controllers as they see fit. When an ANT is transferred via a marketplace (outside the ar.io protocol), controllers are cleared on the next write operation via lazy reconciliation, ensuring the new owner has full control. + +Loss of a private key for a permanently purchased name can result in the name being inaccessible. ### Under_name Ownership @@ -44,7 +46,7 @@ The table below indicates some of the possible interactions with the ArNS regist | Transfer ownership | ✔ | | | | | Add / remove controllers | ✔ | | | | | Approve/Remove Primary name | ✔ | | ✔ | | -| Reassign name to new ANT process | ✔ | | | | +| Reassign name to new ANT | ✔ | | | | | Return a permanent name | ✔ | | | | | Set records (pointers, record metadata) | ✔ | ✔ | ✔ | | | Update records, name, ticker | ✔ | ✔ | | | @@ -62,7 +64,9 @@ Under*names use an underscore "*" in place of a more typically used dot "." to s ## Secondary Markets -Secondary markets could be created by ecosystem partners that facilitate the trading of Name Tokens. Additionally, tertiary markets could be created that support the leasing of these friendly names to other users. Such markets, if any, would be created by third parties unrelated to and outside of the scope of this paper or control of the Foundation. +Since ANTs are standard Metaplex Core NFTs, they are tradeable on any compatible NFT marketplace, including **Tensor** and **Magic Eden**. When an ANT is sold on a marketplace, lazy reconciliation clears the existing controllers on the next write operation, ensuring the new owner gets clean control. + +Additionally, tertiary markets could be created that support the leasing of these friendly names to other users. ## Next Steps diff --git a/content/learn/arns/index.mdx b/content/learn/arns/index.mdx index a059d31a2..c2f4b8050 100644 --- a/content/learn/arns/index.mdx +++ b/content/learn/arns/index.mdx @@ -18,11 +18,11 @@ It's an open, permissionless, domain name registrar that doesn't rely on a singl This system works similarly to traditional DNS services, where users can purchase a name in a registry and DNS Name servers resolve these names to IP addresses. The system is flexible and allows users to purchase names permanently or lease them for a defined duration based on their use case. -With ArNS, the registry is stored permanently on Arweave via [AO](/glossary), making it immutable and globally resilient. This also means that apps and infrastructure cannot just read the latest state of the registry but can also check any point in time in the past, creating a "Wayback Machine" of permanent data. +With ArNS, the registry is stored on Solana via the `ario-arns` program (NameRegistry with up to 50,000 name slots), making it globally resilient and fast to query. Historical state is archived to Arweave, meaning apps and infrastructure can check any point in time in the past, creating a "Wayback Machine" of permanent data. ```mermaid graph TB - subgraph "ar.io Smart Contract" + subgraph "ar.io Solana Programs" Registry[ArNS Registry] Registry --> Name1[ardrive] Registry --> Name2[ao] @@ -30,10 +30,10 @@ graph TB Registry --> NameN[...] end - subgraph "Arweave Name Token" - Name1 -.->|owned by| ANT1[Owner: 0x242424...
Record: @
Target: TxID_123] - Name2 -.->|owned by| ANT2[Owner: Zjgamagh...
Record: @
Target: TxID_456] - Name3 -.->|owned by| ANT3[Owner: Hboaalf...
Record: @
Target: TxID_789] + subgraph "ANTs (Metaplex Core NFTs)" + Name1 -.->|owned by| ANT1[Owner: 7xKXt...
Record: @
Target: TxID_123] + Name2 -.->|owned by| ANT2[Owner: 3mPqR...
Record: @
Target: TxID_456] + Name3 -.->|owned by| ANT3[Owner: 9vLwN...
Record: @
Target: TxID_789] end subgraph "Arweave" @@ -53,11 +53,11 @@ graph TB ## Name Resolution -Users can register a name, like `ardrive`, within the ArNS Registry. Before owning a name, they must create an Arweave Name Token (ANT), an AO Computer based token and open-source protocol used by ArNS to track the ownership and control over the name. +Users can register a name, like `ardrive`, within the ArNS Registry. Before owning a name, they must create an Arweave Name Token (ANT), a Metaplex Core NFT on Solana used by ArNS to track the ownership and control over the name. ANTs allow the owner to set a mutable pointer to any type of permaweb data, like a page, app or file, via its Arweave transaction ID. -Each ar.io gateway acts as an ArNS Name resolver. They fetch the latest state of both the ArNS Registry and its associated ANTs from an AO compute unit (CU) and serve this information rapidly for apps and users. +Each ar.io gateway acts as an ArNS Name resolver. They fetch the latest state of both the ArNS Registry and its associated ANTs from Solana and serve this information rapidly for apps and users. Ar.io gateways will also resolve that name as one of their own subdomains, e.g., `https://ardrive.arweave.net` and proxy all requests to the associated Arweave transaction ID. This means that ANTs work across all ar.io gateways that support them: `https://ardrive.ar-io.dev`, `https://ardrive.g8way.io/`, etc. diff --git a/content/learn/arns/meta.json b/content/learn/arns/meta.json index a5a92bd54..e18ad6626 100644 --- a/content/learn/arns/meta.json +++ b/content/learn/arns/meta.json @@ -1,5 +1,5 @@ { "title": "Arweave Name System (ArNS)", - "pages": ["name-registration", "ants", "pricing-model"], + "pages": ["name-registration", "ants", "pricing-model", "returned-names"], "defaultOpen": false } diff --git a/content/learn/arns/name-registration.mdx b/content/learn/arns/name-registration.mdx index a5cf8ffc2..d4af33a39 100644 --- a/content/learn/arns/name-registration.mdx +++ b/content/learn/arns/name-registration.mdx @@ -19,11 +19,11 @@ Registering a name requires spending ARIO tokens corresponding to the name's cha ## Name Registry -The ArNS Registry is a list of all registered names and their associated ANT Process IDs. Key rules embedded within the smart contract include: +The ArNS Registry is a list of all registered names and their associated ANT mint addresses, stored on Solana in the NameRegistry zero-copy account (up to 50,000 names). Key rules embedded within the Solana programs include: - **Genesis Prices**: Set within the contract as starting conditions - **Dynamic Pricing**: Varies based on name length, purchase type (lease vs buy), lease duration, and current Demand Factor -- **Name Records**: Include a pointer to the Arweave Name Token process identifier, lease end time (if applicable), and undername allocation +- **Name Records**: Include a pointer to the Arweave Name Token (ANT) mint address, lease end time (if applicable), and undername allocation - **Reassignment**: Name registrations can be reassigned from one ANT to another - **Lease Extension**: Anyone with available ARIO Tokens can extend any name's active lease - **Lease to Permanent Buy**: Anyone with available ARIO Tokens can convert a name's lease to a permanent buy @@ -38,7 +38,9 @@ All names registered must meet the following criteria: 2. **Dash placement**: Dashes cannot be leading or trailing characters 3. **Single character domains**: Dashes cannot be used in single character domains 4. **Length limits**: 1 character minimum, 51 characters maximum -5. **Reserved names**: Cannot be an invalid name predesignated to prevent unintentional use/abuse such as `www` +5. **43-character prohibition**: Names exactly 43 characters long are prohibited to prevent Arweave Transaction ID collisions +6. **Lowercase enforcement**: Names must be lowercase at submission +7. **Reserved names**: Cannot be an invalid name predesignated to prevent unintentional use/abuse such as `www` ## Lease Management @@ -46,7 +48,7 @@ All names registered must meet the following criteria: When a lease term ends, there is a **grace period of two (2) weeks** where the lease can be renewed before it fully expires. If this grace period elapses, the name is considered expired and returns to the protocol for public registration. Once expired, a name's associated undername registrations and capacity also expire. -A recently expired name's registration shall be priced subject to the "Returned Name Premium" mechanics. +A recently expired name enters a **Returned Name Dutch Auction**: starting at 50× the base price, decaying to 1× over 14 days. Revenue from returned name purchases is split 50/50 between the protocol and the previous owner. ### Lease to Permabuy Conversions diff --git a/content/learn/arns/pricing-model.mdx b/content/learn/arns/pricing-model.mdx index 27add14ff..74f5f19ac 100644 --- a/content/learn/arns/pricing-model.mdx +++ b/content/learn/arns/pricing-model.mdx @@ -7,7 +7,7 @@ import { Globe, Database, Code } from "lucide-react"; ## Addressing Variable Market Conditions -The future market landscape is unpredictable, and ar.io's smart contract is designed to be immutable, operating without governance or manual intervention. Using a pricing oracle to fix name prices relative to a stable currency is not viable due to the infancy of available solutions and reliance on external dependencies. +The future market landscape is unpredictable, and ar.io's Solana programs are designed to operate without governance or manual intervention. Using a pricing oracle to fix name prices relative to a stable currency is not viable due to the infancy of available solutions and reliance on external dependencies. To address these challenges, ArNS is self-contained and adaptive, with name prices reflecting network activity and market conditions over time. @@ -16,7 +16,7 @@ To achieve this, ArNS incorporates: 1. A **dynamic pricing model** that adjusts fees using a "Demand Factor" based on ArNS purchase activity 2. A **Returned Name Premium (RNP)** system that applies a timed, descending multiplier to registration prices for names that have recently expired or been returned to the protocol -This approach ensures that name valuations adapt to market conditions within the constraints of an immutable, maintenance-free smart contract framework. +This approach ensures that name valuations adapt to market conditions within the constraints of the on-chain protocol. Additionally, **fee halving** occurs when the demand factor stays at minimum (0.5×) for 7 consecutive periods, permanently halving all base fees. A `get_token_cost` view instruction is available via `simulateTransaction` for cost estimation. You can view current live pricing at [ArNS.app](https://arns.ar.io/#/prices) to see these formulas in action. diff --git a/content/learn/arns/returned-names.mdx b/content/learn/arns/returned-names.mdx new file mode 100644 index 000000000..0c1641124 --- /dev/null +++ b/content/learn/arns/returned-names.mdx @@ -0,0 +1,76 @@ +--- +title: 'Returned Names' +description: 'How returned ArNS names are repriced through a Dutch auction mechanism' +--- + +## Overview + +When an ArNS name expires or is voluntarily returned to the protocol, it enters a **Returned Name Dutch Auction** before becoming available for standard registration. This mechanism prevents name squatting at expiry and provides fair pricing through a time-decaying premium. + +## Dutch Auction Mechanics + +Returned names start at a high premium and decay to the base price over 14 days: + +- **Starting price**: 50× the base registration price +- **Ending price**: 1× the base registration price (standard rate) +- **Duration**: 14 days +- **Decay**: Continuous exponential decay from 50× to 1× + +```mermaid +graph LR + A[Name Expired
or Released] --> B[Dutch Auction
Starts at 50x] + B --> C[Price Decays
Over 14 Days] + C --> D[Reaches 1x
Base Price] + D --> E[Standard
Registration] +``` + +## Revenue Split + +When a returned name is purchased during the Dutch auction: + +- **50%** goes to the **protocol balance** (funds epoch rewards) +- **50%** goes to the **previous owner** (the ANT holder at the time of return) + +This incentivizes name owners to voluntarily release names they no longer need, since they receive half the resale value. + +## How Names Enter the Returned Pool + +### Lease Expiration +When a leased name's term ends and the 14-day grace period elapses without renewal, the name enters the returned pool. + +### Voluntary Release +Permanent name owners can voluntarily release their name back to the protocol using the `releaseName` instruction. This immediately places the name in the returned pool. + +## Lifecycle + +| Phase | Duration | Price | Action | +|-------|----------|-------|--------| +| **Active lease** | As registered | N/A | Name is in use | +| **Grace period** | 14 days after expiry | N/A | Owner can renew | +| **Dutch auction** | 14 days | 50× → 1× | Anyone can purchase | +| **Standard registration** | Indefinite | Base price | Normal ArNS purchase | + +## Querying Returned Names + +Use the SDK to check available returned names and their current auction price: + +```typescript +const ario = ARIO.mainnet(); + +// Get all active returned names +const returnedNames = await ario.getArNSReturnedNames({ + limit: 100, + sortBy: 'endTimestamp', + sortOrder: 'asc', +}); + +// Get a specific returned name +const name = await ario.getArNSReturnedName({ name: 'example' }); + +// Check current cost (includes auction premium) +const cost = await ario.getTokenCost({ + intent: 'Buy-Name', + name: 'example', + type: 'permabuy', +}); +``` diff --git a/content/learn/gateways/gateway-registry.mdx b/content/learn/gateways/gateway-registry.mdx index 9aee9e22e..220c116c3 100644 --- a/content/learn/gateways/gateway-registry.mdx +++ b/content/learn/gateways/gateway-registry.mdx @@ -1,15 +1,17 @@ --- title: "Gateway Registry" -description: "Ar.io consists of ar.io gateway nodes, which are identified by their registered Arweave wallet addresses and either their IP addresses or hostnames, as stored in the network" +description: "Ar.io consists of ar.io gateway nodes, which are identified by their registered Solana wallet addresses and either their IP addresses or hostnames, as stored in the network" --- import { Network, Target, Shield, Settings } from 'lucide-react'; ## Overview -Ar.io consists of [ar.io gateway nodes](/learn/what-is-ario), which are identified by their registered Arweave wallet addresses and either their IP addresses or hostnames, as stored in the network's [smart contract](/learn/token) Gateway Address Registry (GAR). +Ar.io consists of [ar.io gateway nodes](/learn/what-is-ario), which are identified by their registered Solana wallet addresses (Ed25519 pubkeys) and either their IP addresses or hostnames, as stored in the network's [Solana programs](/learn/token/architecture) Gateway Address Registry (GAR). -Any gateway operator that wishes to join ar.io must register their node in the ar.io smart contract's Gateway Address Registry. Registration involves staking a minimum amount of ARIO tokens and providing additional metadata describing the gateway service offered. +The gateway registry supports up to **3,000 gateways** via a zero-copy on-chain registry. Any gateway operator that wishes to join ar.io must register their node in the ario-gar program's Gateway Address Registry. Registration involves staking a minimum of **10,000 ARIO** tokens (plus SOL for transaction fees) and providing additional metadata describing the gateway service offered. + +Each gateway must have a **unique observer address** — no two gateways can share the same observer. This is enforced by an ObserverLookup PDA on-chain. These nodes adhere to ar.io's protocols, creating a collaborative environment of gateway nodes that vary in scale and specialization. The network promotes a fundamental level of service quality and trust minimization among its participants. @@ -56,7 +58,8 @@ The Gateway Registry is the foundation of the ar.io network's decentralized infr - **Staking & Rewards**: Gateways earn rewards based on performance through a sophisticated [staking system](/learn/token/staking) that includes delegation opportunities - **Discoverability**: The GAR enables apps and users to find suitable gateways based on their needs - **Performance-Based Selection**: Gateway metadata allows for intelligent routing based on stake, performance, and capabilities -- **Transparent Ecosystem**: All gateway information is publicly accessible through the smart contract and at gateways.ar.io +- **Gateway Pruning**: Gateways that fail 30 consecutive epochs have 100% of their minimum stake slashed and are removed from the network +- **Transparent Ecosystem**: All gateway information is publicly accessible through the Solana programs and at gateways.ar.io By joining the network, gateways become part of a collaborative ecosystem that rewards quality service and ensures reliable access to the permaweb. diff --git a/content/learn/gateways/index.mdx b/content/learn/gateways/index.mdx index ffb720591..e2499c717 100644 --- a/content/learn/gateways/index.mdx +++ b/content/learn/gateways/index.mdx @@ -66,8 +66,8 @@ It's important to understand the boundaries of what ar.io gateways do and don't ### Not Compute Platforms -- **Don't depend on AO**: Gateways operate independently of any compute layer -- **Don't execute smart contracts**: Computation happens on AO or other platforms, not gateways +- **Don't depend on Solana for data serving**: Gateways operate independently — Solana is only used for protocol state (registry, staking, ArNS) +- **Don't execute smart contracts**: Protocol logic runs on Solana programs, not gateways - **Don't process application logic**: Gateways focus purely on data access and delivery ### Not Centralized Services diff --git a/content/learn/gateways/meta.json b/content/learn/gateways/meta.json index 7472de369..7bc5ab22e 100644 --- a/content/learn/gateways/meta.json +++ b/content/learn/gateways/meta.json @@ -5,6 +5,7 @@ "data-retrieval", "data-verification", "gateway-registry", + "pruning", "x402-payments" ], "defaultOpen": false diff --git a/content/learn/gateways/pruning.mdx b/content/learn/gateways/pruning.mdx new file mode 100644 index 000000000..e2e7410e6 --- /dev/null +++ b/content/learn/gateways/pruning.mdx @@ -0,0 +1,55 @@ +--- +title: 'Gateway Pruning' +description: 'How underperforming gateways are removed from the ar.io network through automated pruning' +--- + +## Overview + +The ar.io network uses an automated pruning mechanism to remove gateways that consistently fail to meet performance standards. This ensures network quality by removing unreliable infrastructure and returning slashed stake to the protocol balance. + +## How Pruning Works + +A gateway is pruned when it **fails observation for 30 consecutive epochs** (approximately 30 days). When pruned: + +1. **100% of minimum stake is slashed** — the minimum 10,000 ARIO stake is returned to the protocol balance +2. **Gateway is removed** from the GatewayRegistry +3. **Excess operator stake** enters the standard withdrawal process (90-day delay) +4. **Delegated stakes** enter the standard withdrawal process — delegators can claim after the delay or use expedited withdrawal + +```mermaid +graph TD + A[Gateway fails epoch] --> B{30 consecutive
failures?} + B -->|No| C[Counter increments] + C --> A + B -->|Yes| D[Gateway pruned] + D --> E[Min stake slashed
to protocol] + D --> F[Excess stake enters
withdrawal queue] + D --> G[Delegated stakes enter
withdrawal queue] +``` + +## Failure Tracking + +Each gateway's consecutive failure count is tracked on-chain in the Gateway PDA: + +- **Pass**: Counter resets to 0 +- **Fail**: Counter increments by 1 +- **30 consecutive failures**: Triggers automatic pruning via the `prune_gateway` instruction + +The `prune_gateway` instruction is permissionless — anyone can call it once the failure threshold is reached. + +## Impact on Delegators + +When a gateway is pruned, delegators' stakes are not slashed — only the operator's minimum stake is affected. Delegated stakes enter the standard 90-day withdrawal process, and delegators can: + +- **Wait for withdrawal**: Tokens are released after the 90-day delay +- **Expedited withdrawal**: Pay a fee (50% → 10% linear decay over 90 days) to receive tokens immediately +- **Claim from leaving gateway**: Use the `claim_delegate_from_leaving_gateway` instruction + +## Prevention + +Gateway operators can avoid pruning by: + +- **Maintaining uptime**: Ensure the gateway is accessible and responding to health checks +- **Correct ArNS resolution**: Verify that the gateway correctly resolves ArNS names +- **Observer wallet**: Ensure the observer wallet is funded with SOL and submitting observations +- **Monitoring**: Use the [Gateway Portal](https://gateways.ar.io) to track performance metrics and consecutive failure count diff --git a/content/learn/oip/cranker.mdx b/content/learn/oip/cranker.mdx new file mode 100644 index 000000000..384e556f5 --- /dev/null +++ b/content/learn/oip/cranker.mdx @@ -0,0 +1,62 @@ +--- +title: 'Cranker' +description: 'The permissionless cranker bot that drives the ar.io epoch pipeline on Solana' +--- + +## What is a Cranker? + +A cranker is a permissionless bot that executes the 6-step [epoch pipeline](/learn/oip/epoch-pipeline) on Solana. Since Solana programs cannot execute on a timer, an external actor must call each instruction to advance the epoch lifecycle. + +The key property is that cranking is **permissionless** — any wallet with SOL for transaction fees can run it. No ARIO tokens, gateway registration, or special authorization is needed. + +## Why Cranking Matters + +On the previous AO backend, epochs were advanced atomically with a single `tick()` function. On Solana, the transaction size and compute budget limits make this impossible. The 6-step pipeline breaks the work into manageable transactions that anyone can submit. + +Without crankers, the epoch pipeline would stall — no observations would be prescribed, no rewards would be distributed. Multiple crankers create redundancy so the network is never dependent on a single operator. + +## Deployment Options + +### Standalone Bot + +The standalone cranker runs as an independent Docker container: + +```bash +docker run -d \ + --name ar-io-cranker \ + -e SOLANA_RPC_URL=https://your-rpc.com \ + -e WALLET_PRIVATE_KEY=your-base58-key \ + ghcr.io/ar-io/ar-io-cranker:latest +``` + +The standalone bot: +- Polls the epoch state on a regular interval +- Executes whichever pipeline step is needed next +- Includes health endpoints and Prometheus metrics +- Recommended: run 2-3 instances for redundancy + +### Observer Integration + +The cranker can also be embedded directly in ar.io observers: + +```bash +# In your observer's .env file +ENABLE_EPOCH_CRANKING=true +``` + +This uses the observer's existing wallet and RPC connection. Since the network may have hundreds of observers, this creates massive redundancy at zero additional cost. + +## Safety Properties + +- **Idempotent**: Every instruction can be called multiple times safely. Duplicate calls are no-ops. +- **Permissionless**: No special authority, ARIO tokens, or gateway registration required. +- **No privilege**: The cranker wallet has no special power — it just submits transactions that anyone could submit. +- **Low cost**: ~0.000155 SOL per full epoch (~$0.70/month). + +## Multi-Cranker Coordination + +Multiple crankers can run simultaneously without coordination: + +- **Optimistic concurrency**: All crankers attempt the same steps. The first successful transaction wins; subsequent attempts see the step is already done and skip it. +- **No wasted work**: Idempotent instructions mean duplicate attempts don't cause errors or double-distribution. +- **Cost of redundancy**: Minimal — only SOL transaction fees for the redundant (failed) transactions. diff --git a/content/learn/oip/epoch-pipeline.mdx b/content/learn/oip/epoch-pipeline.mdx new file mode 100644 index 000000000..3983211fc --- /dev/null +++ b/content/learn/oip/epoch-pipeline.mdx @@ -0,0 +1,99 @@ +--- +title: 'Epoch Pipeline' +description: 'The 6-step permissionless epoch pipeline for observation, reward calculation, and distribution on Solana' +--- + +## Overview + +On Solana, the ar.io epoch lifecycle is broken into 6 discrete, permissionless steps. Unlike the previous single atomic `tick()` operation on AO, each step is a separate Solana instruction that can be executed by anyone — no special permissions required. + +All steps are **idempotent** (safe to run multiple times) and **permissionless** (anyone can crank them). This design ensures the protocol cannot be halted by a single point of failure. + +## Pipeline Steps + +```mermaid +graph LR + A[create_epoch] --> B[tally_weights] + B --> C[prescribe_epoch] + C --> D[save_observations] + D --> E[distribute_epoch] + E --> F[close_epoch] +``` + +### 1. create_epoch + +**Initializes the epoch account and computes the reward rate.** + +- Creates the Epoch PDA for the new epoch index +- Computes the epoch reward allocation from the protocol balance +- Reward rate follows a linear decay: 0.1% per epoch → 0.05% over epochs 365–547 + +### 2. tally_weights + +**Batched computation of gateway weights for observer selection.** + +- Processes up to 15 gateways per transaction +- Computes a 4-factor composite weight for each gateway: + - **Stake weight**: Based on total stake (operator + delegated) + - **Tenure weight**: Based on how long the gateway has been in the network + - **Gateway performance**: Based on pass rate across recent epochs + - **Observer performance**: Based on observation submission history +- Multiple transactions are needed to tally all gateways + +### 3. prescribe_epoch + +**Selects observers and prescribed ArNS names via weighted roulette.** + +- Selects up to 50 observers using weighted random selection +- Entropy source: `SHA256(slot || epoch_index || timestamp)` +- Collision handling: 10× retry multiplier (up to 500 iterations) +- Selects 2 prescribed ArNS names that all observers must test + +### 4. save_observations + +**Observers submit their pass/fail observation reports.** + +- Each selected observer submits a bitmap of pass/fail results for tested gateways +- This is the only step that requires a specific signer (the selected observer) +- Observations are stored on the Epoch account + +### 5. distribute_epoch + +**Batched reward distribution to gateways and their delegates.** + +- Processes up to 15 gateways per transaction +- Functional gateways receive the Base Gateway Reward (BGR) +- Functional observers receive the Base Observer Reward (BOR) +- Deficient observers who are functional gateways have their reward reduced by 25% +- Operator rewards auto-compound into operator stake +- Delegate rewards are tracked via the reward-per-share accumulator (settled lazily) +- Leaving gateways receive 0 rewards + +### 6. close_epoch + +**Reclaims rent from old epoch accounts.** + +- Can only be called for epochs that are 7+ epochs old +- Recovers the SOL rent from the Epoch PDA account +- Keeps on-chain state lean over time + +## Timing + +Each epoch lasts **24 hours** (86,400 seconds). The pipeline steps can be executed at any time during or after the epoch: + +| Step | When | Batched? | +|------|------|----------| +| create_epoch | After previous epoch ends | No | +| tally_weights | After create_epoch | Yes (15/tx) | +| prescribe_epoch | After all weights tallied | No | +| save_observations | During observation window | No (per observer) | +| distribute_epoch | After observation window | Yes (15/tx) | +| close_epoch | After 7+ epochs | No | + +## Cost + +Running the full epoch pipeline costs approximately **0.000155 SOL** per epoch (~$0.02), or roughly **$0.70/month** at current SOL prices. This makes it economically trivial for anyone to participate. + +## Who Cranks? + +See the [Cranker](/learn/oip/cranker) documentation for details on the permissionless cranker bot that automates the epoch pipeline. diff --git a/content/learn/oip/index.mdx b/content/learn/oip/index.mdx index 9a510b5d3..23a8b6a77 100644 --- a/content/learn/oip/index.mdx +++ b/content/learn/oip/index.mdx @@ -18,7 +18,7 @@ The Observer Protocol operates through a systematic process where selected gatew ```mermaid sequenceDiagram - participant SC as ar.io Smart Contract + participant SC as ar.io Solana Programs participant OBS as Observer Gateway participant GW as Target Gateway participant AR as Arweave Network @@ -62,8 +62,8 @@ Each 24-hour epoch follows a structured process with specific responsibilities f ### Epoch Start -- **Smart Contract**: Selects up to 50 observers using weighted random selection -- **Smart Contract**: Generates 2 prescribed ArNS names for all observers to test +- **Solana Programs**: Selects up to 50 observers using weighted random selection +- **Solana Programs**: Generates 2 prescribed ArNS names for all observers to test - **Selected Observers**: Receive notification of selection and prescribed names ### Observation Phase @@ -77,12 +77,12 @@ Each 24-hour epoch follows a structured process with specific responsibilities f ### Reporting Phase - **Observers**: Upload detailed JSON reports to Arweave for transparency -- **Observers**: Submit failed gateway lists to the ar.io Smart Contract for consensus voting +- **Observers**: Submit failed gateway lists to the ar.io Solana Programs for consensus voting ### Evaluation and Distribution -- **Smart Contract**: Tallies all observer votes (≥50% pass = functional gateway) -- **Smart Contract**: Distributes rewards at epoch end based on performance +- **Solana Programs**: Tallies all observer votes (≥50% pass = functional gateway) +- **Solana Programs**: Distributes rewards at epoch end based on performance - **Functional Gateways/Observers**: Receive ARIO token rewards automatically ## Key Features diff --git a/content/learn/oip/meta.json b/content/learn/oip/meta.json index 33e3cb26c..a407b9402 100644 --- a/content/learn/oip/meta.json +++ b/content/learn/oip/meta.json @@ -2,6 +2,8 @@ "title": "Observation & Incentive Protocol", "defaultOpen": false, "pages": [ + "epoch-pipeline", + "cranker", "observer-selection", "reporting", "performance-evaluation", diff --git a/content/learn/oip/observer-selection.mdx b/content/learn/oip/observer-selection.mdx index 1a18ef958..8d72f1e8e 100644 --- a/content/learn/oip/observer-selection.mdx +++ b/content/learn/oip/observer-selection.mdx @@ -16,9 +16,9 @@ This creates a consistent evaluation framework where all observers test the same ## Selection Process -Up to **fifty (50)** gateways are selected as observers per epoch using a sophisticated weighted random selection system. The selection uses **hashchain entropy** from previous ar.io contract state messages to ensure unpredictable and tamper-resistant selection. +Up to **fifty (50)** gateways are selected as observers per epoch using a sophisticated weighted random selection system. The selection uses **slot-based entropy** — `SHA256(slot || epoch_index || timestamp)` — from Solana to ensure unpredictable and tamper-resistant selection. Collision handling uses a 10× retry multiplier (up to 500 iterations). -The hashchain-based entropy provides cryptographic randomness for selecting: +The entropy provides cryptographic randomness for selecting: - **Observer Gateways**: The 50 gateways chosen to perform observations - **Prescribed ArNS Names**: The 2 common names all observers must evaluate diff --git a/content/learn/oip/performance-evaluation.mdx b/content/learn/oip/performance-evaluation.mdx index d28249b3d..cb7f7028a 100644 --- a/content/learn/oip/performance-evaluation.mdx +++ b/content/learn/oip/performance-evaluation.mdx @@ -9,20 +9,20 @@ Consider the following classifications: - **Functional or Passed Gateways**: are gateways that meet or surpass the network's performance and quality standards, including ArNS resolution and chunk/offset validation (if selected). - **Deficient or Failed Gateways**: are gateways that fall short of the network's performance expectations, including failures in ArNS resolution or chunk/offset validation. -- **Functional or Submitted Observers**: are selected observers who diligently perform their duties and submit observation reports and contract interactions. -- **Deficient or Failed Observers**: are selected observers who do not fulfill their duty of submitting observation reports and contract interactions. +- **Functional or Submitted Observers**: are selected observers who diligently perform their duties and submit observation reports and on-chain observations. +- **Deficient or Failed Observers**: are selected observers who do not fulfill their duty of submitting observation reports and on-chain observations. ## Evaluation Process -At the end of an epoch, the ar.io Smart Contract processes observer submissions to determine gateway performance through a consensus-based vote tallying system. This evaluation transforms individual observer reports into network-wide performance assessments. +At the end of an epoch, the ar.io Solana programs processes observer submissions to determine gateway performance through a consensus-based vote tallying system. This evaluation transforms individual observer reports into network-wide performance assessments. ### Vote Tallying and Gateway Classification -After observers submit their detailed reports (see [Reporting](/learn/oip/reporting) for submission details), the smart contract performs consensus calculation: +After observers submit their detailed reports (see [Reporting](/learn/oip/reporting) for submission details), the protocol performs consensus calculation: **Vote Processing:** -- **Data Collection**: All observer contract interactions for each gateway are collected +- **Data Collection**: All observer on-chain observations for each gateway are collected - **Vote Counting**: Each observer submission contributes either a PASS or FAIL vote - **Majority Determination**: If ≥50% of submitted observer interactions indicate PASS, the gateway is considered Functional - **Binary Classification**: Gateways are classified as either Functional (eligible for rewards) or Deficient (ineligible for rewards) @@ -113,7 +113,7 @@ Where: ## Evaluation Timeline -Rewards are distributed **at the end of each epoch** by the ar.io Smart Contract directly based on the tallied observer votes. The smart contract processes all observer submissions and automatically distributes rewards to functional gateways and observers based on their performance during the epoch. +Rewards are distributed **at the end of each epoch** by the ar.io Solana programs directly based on the tallied observer votes. The smart contract processes all observer submissions and automatically distributes rewards to functional gateways and observers based on their performance during the epoch. ## Key Features diff --git a/content/learn/oip/reporting.mdx b/content/learn/oip/reporting.mdx index a551e6668..0c999314e 100644 --- a/content/learn/oip/reporting.mdx +++ b/content/learn/oip/reporting.mdx @@ -1,6 +1,6 @@ --- title: "Reporting" -description: "Learn about observer responsibilities for submitting reports to Arweave and the ar.io Smart Contract" +description: "Learn about observer responsibilities for submitting reports to Arweave and the ar.io Solana programs" --- ## Observer Responsibilities @@ -17,7 +17,7 @@ Observers must submit their findings through both channels to fulfill their duti - **Purpose**: Permanent audit trail and transparency - **Content**: Complete test results, timing data, and failure details -### 2. Contract Interactions to ar.io Smart Contract +### 2. On-Chain Observations to ar.io Solana Programs - **Format**: List of failed gateways - **Purpose**: Efficient vote tallying for consensus @@ -109,7 +109,7 @@ Observer performance directly impacts rewards and future participation: ### Successful Observer Performance -- **Observer Reward**: Observers who submit both reports and contract interactions receive the Observer Reward +- **Observer Reward**: Observers who submit both reports and on-chain observations receive the Observer Reward - **Future Selection**: Successful reporting improves Observer Performance Ratio Weight (OPRW) - **Increased Chances**: Higher OPRW increases likelihood of future observer selection and more reward opportunities @@ -124,7 +124,7 @@ Observer performance directly impacts rewards and future participation: The system tracks observer performance to ensure network quality: -- **Submission Tracking**: Both Arweave reports and contract interactions must be submitted +- **Submission Tracking**: Both Arweave reports and on-chain observations must be submitted - **Performance History**: Observer submission record affects future selection probability - **Reward Impact**: Consistent reporting builds credibility and increases earning potential diff --git a/content/learn/oip/reward-distribution.mdx b/content/learn/oip/reward-distribution.mdx index 7692526b5..3f8dab1d2 100644 --- a/content/learn/oip/reward-distribution.mdx +++ b/content/learn/oip/reward-distribution.mdx @@ -51,13 +51,28 @@ The reward distribution is contingent on the performance classifications derived Epoch reward distributions showing the relationship between eligible rewards (total available) and distributed rewards (actually paid out) across epochs. The difference represents rewards not distributed due to gateway or observer deficiencies.

-## Auto-Staking +## Epoch Pipeline -Gateways shall be given the option to have their reward tokens "auto-staked" to their existing stake or sent to their wallet as unlocked tokens. The default setting shall be "auto-staked". +On Solana, reward distribution is driven by a permissionless 6-step [cranker pipeline](/learn/oip/cranker) rather than a single atomic operation: + +1. **create_epoch** — Initialize epoch, compute reward rate +2. **tally_weights** — Batched weight computation (15 gateways per transaction) +3. **prescribe_epoch** — Select observers and prescribed names via weighted roulette +4. **save_observations** — Observers submit pass/fail reports +5. **distribute_epoch** — Batched reward distribution (15 gateways per transaction) +6. **close_epoch** — Reclaim rent after 7+ epochs + +All steps are permissionless and idempotent — anyone can crank them, and running them multiple times is safe. + +## Operator Rewards + +Operator rewards always **auto-compound** into the operator's stake. There is no toggle — operators must call `decrease_operator_stake` to realize rewards as liquid tokens. ## Distribution to Delegates -The protocol will automatically distribute a Functional Gateway's shared rewards with its delegates. The distribution will consider the gateway's total reward for the period (including observation rewards), the gateway's "Delegate Reward Share Ratio", and each delegate's stake proportional to the total delegation. +Delegate rewards use a **reward-per-share accumulator** pattern. Rather than distributing rewards to each delegate individually each epoch, the protocol tracks a cumulative reward-per-token on each gateway. Pending rewards are settled when the delegator interacts with the protocol (e.g., delegate more, withdraw, or claim rewards). + +Leaving gateways receive 0 rewards for any epoch in which they have initiated withdrawal. Each individual delegate reward is calculated as: diff --git a/content/learn/token/add-to-wander.mdx b/content/learn/token/add-to-wander.mdx deleted file mode 100644 index e0fff7667..000000000 --- a/content/learn/token/add-to-wander.mdx +++ /dev/null @@ -1,161 +0,0 @@ ---- -title: 'Add to Wander' -description: 'Step-by-step guide to adding the ARIO token to your Wander wallet for viewing balances and managing tokens' ---- - -## Adding ARIO Token to Wander - -Wander (formerly ArConnect) is the primary wallet for the Arweave ecosystem and provides native support for AO tokens like ARIO. Follow this guide to add ARIO to your wallet and start viewing your token balance. - -## Prerequisites - -Before adding ARIO to your Wander wallet, ensure you have: - -- **Wander Wallet Installed**: Download from [wander.app](https://wander.app) for desktop or mobile -- **Wallet Setup Complete**: Your wallet should be created and secured with a backup phrase -- **Active Internet Connection**: Required for token import and balance queries - -## Step-by-Step Workflow - - - - ### Open Wander Wallet - - Launch your Wander wallet application: - - **Desktop**: Open the Wander desktop application - - **Mobile**: Tap the Wander app icon on your device - - - - ### Access Settings Menu - - Navigate to the settings section of your wallet: - - **For Mobile Users:** - 1. Tap the **3 vertical dots** (⋮) in the top right corner of the screen - 2. Select **"Settings"** from the dropdown menu - - **For Desktop Users:** - 1. Click the **hamburger menu icon** (☰) in the bottom right corner - 2. Navigate to the settings section - - - - ### Navigate to Token Management - - 1. In the Settings menu, select **"Tokens"** - 2. This opens the token management interface where you can view and add tokens - - - - ### Import New Token - - 1. Click the **"Import Token"** button - 2. You'll see a form for adding new token details - - - - ### Configure Token Type (Desktop Only) - - **For Desktop Users:** - - Ensure the **"Asset/Collectible"** dropdown is set to **"Asset"** - - This tells Wander that you're adding a fungible token, not an NFT - - - - ### Enter ARIO Token Details - - 1. In the **Process ID** field, enter the ARIO token process ID: - ``` - qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE - ``` - - 2. Once you enter the Process ID, Wander will automatically populate: - - **Token Ticker**: "ARIO" - - **Token Name**: "ar.io Network" - - 3. Verify that the auto-populated information is correct - - - - ### Complete the Import - - 1. Click **"Add Token"** to complete the import process - 2. Wander will add ARIO to your token list and begin querying your balance - - - - ### Verify Token Addition - - After successful import, you should see: - - ARIO listed in your wallet's token section - - Your current ARIO balance (if you hold any tokens) - - The ARIO token logo and ticker - - - -## Viewing Your ARIO Balance - -Once ARIO is added to your Wander wallet: - -### Main Wallet View -- Your total ARIO balance appears alongside other tokens -- Balances update automatically when you receive or send tokens -- Tap/click on ARIO to view detailed transaction history - -### Token Details -- **Balance**: Current ARIO token holdings -- **Value**: Estimated value (if price data is available) -- **Transactions**: Recent ARIO transaction history -- **Actions**: Send, receive, and manage tokens - -## Managing ARIO Tokens - -### Sending ARIO -1. Select ARIO from your token list -2. Click **"Send"** -3. Enter recipient address and amount -4. Confirm transaction details and send - -### Receiving ARIO -1. Select ARIO from your token list -2. Click **"Receive"** -3. Share your wallet address or QR code -4. Incoming tokens will appear automatically - -### Transaction History -- View all ARIO transactions in the token detail view -- Check transaction status and confirmations -- Access transaction IDs for verification - -## Troubleshooting - -### Token Not Appearing -If ARIO doesn't appear after import: -- **Refresh**: Try refreshing the wallet or restarting the app -- **Process ID**: Verify you entered the correct process ID -- **Network**: Check your internet connection -- **Support**: Contact Wander support if issues persist - -### Balance Not Updating -If your balance isn't showing correctly: -- **Sync**: Allow time for the wallet to sync with the network -- **Manual Refresh**: Use the refresh option in the token list -- **Network Status**: Check if there are known network issues - -### Import Errors -If you encounter errors during import: -- **Format Check**: Ensure the process ID is correctly formatted -- **Network Connection**: Verify stable internet connectivity -- **Wallet Version**: Update to the latest version of Wander -- **Try Again**: Sometimes retrying the import process works - -## Next Steps - -After successfully adding ARIO to Wander: - -1. **Buy an ArNS Name**: Purchase an ArNS name directly in Wander and set it as your primary name for easy identification -2. **Join the Network**: Visit [https://gateways.ar.io](https://gateways.ar.io) to join as a gateway operator or delegate your tokens to existing operators -3. **Stay Connected**: Join the [Discord community](https://discord.com/invite/HGG52EtTc2) to learn more about network updates and participate in discussions - -Your Wander wallet is now configured to manage ARIO tokens, giving you full access to the ar.io ecosystem's financial features and services. diff --git a/content/learn/token/architecture.mdx b/content/learn/token/architecture.mdx index e28e2d8a6..16b4120b0 100644 --- a/content/learn/token/architecture.mdx +++ b/content/learn/token/architecture.mdx @@ -1,120 +1,145 @@ --- title: 'Architecture' -description: "Explore the technical architecture of the $ARIO contract and ar.io's system components" +description: "Explore the technical architecture of the ARIO Solana programs and ar.io's system components" --- -## ARIO Contract Architecture +## ARIO Program Architecture -The $ARIO token operates through a smart contract built on AO Computer. The system is composed of several interconnected components that work together to provide a comprehensive network infrastructure. +The ARIO protocol operates through four Solana programs (3+1) that work together via cross-program invocation (CPI). This architecture consolidates what was previously spread across separate processes into a coordinated set of programs with clear responsibilities. ```mermaid graph LR - subgraph ARIO["ARIO Smart Contract"] - direction LR - BAL[Balances] - GW_REG[Gateway Registry] + subgraph CORE["ario-core"] + direction TB + BAL[SPL Token / Balances] VAULTS[Vaults] - ARNS_REG[ArNS Registry] + PRIMARY[Primary Names] end - subgraph EXT["External AO Processes"] + subgraph GAR["ario-gar"] direction TB - ANT_REGISTRY[ANT Registry] - ANT1[ANT Process: alice] + GW_REG[Gateway Registry
3,000 slots] + STAKING[Staking & Delegation] + EPOCHS[Epochs & Rewards] end - %% Invisible positioning link - ARIO --- EXT - linkStyle 0 opacity:0; + subgraph ARNS["ario-arns"] + direction TB + NAME_REG[Name Registry
50,000 slots] + DEMAND[Demand Factor] + PRICING[Pricing & Auctions] + end - ANT1 -.-> |ownership changes| ANT_REGISTRY - ARNS_REG -.->|alice| ANT1 + subgraph ANT["ario-ant"] + direction TB + NFT[Metaplex Core NFTs] + RECORDS[DNS-like Records] + CTRL[Controllers] + end - classDef smartContract fill:#e3f2fd - classDef antProcess fill:#f3e5f5 - classDef registry fill:#e8f5e8 - classDef hidden display:none; - classDef dashedGroup stroke-dasharray: 5 5, fill: transparent; + GAR -->|CPI: token ops| CORE + ARNS -->|CPI: token ops| CORE + ARNS -.->|reads gateway data| GAR - class BAL,GW_REG,ARNS_REG,VAULTS smartContract - class ANT1 antProcess - class ANT_REGISTRY registry - class EXT dashedGroup + classDef coreProgram fill:#e3f2fd + classDef garProgram fill:#e8f5e8 + classDef arnsProgram fill:#fff3e0 + classDef antProgram fill:#f3e5f5 + class BAL,VAULTS,PRIMARY coreProgram + class GW_REG,STAKING,EPOCHS garProgram + class NAME_REG,DEMAND,PRICING arnsProgram + class NFT,RECORDS,CTRL antProgram ``` -## Core Components +## Programs + +### ario-core + +The core program manages the ARIO SPL Token, vaults, and primary names: -### Balances -The Balances component manages the fundamental token accounting for the ARIO ecosystem: +- **SPL Token Operations**: ARIO is a standard SPL Token (6 decimals, 1 ARIO = 1,000,000 mARIO). Transfers, balances, and token accounts follow the SPL Token standard. +- **Vaults**: Time-locked token deposits for various purposes — RFPs, bounties, and ecosystem programs. Minimum size: 100 ARIO. Duration: 14 days to 200 years. +- **Primary Names**: Maps a Solana wallet address to a single ArNS name for easy identification. Fee: 0.2 ARIO × demand factor. -- **Token Holdings**: Tracks ARIO token balances for all network participants -- **Transfer Logic**: Handles secure token transfers between addresses -- **Paginated Queries**: Provides efficient balance lookups with cursor-based pagination -- **Integration Layer**: Connects with all other components for balance updates +Other programs (ario-gar, ario-arns) call into ario-core via CPI for all token operations. -### Gateway Registry -The Gateway Registry manages the network's infrastructure providers and all delegation relationships: +### ario-gar (Gateway Address Registry) -- **Gateway Management**: Handles gateway registration, settings updates, and network participation -- **Operator Stakes**: Manages gateway operator stakes and minimum staking requirements -- **Delegated Stakes**: Coordinates delegated stake from token holders to gateway operators -- **Performance Tracking**: Monitors gateway performance metrics and eligibility for rewards +Manages the network's gateway infrastructure, staking, delegation, and the epoch reward pipeline: -### ArNS Registry -The ArNS (Arweave Name System) Registry provides decentralized domain name services: +- **Gateway Registry**: A zero-copy on-chain registry with up to 3,000 gateway slots. Each gateway is a PDA storing operator address, stake, observer address, settings, and performance stats. +- **Staking & Delegation**: Operator stakes, delegated stakes (separate PDA per gateway-delegator pair), withdrawals, redelegation, and allowlists. +- **Observer Address Uniqueness**: An ObserverLookup PDA enforces that no two gateways share the same observer address. +- **Epoch Pipeline**: A 6-step permissionless pipeline driven by [cranker bots](/learn/oip/cranker): + 1. `create_epoch` — Initialize epoch, compute reward rate + 2. `tally_weights` — Batched weight computation (15 gateways per transaction) + 3. `prescribe_epoch` — Select observers and prescribed names via weighted roulette + 4. `save_observations` — Observers submit pass/fail reports + 5. `distribute_epoch` — Batched reward distribution (15 gateways per transaction) + 6. `close_epoch` — Reclaim rent after 7+ epochs +- **Gateway Pruning**: Gateways that fail 30 consecutive epochs have 100% of their minimum stake slashed and are removed from the network. -- **Name Registration**: Manages the purchase and registration of friendly names -- **Lease Management**: Handles name renewals and lease extensions -- **Primary Names**: Allows users to set primary names for their addresses -- **ANT Integration**: Links registered names to their corresponding ANT processes +### ario-arns (ArNS Registry) -### Vaults -The Vaults component implements token time-locking mechanisms for various ecosystem purposes: +Manages the Arweave Name System — name registration, leasing, pricing, and returned names: -- **Multi-Purpose Locking**: Locks tokens for RFPs, bug bounties, investors, and core team members -- **Flexible Terms**: Supports various lock periods and amounts based on purpose and requirements -- **Extension Options**: Allows participants to extend vault lock periods when needed -- **Withdrawal Logic**: Manages secure token release after lock expiration or completion of terms +- **Name Registry**: A zero-copy on-chain registry with up to 50,000 name slots. Each name is an ArnsRecord PDA storing the owner, ANT mint address, lease type, and expiration. +- **Pricing**: Dynamic pricing via a DemandFactor PDA. Fee halving occurs when the demand factor stays at minimum (0.5×) for 7 consecutive periods. +- **Returned Name Auctions**: When a name expires or is released, it enters a Dutch auction: 50× → 1× base price over 14 days, with a 50/50 revenue split between protocol and previous owner. +- **Validation**: 43-character names are prohibited (Arweave TX ID collision prevention). Names must be lowercase at submission. +- **Cost Simulation**: `get_token_cost` view instruction available via `simulateTransaction` for fee estimation. -## System Processes +### ario-ant (Arweave Name Tokens) -### ANT Registry Process -A utility process that facilitates ANT discovery and management: +ANTs are [Metaplex Core](https://developers.metaplex.com/core) NFTs that represent ownership of ArNS names: -- **Discovery Service**: Makes it easy to find ANTs owned by specific wallet addresses -- **Ownership Tracking**: Provides efficient lookup of ANT ownership relationships -- **Integration Support**: Connects with wallets and dApps for seamless ANT management -- **Query Interface**: Enables paginated queries for ANT discovery +- **NFT Standard**: Each ANT is a Metaplex Core asset — tradeable on Tensor, Magic Eden, and other NFT marketplaces. +- **DNS-like Records**: Each ANT stores routing records (AntRecord PDAs) mapping undernames to Arweave transaction IDs or IPFS CIDs, with configurable TTL values. +- **Controllers**: Up to 10 controllers per ANT can manage records without holding the NFT itself. +- **Lazy Reconciliation**: When an ANT is transferred via a marketplace (outside the ar.io protocol), controllers are cleared on the next write operation, ensuring the new owner has full control. +- **@ Record**: The root (@) record cannot be removed, only updated — ensuring the name always resolves. -### ArNS Name Tokens (ANTs) -Transferable token processes that represent ownership and control of ArNS names: +## State Model -- **Name Ownership**: Each ANT process controls a specific ArNS name -- **Record Management**: ANT holders manage DNS-like records for their names -- **Undername Control**: Support for creating and managing subdomains (undernames) -- **Transferable Rights**: ANTs can be bought, sold, and transferred as independent tokens -- **Process-Based**: Each ANT is its own AO process with autonomous functionality +All protocol state is stored in Solana accounts using Program Derived Addresses (PDAs): +| Account Type | Program | Derivation Seeds | Purpose | +|-------------|---------|-----------------|---------| +| ArioConfig | ario-core | `["config"]` | Global token configuration | +| Vault | ario-core | `["vault", owner, vault_id]` | Time-locked token deposit | +| PrimaryName | ario-core | `["primary_name", name_hash]` | Name → address mapping | +| PrimaryNameReverse | ario-core | `["primary_name_reverse", owner]` | Address → name reverse lookup | +| GatewayRegistry | ario-gar | `["gateway_registry"]` | Zero-copy gateway slot array | +| Gateway | ario-gar | `["gateway", operator]` | Individual gateway state | +| Delegation | ario-gar | `["delegation", gateway, delegator]` | Per-pair delegation | +| Withdrawal | ario-gar | `["withdrawal", owner, id]` | Pending withdrawal | +| ObserverLookup | ario-gar | `["observer_lookup", observer]` | Observer uniqueness check | +| Epoch | ario-gar | `["epoch", epoch_index]` | Epoch state and rewards | +| NameRegistry | ario-arns | `["name_registry"]` | Zero-copy name slot array | +| ArnsRecord | ario-arns | `["arns_record", name_hash]` | Individual name record | +| DemandFactor | ario-arns | `["demand_factor"]` | Current pricing multiplier | +| AntConfig | ario-ant | `["ant_config", mint]` | ANT metadata and settings | +| AntControllers | ario-ant | `["ant_controllers", mint]` | Controller list (max 10) | +| AntRecord | ario-ant | `["ant_record", mint, undername_hash]` | DNS-like routing record | ## Security Model The architecture implements multiple layers of security: ### Economic Security -- **Stake Requirements**: Minimum stakes ensure operator commitment and skin in the game -- **Performance-Based Removal**: Gateways that fail observation for 30 consecutive epochs are removed from the network -- **Complete Stake Slashing**: 100% of stake is returned to the protocol balance when gateways are removed for poor performance -- **Observation Consensus**: Peer-to-peer monitoring ensures no single point of failure in performance evaluation +- **Stake Requirements**: Minimum 10,000 ARIO to join as a gateway operator +- **Performance-Based Pruning**: Gateways that fail observation for 30 consecutive epochs are removed with 100% of minimum stake slashed +- **Observation Consensus**: Peer-to-peer monitoring ensures no single point of failure ### Technical Security -- **AO Computer**: Leverages Arweave's permanent and decentralized compute layer -- **Process Isolation**: Separate processes for different system functions -- **Cryptographic Verification**: All transactions and state changes are cryptographically secured +- **Solana Runtime**: Enforces signer authentication, account ownership, and rent exemption +- **PDA Isolation**: Each account type has deterministic seeds preventing collision or unauthorized access +- **Audited Code**: Independent security audit with all findings addressed +- **CPI Guards**: Cross-program invocations validate calling program identity ### Governance Security -- **Current Ownership**: Currently owned by a multisig with intentions to make ownership immutable -- **Path to Immutability**: Plans to transition to fully immutable protocol without governance control -- **Transparent Operations**: All system state is publicly verifiable on Arweave -- **Consensus-Based Evaluation**: Gateway performance determined by peer consensus rather than centralized authority +- **Current Ownership**: Managed by a Squads v4 multisig +- **Path to Immutability**: Plans to transition to fully immutable protocol +- **Transparent State**: All on-chain state is publicly verifiable via any Solana RPC or explorer diff --git a/content/learn/token/get-the-token.mdx b/content/learn/token/get-the-token.mdx index 32c4ca978..e7fafc6a7 100644 --- a/content/learn/token/get-the-token.mdx +++ b/content/learn/token/get-the-token.mdx @@ -1,14 +1,14 @@ --- title: 'Get the Token' -description: 'Learn how to acquire $ARIO tokens through various methods including exchanges, swaps, bridging, and network participation' +description: 'Learn how to acquire ARIO tokens through exchanges, swaps, bridging, and network participation' --- ## Acquiring ARIO Tokens ARIO exists on multiple networks: -- **AO ARIO (canonical):** The base asset that powers ar.io, staking, rewards, and ArNS. -- **Base ARIO (bridged):** A representation of AO ARIO on the Base L2 for EVM-based liquidity, tools, and integrations. +- **Solana ARIO (canonical):** The native SPL Token that powers ar.io — staking, rewards, ArNS, and governance. +- **Base ARIO (bridged):** A representation of Solana ARIO on the Base L2 for EVM-based liquidity, tools, and integrations. Choose between mainnet and testnet tokens based on your requirements. @@ -24,13 +24,15 @@ Choose between mainnet and testnet tokens based on your requirements. Pick the network you want to use: - - + + ### Token Details - - **Contract ID:** `qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE` - - **Explorer:** https://scan.ar.io/#/entity/qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE + - **Mint Address:** `` + - **Token Standard:** SPL Token + - **Decimals:** 6 + - **Explorer:** [View on Solscan](https://solscan.io/token/) --- @@ -47,22 +49,27 @@ Choose between mainnet and testnet tokens based on your requirements. Before trading, always review exchange fees, liquidity, and withdrawal policies. #### Decentralized Exchanges (DEXs) - You can also swap ARIO on decentralized exchanges within the **AO ecosystem**: + You can swap ARIO on Solana DEXs: - - **[Permaswap](https://www.permaswap.network/#/liquidity?processId=T2r71KaJH15fpiyGD_RHsWqrIS1ccO7DZ7cm9g4HLRw&to=add)** – AO ecosystem trading platform. + - **[Jupiter](https://jup.ag)** — Solana's leading DEX aggregator + - **[Raydium](https://raydium.io)** — AMM and liquidity on Solana - When trading on a DEX, always confirm that the token is verified and has the correct contract address. + When trading on a DEX, always confirm that the token mint address matches the official ARIO mint above. --- ### Wallets - The **[Wander App and Browser Extension](https://wander.app)** provides native ARIO (AO) support, making it simple to acquire, store, and manage your tokens. + ARIO is a standard SPL Token — any Solana-compatible wallet can hold it: - ARIO on AO can also be held in EVM wallets, though balances typically won’t display unless the wallet is connected through an EVM-enabled AO app. + - **[Phantom](https://phantom.app)** — Most popular Solana wallet + - **[Solflare](https://solflare.com)** — Full-featured Solana wallet with staking support + - **[Backpack](https://backpack.app)** — Multi-chain wallet with Solana support + + Most Solana wallets auto-detect ARIO once you receive tokens. To add manually, import the mint address above. - Recommended: Wander offers the easiest way to get started — buy, swap, stake, and manage AO-based ARIO in one place with a seamless permaweb-native experience. + See our [Wallet Setup Guide](/learn/token/wallets) for detailed instructions on configuring your wallet for ARIO. @@ -76,11 +83,11 @@ Choose between mainnet and testnet tokens based on your requirements. --- - You can obtain ARIO on Base by swapping on a DEX or by bridging it from AO. + You can obtain ARIO on Base by swapping on a DEX or by bridging it from Solana. ### Bridge - Bridge from AO to Base (and vice versa) via the **[ARIO Bridge](https://swap.ar.io)**. + Bridge from Solana to Base (and vice versa) via the **[ARIO Bridge](https://swap.ar.io)**. ### Decentralized Exchanges (DEXs) @@ -104,10 +111,10 @@ Choose between mainnet and testnet tokens based on your requirements. ### Network Participation - ARIO on AO can also be earned by supporting the network through direct operation or delegated staking. + ARIO on Solana can be earned by supporting the network through direct operation or delegated staking. - **Note:** At this time, only ARIO on AO can be used for joining a gateway to the network and delegated staking. + **Note:** Only ARIO on Solana can be used for joining a gateway to the network and delegated staking. SOL is also required for Solana transaction fees. #### Gateway Operation @@ -147,10 +154,10 @@ Choose between mainnet and testnet tokens based on your requirements. ## Testnet Tokens - For developers and testing purposes, you can obtain **ARIO on AO** testnet tokens from the ar.io faucet: + For developers and testing purposes, you can obtain ARIO testnet tokens on Solana devnet from the ar.io faucet: - **Note:** Testnet token balances, ArNS names, and gateway registry reset once a month. + **Note:** Testnet token balances, ArNS names, and gateway registry reset periodically. ### Faucet @@ -165,10 +172,10 @@ Choose between mainnet and testnet tokens based on your requirements. ### Testnet Resources - - **Network**: [ar.io Testnet (agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdiA)](https://scan.ar.io/#/entity/agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdiA) + - **Network**: Solana Devnet - **Purpose**: Development and testing - **Cost**: Free - - **Limitations**: Monthly resets of balances, names, and registry + - **Limitations**: Periodic resets of balances, names, and registry - **Use Cases**: Application development, integration testing, learning @@ -181,4 +188,3 @@ Choose between mainnet and testnet tokens based on your requirements. - **ARIO powers ar.io** — enabling staking, naming, and incentives. - **Get ARIO** on CEXs, DEXs, or directly through participation. - **Earn ARIO** by running gateways, delegating, or contributing to ecosystem growth. - diff --git a/content/learn/token/index.mdx b/content/learn/token/index.mdx index e26d34098..fa955acf5 100644 --- a/content/learn/token/index.mdx +++ b/content/learn/token/index.mdx @@ -1,6 +1,6 @@ --- title: 'Token' -description: 'Learn about the ARIO token - the multifunction AO Computer based token that powers ar.io and its suite of permanent cloud applications' +description: 'Learn about the ARIO token — the SPL Token on Solana that powers ar.io and its suite of permanent cloud applications' --- import { Card, Cards } from 'fumadocs-ui/components/card'; @@ -8,13 +8,13 @@ import { Building, ShoppingCart, Target, Wallet } from 'lucide-react'; ## Overview -ARIO is the multifunction [AO Computer](/glossary) based token that powers ar.io and its suite of permanent cloud applications. Built on AO, ARIO leverages the computational power and permanence of the Arweave ecosystem to create a robust, decentralized infrastructure token. +ARIO is the native token of the [ar.io network](https://ar.io), implemented as an [SPL Token](https://spl.solana.com/token) on Solana. It powers the network's decentralized gateway infrastructure, ArNS naming system, and incentive mechanisms. The token uses 6 decimal places (1 ARIO = 1,000,000 mARIO). ### Key Features -- **Native AO Token**: ARIO is built directly on AO Computer, utilizing its decentralized compute capabilities for smart contract execution and network operations -- **Staking-Based Infrastructure**: The network operates on a staking-based incentive system where gateway operators secure infrastructure services through token commitment -- **Multi-utility Design**: ARIO serves multiple functions within the ecosystem, from network participation to governance and payments +- **SPL Token on Solana**: ARIO is a standard SPL Token, compatible with the full Solana wallet and DeFi ecosystem — including Phantom, Solflare, Backpack, Jupiter, and Raydium +- **Staking-Based Infrastructure**: Gateway operators and delegators stake ARIO to secure network infrastructure and earn protocol rewards +- **Multi-utility Design**: ARIO serves multiple functions across the ecosystem — staking, ArNS name registration, delegation, governance participation, and payments ## Incentive Mechanisms @@ -22,16 +22,16 @@ ARIO's design creates powerful incentives for network participants through multi ### Gateway Operator Incentives -- **Staking Rewards**: Gateway operators earn rewards for maintaining network infrastructure and providing reliable data services +- **Staking Rewards**: Gateway operators earn rewards for maintaining network infrastructure and providing reliable data services. Operator rewards automatically compound into their stake. - **Performance Bonuses**: Additional rewards for gateways that demonstrate high uptime and fast response times - **Network Growth Rewards**: Operators benefit as the network scales and generates more activity ### Delegator Rewards - **Delegated Staking**: Token holders can delegate their ARIO to trusted gateway operators to participate in network operations -- **Increased Operator Stake**: Delegation enhances gateway operator visibility and influence within the network +- **Reward Accumulator**: Delegate rewards are tracked via a reward-per-share accumulator and settled when the delegator interacts with the protocol - **Shared Risk and Rewards**: Delegators participate in the risk and rewards of gateway operations -- **Withdrawal Flexibility**: Delegated tokens can be withdrawn following the same vault lock period rules +- **Withdrawal Flexibility**: Delegated tokens can be withdrawn following standard lock period rules, with an optional expedited withdrawal at a fee ### Ecosystem Participation @@ -45,10 +45,11 @@ Ar.io implements a robust staking-based incentive system that ensures infrastruc ### Gateway Operator Requirements -- Gateway operators must stake a minimum amount of ARIO tokens to join the network -- Staking demonstrates commitment to network objectives and promotes infrastructure reliability +- Gateway operators must stake a minimum of 10,000 ARIO to join the network +- The gateway registry supports up to 3,000 gateways - Only gateways that pass [Observation and Incentive Protocol](/learn/oip) evaluations receive rewards -- Staked tokens remain locked until withdrawal is initiated or vault period expires +- Operator rewards always auto-compound — operators must decrease their stake to realize rewards +- Operators cannot self-delegate ### Network Quality Assurance @@ -64,34 +65,34 @@ Ar.io implements a robust staking-based incentive system that ensures infrastruc - Observer gateways receive additional rewards for monitoring network quality - Delegated staking allows broader community participation in successful gateway operations -## Built on AO Computer +## Protocol Execution on Solana -ARIO's foundation on AO Computer provides unique advantages: +ARIO's protocol logic runs across four Solana programs that work together via cross-program invocation (CPI): -### Computational Permanence +### High Performance -- All token operations and smart contracts benefit from Arweave's permanent storage -- Network history and token transactions are immutably recorded -- Computational results are verifiable and permanent +- Transactions confirm in ~400ms with Solana's proof-of-stake consensus +- Epoch reward distribution is driven by a permissionless [cranker pipeline](/learn/oip/cranker) — anyone can participate +- Zero-copy account registries enable efficient on-chain state management -### Decentralized Execution +### Ecosystem Integration -- Token logic runs across distributed AO processes, eliminating single points of failure -- Smart contract upgrades follow community governance processes -- Network operations scale with AO's computational capacity +- Native compatibility with the Solana DeFi ecosystem (Jupiter, Raydium, and more) +- ANTs (Arweave Name Tokens) are Metaplex Core NFTs — tradeable on Tensor, Magic Eden, and other NFT marketplaces +- Seamless interaction with Arweave's permanent data storage layer -### Ecosystem Integration +### Security -- Native compatibility with other AO-based applications and tokens -- Seamless interaction with Arweave's data storage layer -- Built-in interoperability with the broader permaweb ecosystem +- All program logic is audited and deployed on-chain +- Solana's runtime enforces signer authentication and account ownership checks +- Deterministic PDA (Program Derived Address) accounts ensure predictable state management ## Explore the Token } /> @@ -108,9 +109,9 @@ ARIO's foundation on AO Computer provides unique advantages: icon={} /> } /> - \ No newline at end of file + diff --git a/content/learn/token/meta.json b/content/learn/token/meta.json index 28f5df72b..1105db756 100644 --- a/content/learn/token/meta.json +++ b/content/learn/token/meta.json @@ -5,6 +5,7 @@ "architecture", "staking", "get-the-token", - "add-to-wander" + "wallets", + "migration" ] } diff --git a/content/learn/token/migration.mdx b/content/learn/token/migration.mdx new file mode 100644 index 000000000..a4c720421 --- /dev/null +++ b/content/learn/token/migration.mdx @@ -0,0 +1,123 @@ +--- +title: 'Migration Guide' +description: 'How to migrate your ARIO tokens, ArNS names, and gateway operations from AO to Solana' +--- + +## AO to Solana Migration + +The ar.io network has migrated protocol execution from AO (Arweave compute) to Solana. This guide explains how the migration works and what actions you need to take. + + +Specific dates, claim app URLs, and final program addresses will be updated as the migration progresses. Check back for the latest information. + + +## Overview + +The migration follows an **import-then-claim** approach: + +1. **Pre-registration**: Users map their Arweave/Ethereum addresses to Solana wallet addresses before cutover +2. **Snapshot**: AO state is frozen and exported +3. **Import**: All state (balances, stakes, names, gateways, ANTs) is imported to Solana programs +4. **Claim**: Users who didn't pre-register can claim their tokens via a claim app within the claim window + +```mermaid +graph LR + A[Pre-Register
Map addresses] --> B[AO Frozen
Snapshot exported] + B --> C[Import to Solana
All state migrated] + C --> D[Network Live
Solana default] + D --> E[Claim Window
Late claims] +``` + +## What Happens to Your Assets + +### ARIO Token Balances +- If you pre-registered your Solana address, your ARIO balance is imported directly to your Solana wallet as SPL Tokens +- If you didn't pre-register, your tokens are held in escrow and can be claimed via the claim app + +### ArNS Names +- All registered ArNS names are migrated to the Solana NameRegistry +- ANTs become Metaplex Core NFTs on Solana +- Name routing (pointing to Arweave Transaction IDs) is preserved +- Records and undernames are migrated to AntRecord PDAs + +### Gateway Registrations +- Gateway operator registrations are imported to the Solana GatewayRegistry +- Stake amounts are preserved +- Delegated stakes are migrated as individual Delegation PDAs +- Observer addresses must be updated to Solana pubkeys + +### Vaults +- All active vaults are imported to Solana with their lock periods preserved + +## Address Mapping + +To map your existing address to a Solana wallet: + + + + ### Create a Solana Wallet + + Set up a Solana wallet using [Phantom](https://phantom.app), [Solflare](https://solflare.com), or [Backpack](https://backpack.app). See our [Wallet Setup Guide](/learn/token/wallets). + + + + ### Sign an Attestation + + Sign a data item with your Arweave or Ethereum key that maps to your Solana public key. This creates an immutable proof on Arweave that you control both addresses. + + + + ### Verify Mapping + + Your address mapping will be included in the migration import. Verify your mapping is registered before the cutover date. + + + +## What Changes + +| Aspect | Before (AO) | After (Solana) | +|--------|-------------|----------------| +| **Token** | In-process Lua balance | SPL Token | +| **Wallets** | Arweave (RSA), Ethereum (ECDSA) | Solana (Ed25519) — Phantom, Solflare, Backpack | +| **Gas fees** | Abstracted | SOL required for Solana transaction fees | +| **ANTs** | Separate AO process per name | Metaplex Core NFTs (one program, many assets) | +| **Epochs** | Atomic `tick()` message | 6-step permissionless cranker pipeline | +| **State reads** | AO Compute Unit (CU) | Solana RPC + indexer | +| **SDK default** | AO backend | Solana backend (v3.23+) | + +## What Stays the Same + +- **ARIO supply**: 1 billion tokens, non-inflationary +- **Token decimals**: 6 (1 ARIO = 1,000,000 mARIO) +- **Minimum operator stake**: 10,000 ARIO +- **ArNS name routing**: Names still point to Arweave Transaction IDs +- **Gateway data serving**: Gateways still serve Arweave data +- **SDK API surface**: Same method names, Solana underneath + +## Timeline + +{/* TODO: Update with final dates */} + +| Phase | Description | +|-------|-------------| +| **Pre-migration** | Claim app opens, users pre-register Solana addresses | +| **Cutover** | AO frozen, state exported and imported to Solana | +| **Network live** | Solana programs active, gateways and epochs operational | +| **Claim window** | Late claims accepted for unregistered users | + +## FAQ + +**Do I need to do anything if I pre-registered?** +No. Your balances, names, and stakes are automatically available in your Solana wallet after import. + +**What if I miss the pre-registration window?** +You can still claim your tokens via the claim app during the claim window. Your assets are held in escrow until claimed. + +**Do I need SOL?** +Yes. All Solana transactions require a small amount of SOL for fees. This is a new requirement — on AO, fees were abstracted. + +**Will my ArNS names still work?** +Yes. Names continue to resolve through ar.io gateways. The routing records (pointing to Arweave data) are preserved exactly as they were. + +**Can I still use the AO backend?** +The SDK supports an `--ao` flag for legacy AO backend access during the transition period. diff --git a/content/learn/token/staking.mdx b/content/learn/token/staking.mdx index f4fcce18d..e08763432 100644 --- a/content/learn/token/staking.mdx +++ b/content/learn/token/staking.mdx @@ -10,9 +10,13 @@ import { Target, Network, Shield, Coins } from 'lucide-react'; Staking tokens within ar.io serves a dual primary purpose: it signifies a public commitment by gateway operators and qualifies them and their delegates for reward distributions. -In the ar.io ecosystem, "staking" refers to the process of locking a specified amount of ARIO tokens into a protocol-controlled vault. This act signifies an opportunity cost for the staker, acting both as a motivator and a public pledge to uphold the network's collective interests. Once staked, tokens remain locked until the staker initiates an 'unstake / withdraw' action or reaches the end of the vault’s lock period. +In the ar.io ecosystem, "staking" refers to the process of locking a specified amount of ARIO tokens into protocol-controlled accounts on Solana. This act signifies an opportunity cost for the staker, acting both as a motivator and a public pledge to uphold the network's collective interests. Once staked, tokens remain locked until the staker initiates a withdrawal or reaches the end of the lock period. -It is important to note that the ARIO Token is non-inflationary, distinguishing ar.io's staking mechanism from yield-generation tools found in other protocols. Staking in this context is about eligibility for potential rewards rather than direct token yield. By staking tokens, gateway operators (and their delegates) demonstrate their commitment to the network, thereby gaining eligibility for protocol-driven rewards and access to the network’s shared resources. +It is important to note that the ARIO Token is non-inflationary, distinguishing ar.io's staking mechanism from yield-generation tools found in other protocols. Staking in this context is about eligibility for potential rewards rather than direct token yield. By staking tokens, gateway operators (and their delegates) demonstrate their commitment to the network, thereby gaining eligibility for protocol-driven rewards and access to the network's shared resources. + + +SOL is required for Solana transaction fees when staking, delegating, or withdrawing ARIO. +