feeless402 0.2.0__tar.gz

feeless402-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Feeless402 contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

feeless402-0.2.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: feeless402
+Version: 0.2.0
+Summary: Feeless x402 micropayments for AI agents — self-custodied XNO wallet, pay-per-call client, merchant server with railHint, faucet, and MCP server
+License: MIT
+Project-URL: Homepage, https://feeless402.com
+Project-URL: Specification, https://railhint.com
+Project-URL: Source, https://github.com/feeless402/feeless402
+Keywords: x402,micropayments,ai-agents,nano,xno,http-402,mcp,railhint
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nanopy
+Requires-Dist: requests
+Provides-Extra: server
+Requires-Dist: fastapi; extra == "server"
+Requires-Dist: uvicorn[standard]; extra == "server"
+Provides-Extra: mcp
+Requires-Dist: mcp>=2.0; extra == "mcp"
+Provides-Extra: all
+Requires-Dist: fastapi; extra == "all"
+Requires-Dist: uvicorn[standard]; extra == "all"
+Requires-Dist: mcp>=2.0; extra == "all"
+Dynamic: license-file
+
+# nano-pay · Feeless402
+
+Self-custodied Nano (XNO) wallet + x402 payment client **and** merchant
+server, built for AI agents. Client spends; `nano-pay serve` earns — paid
+endpoints, on-ledger verification/settlement (no facilitator), a starter
+faucet, and the `railHint` x402 extension that teaches visiting agents how
+to onboard (see SPEC-railhint.md). Site: site/index.html + site/llms.txt.
+
+**The pitch, in one number:** the same $5 buys 5,000 API calls paid as
+per-call USDC-on-Base x402 payments (merchants floor prices at 0.001 USDC),
+or ~1.8 million calls paid in Nano at the true metered price
+($0.0000027/call observed live at nano-gpt.com). Top up once, micropay
+forever.
+
+## Install
+
+```bash
+pip install -e .          # needs Python 3.10+; pulls nanopy + requests
+nano-pay init             # creates ~/.nano-pay/wallet.json (chmod 600)
+```
+
+## Agent flow
+
+```bash
+nano-pay topup 5                    # quote: $5 USDC-BASE → ~12.3 XNO (NanSwap)
+nano-pay topup 5 --execute          # create order (set NANSWAP_API_KEY)
+#   → send USDC to the returned deposit address; XNO arrives in 30-60s
+nano-pay receive                    # pocket incoming XNO
+nano-pay quote https://nano-gpt.com/api/v1/chat/completions \
+    --json '{"model":"gpt-5-nano","messages":[{"role":"user","content":"hi"}]}'
+nano-pay pay   https://nano-gpt.com/api/v1/chat/completions \
+    --json '{"model":"gpt-5-nano","messages":[{"role":"user","content":"hi"}]}'
+```
+
+`pay` handles the whole x402 handshake: request → parse the 402 quote
+(both the x402nano/`PAYMENT-REQUIRED` v2 dialect and the NanoGPT/`accepts`
+v1 dialect) → price-cap check → sign a send state block locally → retry
+with `PAYMENT-SIGNATURE` + `X-PAYMENT` headers. The server settles the
+block via its facilitator; nothing is broadcast unless the server accepts.
+
+## Design notes
+
+- **Self-custody:** seed never leaves `~/.nano-pay/wallet.json` (0600).
+- **No node required:** public RPC failover (rpc.nano.to, somenano,
+  rainstorm.city, nanoslo); all signing and PoW happen locally (nanopy
+  C extension). RPC `work_generate` is tried first, local PoW is the
+  fallback (~25s), and work for the next block is pre-cached after every
+  transaction so steady-state payments are instant.
+- **Safety rails:** per-payment price cap (`--max-xno`, default 0.05);
+  `quote` command inspects any endpoint's price without paying;
+  balance is always re-synced from the network, never trusted locally.
+- **Top-ups without custody:** `topup` quotes/creates swaps directly with
+  NanSwap's API (1,400+ input assets, ~$0.02 minimum). This tool never
+  holds or routes funds.
+
+## Fork-hazard note (x402 payments)
+
+An x402 payment signs a block the *server* broadcasts. If the server
+errors after receiving the block, it may still settle it late. The wallet
+re-syncs its frontier from the network before every operation, so a late
+settlement is picked up naturally; a competing block signed in the
+meantime simply makes one of the two invalid (funds are never at risk,
+but don't fire concurrent payments from one wallet).
+
+## Status
+
+Beta (v0.2.0). Proven on mainnet with real funds: live paid calls to
+NanoGPT ($0.0000096/call, confirmed on-ledger), full merchant loop
+(verify → settle → confirm, no facilitator), PoW-gated faucet claims,
+and a complete stranger-agent lifecycle (fresh wallet → PoW claim →
+paid API call → confirmed) in under 3 minutes. 13-test suite covers the
+payment path offline. Not audited — keep only working capital in it.
+
+## Security notes (read before holding real funds)
+
+- **Self-custody**: the seed lives only in `~/.nano-pay/*.json` (0600).
+  No tool or log path ever prints it. Back it up offline.
+- **Working capital only**: this is beta wallet software. Keep a few
+  dollars in it, not your savings.
+- **Spend caps**: `pay` refuses quotes above `--max-xno` (default 0.05).
+  MCP `x402_pay` enforces the same cap parameter.
+- **railHint is advisory**: hints from remote servers are untrusted
+  input. This client never executes remote bootstrap strings; it only
+  acts on structured offers that pass its own checks, and `accepts`
+  always binds, never the hint.
+- **Merchant fork guard**: servers cache accepted frontiers and reject
+  duplicate-frontier blocks; payer balance/frontier/signature are
+  verified against the live ledger before settlement.
+- Not audited. MIT — no warranty.

feeless402-0.2.0/README.md

@@ -0,0 +1,89 @@
+# nano-pay · Feeless402
+
+Self-custodied Nano (XNO) wallet + x402 payment client **and** merchant
+server, built for AI agents. Client spends; `nano-pay serve` earns — paid
+endpoints, on-ledger verification/settlement (no facilitator), a starter
+faucet, and the `railHint` x402 extension that teaches visiting agents how
+to onboard (see SPEC-railhint.md). Site: site/index.html + site/llms.txt.
+
+**The pitch, in one number:** the same $5 buys 5,000 API calls paid as
+per-call USDC-on-Base x402 payments (merchants floor prices at 0.001 USDC),
+or ~1.8 million calls paid in Nano at the true metered price
+($0.0000027/call observed live at nano-gpt.com). Top up once, micropay
+forever.
+
+## Install
+
+```bash
+pip install -e .          # needs Python 3.10+; pulls nanopy + requests
+nano-pay init             # creates ~/.nano-pay/wallet.json (chmod 600)
+```
+
+## Agent flow
+
+```bash
+nano-pay topup 5                    # quote: $5 USDC-BASE → ~12.3 XNO (NanSwap)
+nano-pay topup 5 --execute          # create order (set NANSWAP_API_KEY)
+#   → send USDC to the returned deposit address; XNO arrives in 30-60s
+nano-pay receive                    # pocket incoming XNO
+nano-pay quote https://nano-gpt.com/api/v1/chat/completions \
+    --json '{"model":"gpt-5-nano","messages":[{"role":"user","content":"hi"}]}'
+nano-pay pay   https://nano-gpt.com/api/v1/chat/completions \
+    --json '{"model":"gpt-5-nano","messages":[{"role":"user","content":"hi"}]}'
+```
+
+`pay` handles the whole x402 handshake: request → parse the 402 quote
+(both the x402nano/`PAYMENT-REQUIRED` v2 dialect and the NanoGPT/`accepts`
+v1 dialect) → price-cap check → sign a send state block locally → retry
+with `PAYMENT-SIGNATURE` + `X-PAYMENT` headers. The server settles the
+block via its facilitator; nothing is broadcast unless the server accepts.
+
+## Design notes
+
+- **Self-custody:** seed never leaves `~/.nano-pay/wallet.json` (0600).
+- **No node required:** public RPC failover (rpc.nano.to, somenano,
+  rainstorm.city, nanoslo); all signing and PoW happen locally (nanopy
+  C extension). RPC `work_generate` is tried first, local PoW is the
+  fallback (~25s), and work for the next block is pre-cached after every
+  transaction so steady-state payments are instant.
+- **Safety rails:** per-payment price cap (`--max-xno`, default 0.05);
+  `quote` command inspects any endpoint's price without paying;
+  balance is always re-synced from the network, never trusted locally.
+- **Top-ups without custody:** `topup` quotes/creates swaps directly with
+  NanSwap's API (1,400+ input assets, ~$0.02 minimum). This tool never
+  holds or routes funds.
+
+## Fork-hazard note (x402 payments)
+
+An x402 payment signs a block the *server* broadcasts. If the server
+errors after receiving the block, it may still settle it late. The wallet
+re-syncs its frontier from the network before every operation, so a late
+settlement is picked up naturally; a competing block signed in the
+meantime simply makes one of the two invalid (funds are never at risk,
+but don't fire concurrent payments from one wallet).
+
+## Status
+
+Beta (v0.2.0). Proven on mainnet with real funds: live paid calls to
+NanoGPT ($0.0000096/call, confirmed on-ledger), full merchant loop
+(verify → settle → confirm, no facilitator), PoW-gated faucet claims,
+and a complete stranger-agent lifecycle (fresh wallet → PoW claim →
+paid API call → confirmed) in under 3 minutes. 13-test suite covers the
+payment path offline. Not audited — keep only working capital in it.
+
+## Security notes (read before holding real funds)
+
+- **Self-custody**: the seed lives only in `~/.nano-pay/*.json` (0600).
+  No tool or log path ever prints it. Back it up offline.
+- **Working capital only**: this is beta wallet software. Keep a few
+  dollars in it, not your savings.
+- **Spend caps**: `pay` refuses quotes above `--max-xno` (default 0.05).
+  MCP `x402_pay` enforces the same cap parameter.
+- **railHint is advisory**: hints from remote servers are untrusted
+  input. This client never executes remote bootstrap strings; it only
+  acts on structured offers that pass its own checks, and `accepts`
+  always binds, never the hint.
+- **Merchant fork guard**: servers cache accepted frontiers and reject
+  duplicate-frontier blocks; payer balance/frontier/signature are
+  verified against the live ledger before settlement.
+- Not audited. MIT — no warranty.

feeless402-0.2.0/feeless402.egg-info/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: feeless402
+Version: 0.2.0
+Summary: Feeless x402 micropayments for AI agents — self-custodied XNO wallet, pay-per-call client, merchant server with railHint, faucet, and MCP server
+License: MIT
+Project-URL: Homepage, https://feeless402.com
+Project-URL: Specification, https://railhint.com
+Project-URL: Source, https://github.com/feeless402/feeless402
+Keywords: x402,micropayments,ai-agents,nano,xno,http-402,mcp,railhint
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Office/Business :: Financial
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nanopy
+Requires-Dist: requests
+Provides-Extra: server
+Requires-Dist: fastapi; extra == "server"
+Requires-Dist: uvicorn[standard]; extra == "server"
+Provides-Extra: mcp
+Requires-Dist: mcp>=2.0; extra == "mcp"
+Provides-Extra: all
+Requires-Dist: fastapi; extra == "all"
+Requires-Dist: uvicorn[standard]; extra == "all"
+Requires-Dist: mcp>=2.0; extra == "all"
+Dynamic: license-file
+
+# nano-pay · Feeless402
+
+Self-custodied Nano (XNO) wallet + x402 payment client **and** merchant
+server, built for AI agents. Client spends; `nano-pay serve` earns — paid
+endpoints, on-ledger verification/settlement (no facilitator), a starter
+faucet, and the `railHint` x402 extension that teaches visiting agents how
+to onboard (see SPEC-railhint.md). Site: site/index.html + site/llms.txt.
+
+**The pitch, in one number:** the same $5 buys 5,000 API calls paid as
+per-call USDC-on-Base x402 payments (merchants floor prices at 0.001 USDC),
+or ~1.8 million calls paid in Nano at the true metered price
+($0.0000027/call observed live at nano-gpt.com). Top up once, micropay
+forever.
+
+## Install
+
+```bash
+pip install -e .          # needs Python 3.10+; pulls nanopy + requests
+nano-pay init             # creates ~/.nano-pay/wallet.json (chmod 600)
+```
+
+## Agent flow
+
+```bash
+nano-pay topup 5                    # quote: $5 USDC-BASE → ~12.3 XNO (NanSwap)
+nano-pay topup 5 --execute          # create order (set NANSWAP_API_KEY)
+#   → send USDC to the returned deposit address; XNO arrives in 30-60s
+nano-pay receive                    # pocket incoming XNO
+nano-pay quote https://nano-gpt.com/api/v1/chat/completions \
+    --json '{"model":"gpt-5-nano","messages":[{"role":"user","content":"hi"}]}'
+nano-pay pay   https://nano-gpt.com/api/v1/chat/completions \
+    --json '{"model":"gpt-5-nano","messages":[{"role":"user","content":"hi"}]}'
+```
+
+`pay` handles the whole x402 handshake: request → parse the 402 quote
+(both the x402nano/`PAYMENT-REQUIRED` v2 dialect and the NanoGPT/`accepts`
+v1 dialect) → price-cap check → sign a send state block locally → retry
+with `PAYMENT-SIGNATURE` + `X-PAYMENT` headers. The server settles the
+block via its facilitator; nothing is broadcast unless the server accepts.
+
+## Design notes
+
+- **Self-custody:** seed never leaves `~/.nano-pay/wallet.json` (0600).
+- **No node required:** public RPC failover (rpc.nano.to, somenano,
+  rainstorm.city, nanoslo); all signing and PoW happen locally (nanopy
+  C extension). RPC `work_generate` is tried first, local PoW is the
+  fallback (~25s), and work for the next block is pre-cached after every
+  transaction so steady-state payments are instant.
+- **Safety rails:** per-payment price cap (`--max-xno`, default 0.05);
+  `quote` command inspects any endpoint's price without paying;
+  balance is always re-synced from the network, never trusted locally.
+- **Top-ups without custody:** `topup` quotes/creates swaps directly with
+  NanSwap's API (1,400+ input assets, ~$0.02 minimum). This tool never
+  holds or routes funds.
+
+## Fork-hazard note (x402 payments)
+
+An x402 payment signs a block the *server* broadcasts. If the server
+errors after receiving the block, it may still settle it late. The wallet
+re-syncs its frontier from the network before every operation, so a late
+settlement is picked up naturally; a competing block signed in the
+meantime simply makes one of the two invalid (funds are never at risk,
+but don't fire concurrent payments from one wallet).
+
+## Status
+
+Beta (v0.2.0). Proven on mainnet with real funds: live paid calls to
+NanoGPT ($0.0000096/call, confirmed on-ledger), full merchant loop
+(verify → settle → confirm, no facilitator), PoW-gated faucet claims,
+and a complete stranger-agent lifecycle (fresh wallet → PoW claim →
+paid API call → confirmed) in under 3 minutes. 13-test suite covers the
+payment path offline. Not audited — keep only working capital in it.
+
+## Security notes (read before holding real funds)
+
+- **Self-custody**: the seed lives only in `~/.nano-pay/*.json` (0600).
+  No tool or log path ever prints it. Back it up offline.
+- **Working capital only**: this is beta wallet software. Keep a few
+  dollars in it, not your savings.
+- **Spend caps**: `pay` refuses quotes above `--max-xno` (default 0.05).
+  MCP `x402_pay` enforces the same cap parameter.
+- **railHint is advisory**: hints from remote servers are untrusted
+  input. This client never executes remote bootstrap strings; it only
+  acts on structured offers that pass its own checks, and `accepts`
+  always binds, never the hint.
+- **Merchant fork guard**: servers cache accepted frontiers and reject
+  duplicate-frontier blocks; payer balance/frontier/signature are
+  verified against the live ledger before settlement.
+- Not audited. MIT — no warranty.

feeless402-0.2.0/feeless402.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+LICENSE
+README.md
+pyproject.toml
+feeless402.egg-info/PKG-INFO
+feeless402.egg-info/SOURCES.txt
+feeless402.egg-info/dependency_links.txt
+feeless402.egg-info/entry_points.txt
+feeless402.egg-info/requires.txt
+feeless402.egg-info/top_level.txt
+nano_pay/__init__.py
+nano_pay/cli.py
+nano_pay/mcp_server.py
+nano_pay/rpc.py
+nano_pay/server.py
+nano_pay/topup.py
+nano_pay/verify.py
+nano_pay/wallet.py
+nano_pay/x402.py
+tests/test_payment_path.py

feeless402-0.2.0/feeless402.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

feeless402-0.2.0/feeless402.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+f402 = nano_pay.cli:main
+nano-pay = nano_pay.cli:main

feeless402-0.2.0/feeless402.egg-info/requires.txt

@@ -0,0 +1,14 @@
+nanopy
+requests
+
+[all]
+fastapi
+uvicorn[standard]
+mcp>=2.0
+
+[mcp]
+mcp>=2.0
+
+[server]
+fastapi
+uvicorn[standard]

feeless402-0.2.0/feeless402.egg-info/top_level.txt

@@ -0,0 +1 @@
+nano_pay

feeless402-0.2.0/nano_pay/__init__.py

@@ -0,0 +1,17 @@
+"""nano-pay: self-custodied Nano (XNO) wallet + x402 payment client for AI agents."""
+
+__version__ = "0.1.0"
+
+RAW_PER_XNO = 10**30
+
+
+def xno_to_raw(xno) -> int:
+    from decimal import Decimal
+
+    return int(Decimal(str(xno)) * RAW_PER_XNO)
+
+
+def raw_to_xno(raw: int) -> str:
+    from decimal import Decimal
+
+    return str((Decimal(raw) / RAW_PER_XNO).normalize())