stablecoin-games-renpy 0.1.4__tar.gz

stablecoin_games_renpy-0.1.4/.gitignore

@@ -0,0 +1,54 @@
+# Python
+__pycache__/
+*.py[cod]
+.venv/
+.pytest_cache/
+.hypothesis/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# Ren'Py build artefacts and runtime files
+*.rpyc
+*.rpymc
+*.rpyb
+cache/
+saves/
+log.txt
+traceback.txt
+errors.txt
+files.txt
+*-dists/
+
+# Foundry (integration tests)
+contracts/out/
+contracts/cache/
+
+# OS / editors
+.DS_Store
+Thumbs.db
+.idea/
+.vscode/
+
+# Plugin copies made by tools/sync_demo.py
+examples/demo_game/game/scfg/
+examples/demo_game/game/python-packages/
+tests/renpy_e2e/game/scfg/
+tests/renpy_e2e/game/python-packages/
+tests/renpy_e2e/*.txt
+dist/
+tests/renpy_e2e/game/e2e_testcase.rpy
+tests/renpy_web_e2e/game/scfg/
+tests/renpy_web_e2e/game/python-packages/
+tests/renpy_web_e2e/game/e2e_web_config.json
+tests/renpy_web_e2e/progressive_download.txt
+
+# Docusaurus (website/)
+website/node_modules/
+website/build/
+website/.docusaurus/
+
+# npm installer: filled in by npm/scripts/bundle.js at pack time
+npm/plugin/
+npm/LICENSE
+npm/*.tgz

stablecoin_games_renpy-0.1.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Repulse Game Studio
+
+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.

stablecoin_games_renpy-0.1.4/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.4
+Name: stablecoin-games-renpy
+Version: 0.1.4
+Summary: Stablecoin for Games (SCFG): USDC/USDT tips and unlocks for Ren'Py games, paid straight to your wallet. No server, no tokens, no NFTs. Installs the plugin into your project.
+Project-URL: Homepage, https://jrpg.com/stablecoinforgames/
+Project-URL: Documentation, https://jrpg.com/stablecoinforgames/docs/
+Project-URL: Source, https://github.com/Repulse-Game-Studio/jrpg-stablecoin-games
+Project-URL: Changelog, https://github.com/Repulse-Game-Studio/jrpg-stablecoin-games/releases
+License-Expression: MIT
+License-File: LICENSE
+Keywords: arbitrum,arc,base,crypto,donations,ethereum,game-monetization,monetization,payments,polygon,ren'py,renpy,scfg,solana,stablecoin,stablecoin-for-games,stablecoin-games,stablecoinforgames,tips,usdc,usdt,visual-novel,wallet,web3
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# Stablecoin for Games
+
+Take tips and sell unlocks in **USDC** and **USDT** inside your Ren'Py game, on Ethereum,
+Arbitrum, Polygon, Base, Arc or Solana. The player's wallet pays yours directly. There is no
+store, account or server in between: the game watches the blockchain itself. Prices are in
+dollars. There are no tokens to buy and no NFTs.
+
+![A player tips 3 USDC on Arc in Ruby Dreams: pick an amount, pick a network, scan the QR code, payment confirmed](https://raw.githubusercontent.com/Repulse-Game-Studio/jrpg-stablecoin-games/main/.github/media/tip-arc.gif)
+
+This package installs the plugin into your Ren'Py project. Ren'Py only loads code from a
+game's own `game/` folder, so the plugin is copied there rather than installed into Python.
+
+## Install
+
+From your Ren'Py project folder (the one that contains `game/`):
+
+```bash
+uvx stablecoin-games-renpy install .
+```
+
+or, with pipx: `pipx run stablecoin-games-renpy install .`, or with Node: `npx stablecoin-games-renpy install .`
+
+That adds:
+
+```
+game/scfg/                        (screens, API, browser checkout page)
+game/python-packages/scfg_core/   (the engine; plain Python)
+```
+
+## Update
+
+```bash
+uvx stablecoin-games-renpy update .
+```
+
+It replaces those two folders with the latest version. Your own files, your configuration
+and your players' purchases are not touched.
+
+## Use it
+
+```renpy
+init python:
+    scfg.configure(wallet="0xYourWallet", testnet=True)
+    scfg.add_item("chapter2", code=1, price="4.99", token="USDC", title="Chapter 2")
+
+label end_of_chapter1:
+    $ result = scfg.pay("unlock", item="chapter2")
+    if scfg.owns("chapter2"):
+        jump chapter2
+```
+
+Requires Ren'Py 8.2 or newer. Read the
+[developer guide](https://jrpg.com/stablecoinforgames/docs/developers/install) and the
+[security notes](https://jrpg.com/stablecoinforgames/docs/developers/security) before you
+sell anything: without a server, unlocks are honour-grade.
+
+- Website: https://jrpg.com/stablecoinforgames/
+- Docs: https://jrpg.com/stablecoinforgames/docs/
+- Source and release zips: https://github.com/Repulse-Game-Studio/jrpg-stablecoin-games
+- itch.io: https://repulse-games.itch.io/stablecoin-for-games
+- npm: https://www.npmjs.com/package/stablecoin-games-renpy
+- License: MIT

stablecoin_games_renpy-0.1.4/README.md

@@ -0,0 +1,141 @@
+# Stablecoin for Games
+
+**[Website](https://jrpg.com/stablecoinforgames/)** ·
+[Docs](https://jrpg.com/stablecoinforgames/docs/) ·
+[itch.io](https://repulse-games.itch.io/stablecoin-for-games) ·
+[npm](https://www.npmjs.com/package/stablecoin-games-renpy) ·
+[PyPI](https://pypi.org/project/stablecoin-games-renpy/)
+
+Accept **USDC/USDT tips and unlock purchases** in Ren'Py games, paid straight to the
+developer's wallet, on Ethereum, Arbitrum, Polygon, Base, **Arc** and **Solana**. No server, no
+accounts, no middleman: the game watches the blockchain itself. Works in desktop builds and
+in Ren'Py's web (HTML5) build.
+
+![A player tips 3 USDC on Arc in Ruby Dreams: pick an amount, pick a network, scan the QR code, payment confirmed](.github/media/tip-arc.gif)
+
+```renpy
+init python:
+    scfg.configure(wallet="0xYourWallet", testnet=True)
+    scfg.add_item("chapter2", code=1, price="4.99", token="USDC", title="Chapter 2")
+
+label end_of_chapter1:
+    $ result = scfg.pay("unlock", item="chapter2")
+    if scfg.owns("chapter2"):
+        jump chapter2
+```
+
+## Using it in your game
+
+1. From your Ren'Py project folder, run `uvx stablecoin-games-renpy install .` (or `pipx run stablecoin-games-renpy install .`, or `npx stablecoin-games-renpy install .`),
+   and `uvx stablecoin-games-renpy update .` later for new versions. Or download `scfg-renpy-<version>.zip`
+   from the [latest release](https://github.com/Repulse-Game-Studio/jrpg-stablecoin-games/releases/latest)
+   or [itch.io](https://repulse-games.itch.io/stablecoin-for-games).
+   To build it yourself instead, clone the repo and run `python tools/package.py` (Python 3.9+,
+   no dependencies), which writes the same zip to `dist/`. Don't copy the repo itself into your
+   game: only `plugin/game/` ships, and the zip holds exactly that.
+2. Unzip it into your Ren'Py project folder, the one that contains `game/`. You get `game/scfg/` and
+   `game/python-packages/scfg_core/`. See [Install](docs/developers/install.md) for the layout and for updating.
+3. Follow the [developer guide](docs/developers/README.md). It covers configuration, the
+   API, testing on testnets, customizing the look, web builds and the security model.
+
+**Updating an existing game:** Arc is now built in and offered by default. Read the
+guide's [upgrade notes](docs/developers/configure/arc.md#upgrading-to-the-version-with-arc-built-in)
+first, especially if your payout wallet is a smart-contract wallet or your game added Arc
+itself with `add_chain()`.
+
+Requires Ren'Py 8.2 or newer. Read [Security and limitations](docs/developers/security/README.md)
+before selling anything: without a server, unlocks are honour-grade.
+
+The docs are published at https://jrpg.com/stablecoinforgames/docs/.
+Players can read how paying works, which wallets work and how to restore a purchase in
+[docs/players/](docs/players/paying.md).
+
+## Repository layout
+
+| Path | Contents |
+|---|---|
+| `plugin/game/scfg/` | Ren'Py glue: API (`scfg_api.rpy`), screens, UI images (`ui/`), browser checkout page and web-build bridge (`web/`) |
+| `plugin/game/python-packages/scfg_core/` | Engine-independent core (Python 3.9, stdlib only) |
+| `examples/demo_game/` | Demo game (run `tools/sync_demo.py` first) |
+| `docs/` | The docs: `players/` for players, `developers/` for the developer guide (joined into one `scfg-README.md` in the zip) |
+| `website/` | Docusaurus site built from `docs/`, sidebar in `sidebars.json`. `.github/workflows/docs.yml` checks that it builds |
+| `tests/unit/` | Fast unit tests |
+| `tests/integration/` | Local Anvil chain (also dressed as Arc), local Solana validator and headless Chrome tests (`-m integration`) |
+| `tests/live/` | Read-only checks of pinned real Arc mainnet payments (`-m live`, needs internet) |
+| `tests/renpy_e2e/`, `tests/renpy_web_e2e/` | Real Ren'Py runs (desktop and web build) driving a payment through the screens |
+| `tools/` | `package.py` (release zip), `sync_demo.py`, `check_rpcs.py`, `run_renpy_e2e.py`, `run_renpy_web_e2e.py`, `make_ui_assets.py` (screen corner images) |
+| `contracts/` | `MockToken.sol` (6-decimal mock token) and the Arc stand-ins `ArcMockUsdc.sol` / `ArcSystemEmitter.sol`, used by integration tests |
+
+## Development
+
+```bash
+uv sync                                   # Python 3.9 venv + dev tools
+uv run pytest                             # unit tests
+uv run ruff check .                       # lint
+
+# needs Foundry's `anvil` (https://getfoundry.sh) and Agave's `solana-test-validator`
+# (https://github.com/anza-xyz/agave/releases) on PATH; browser tests need Chrome/Chromium
+uv run pytest -m integration
+
+# real Ren'Py run (opens a small window; needs a Ren'Py SDK, anvil and, for Solana, the validator)
+uv run python tools/run_renpy_e2e.py --sdk /path/to/renpy-8.5.3-sdk
+uv run python tools/run_renpy_e2e.py --sdk /path/to/renpy-8.5.3-sdk --family solana
+uv run python tools/run_renpy_e2e.py --sdk /path/to/renpy-8.5.3-sdk --family arc
+
+# real web build in headless Chrome (needs an SDK with web support, anvil and Playwright's Chromium)
+uv run python tools/run_renpy_web_e2e.py --sdk /path/to/renpy-8.5.3-sdk [--family arc]
+
+uv run pytest -m live                     # pinned real Arc payments, read-only
+
+uv run python tools/check_rpcs.py         # are the built-in public RPCs alive?
+uv run python tools/package.py            # build dist/scfg-renpy-<version>.zip
+
+# docs site (Node 20+)
+cd website && npm ci && npm start         # live preview at http://localhost:3000/stablecoinforgames/docs/
+```
+
+### Testing Arc
+
+Arc (USDC as the gas coin) is tested without its network at three levels:
+
+- **Anvil dressed as Arc.** `anvil_setCode` places `contracts/ArcSystemEmitter.sol` at Arc's
+  system emitter (`0xffff…fffe`) and `contracts/ArcMockUsdc.sol` at its USDC address
+  (`0x3600…0000`). They log in the same order as Arc: a native send logs only at the
+  emitter (18 decimals), an ERC-20 `transfer()` logs at the emitter and then at `0x3600`.
+  The integration tests (`tests/integration/test_arc_anvil.py`) and both Ren'Py e2e runs
+  with `--family arc` use them. The compiled bytecode lives in
+  `tests/integration/mock_token.py`, whose docstring has the `forge build` command to
+  regenerate it after editing the contracts.
+- **Real Arc mainnet, read-only.** `uv run pytest -m live` reads two pinned real payments
+  (one native send, one `transfer()`) through the plugin's restore, re-verify and scan code.
+  No key or funds are needed; the tests skip when Arc's RPC can't be reached. In CI they
+  run with the scheduled RPC check, not on every push.
+- **A real wallet, by hand.** Before a release, pay on Arc Testnet once with a wallet's
+  Send button and once through the browser checkout (see the guide's
+  [Arc page](docs/developers/configure/arc.md)).
+
+The desktop e2e defaults to SDL's offscreen video driver. Where that isn't available, set
+`SCFG_E2E_VIDEODRIVER=x11` (or another SDL driver).
+
+## Releasing
+
+1. Set the new version in `plugin/game/python-packages/scfg_core/__init__.py` (`__version__`) and
+   merge it to `main`.
+2. Tag that commit and push the tag:
+   ```bash
+   git tag v0.2.0 && git push origin v0.2.0
+   ```
+
+`.github/workflows/release.yml` then runs the lint and unit tests, checks that the tag matches
+`__version__`, builds the zip with `tools/package.py` and publishes it as a GitHub release with
+generated notes. A second job builds the `stablecoin-games-renpy` package (`uv build`: the installer in
+`installer/` with the plugin files inside it) and uploads it to PyPI through trusted publishing,
+from the `pypi` environment. A version with letters in it, such as `0.2.0rc1`, is published as a
+prerelease and does not become "latest".
+
+## License
+
+MIT, see [`LICENSE`](LICENSE).
+
+Third-party code vendored unmodified: `scfg_core/_xkcp.py` (Keccak team, CC0) and
+`scfg_core/_qrcodegen.py` (Project Nayuki, MIT).

stablecoin_games_renpy-0.1.4/docs/developers/README.md

@@ -0,0 +1,14 @@
+# Developer guide
+
+Accept **USDC** and **USDT** tips and unlock purchases in your Ren'Py game, paid
+**directly to your own wallet**. There is no server, no account, and no middleman:
+the plugin watches the blockchain itself.
+
+- Chains: Ethereum, Arbitrum, Polygon (USDC + USDT), Base (USDC), **Arc (USDC, also its gas coin)**, **Solana (USDC + USDT; devnet USDC)**, plus any EVM chain you add yourself (see [Your own RPC endpoints and chains](configure/README.md#your-own-rpc-endpoints-and-chains), [Arc](configure/arc.md) and [Solana](configure/solana.md))
+- Platforms: Windows, macOS, Linux, Android and the web (HTML5) build, on your own site or on itch.io
+- Requires Ren'Py 8.2 or newer (tested on 8.3.7 and 8.5.3)
+
+Start with [Install](install.md).
+
+> **Read [Security and limitations](security/README.md) before you sell anything.** Without a server,
+> unlocks are honour-grade: a determined player can bypass them.

stablecoin_games_renpy-0.1.4/docs/developers/configure/README.md

@@ -0,0 +1,139 @@
+# Configure
+
+```renpy
+init python:
+    scfg.configure(
+        wallet="0xYourWalletAddressHere",   # where payments go (EIP-55 checked)
+        testnet=True,                       # remove (or False) for real money
+    )
+
+    # Paid items. `code` (1-99) is written into players' payments forever:
+    # NEVER change an item's code after release.
+    scfg.add_item("chapter2", code=1, price="4.99", token="USDC", title="Chapter 2: The Fall")
+    scfg.add_item("ost",      code=2, price="2.00", token="USDT", title="Original Soundtrack")
+```
+
+## All `configure()` options
+
+| Option | Default | Meaning |
+|---|---|---|
+| `wallet` | required unless `solana_wallet` is given | Your EVM payout address. A wrong-case checksum raises an error, which catches typos |
+| `solana_wallet` | none | Your Solana payout address (base58) to accept USDC/USDT on Solana. See [Solana](solana.md) |
+| `testnet` | `False` | `True` uses Sepolia, Arbitrum Sepolia, Polygon Amoy, Base Sepolia, Arc Testnet and Solana Devnet (USDC only) |
+| `chains` | all built-ins + yours | Which networks players may pay on, in display order: `["arbitrum", "base", "arc", "polygon", "ethereum", "solana"]`. Chains you added with `add_chain()` can be listed too. By default the EVM chains (built-in, then yours) are offered if `wallet` is set, followed by `"solana"` if `solana_wallet` is set |
+| `tokens` | both | `["USDC"]`, `["USDT"]` or both |
+| `methods` | all on | Per-method options, see below |
+| `rpc_urls` | none | Your own RPC endpoints per chain, tried before the built-in public ones, e.g. `{"arbitrum": ["https://arb-mainnet.g.alchemy.com/v2/KEY"]}`. See below |
+| `confirmations` | per chain | Override blocks to wait on EVM chains, e.g. `{"ethereum": 12}`. Arc's default is 1: its blocks are final. Refused for `"solana"`, which has no block count (see [Solana](solana.md)) |
+| `previous_wallets` | none | Wallets used by earlier versions of your game, EVM (`0x…`) and Solana addresses can be mixed. Keeps old purchases valid after you change wallets |
+| `logo` | none | An image in your game folder, e.g. `"images/logo.png"` (`.png`, `.jpg` or `.webp`). Shown at the top of the payment screens and the browser checkout page, fitted into 240 × 64 (at 1280 × 720). A wide wordmark works best |
+| `accent` | `"#0e7c74"` | Color of selected options and the main browser button, e.g. `accent=gui.accent_color`. Text on it switches between white and dark automatically |
+
+## Payment methods
+
+| Method | Options | What the player does |
+|---|---|---|
+| `browser` | `enabled`, `timeout_min` (30) | Desktop: clicks "Open checkout in browser"; a page served by the game on `127.0.0.1` connects MetaMask, Rabby, Coinbase Wallet or another extension (on Solana: Phantom, Solflare or Backpack), and sends the payment. Web build: clicks "Open wallet"; the same checkout opens over the game (offered only when the page has a wallet for the network; see [Web builds](../security/web-builds.md)) |
+| `qr` | `enabled`, `wallet_button` (Android "Open wallet app"), `chains` (restrict) | Scans a QR code with a phone wallet (EIP-681 payment link; on Solana, a Solana Pay link) |
+| `manual` | `enabled`, `allow_tx_paste` | Sends the exact amount from any wallet or exchange; can paste the transaction hash |
+
+```renpy
+scfg.configure(wallet="0x...", methods={"browser": {"enabled": False},
+                                              "qr": {"chains": ["base", "polygon"]}})
+```
+
+## Your own RPC endpoints and chains
+
+**Your own RPC endpoint for a built-in chain.** The plugin talks to each chain through
+free public RPC endpoints. They work, but they rate-limit and sometimes go down. If you
+have an endpoint from Alchemy, Infura, QuickNode, Ankr, or your own node, pass it in
+`rpc_urls`. Your endpoints are tried first, and the built-in public ones remain as a fallback:
+
+```renpy
+init python:
+    scfg.configure(
+        wallet="0xYourWallet",
+        rpc_urls={
+            "arbitrum": "https://arb-mainnet.g.alchemy.com/v2/YOUR_KEY",
+            "base": ["https://base-mainnet.g.alchemy.com/v2/YOUR_KEY",
+                     "https://my-backup-node.example.com"],
+        },
+    )
+```
+
+**Your own chain.** For an EVM chain that isn't built in (Avalanche, Optimism, Linea,
+your own appchain…), describe it with `scfg.add_chain()` **before** `configure()`.
+Its key then works everywhere a built-in key does: `chains=`, `rpc_urls=`, `confirmations=`
+and `methods={"qr": {"chains": [...]}}`.
+
+```renpy
+init python:
+    # Avalanche C-Chain, real money (used when testnet=False).
+    scfg.add_chain(
+        "avalanche",
+        name="Avalanche",                  # shown on the network button
+        chain_id=43114,
+        rpc=["https://api.avax.network/ext/bc/C/rpc"],
+        tokens={"USDC": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E"},
+        confirmations=3,
+        explorer_tx="https://snowtrace.io/tx/{}",
+        native_symbol="AVAX",
+        fee_hint="low",
+    )
+    # The same key for testing (used when testnet=True): Avalanche Fuji.
+    scfg.add_chain(
+        "avalanche", testnet=True,
+        name="Avalanche Fuji", chain_id=43113,
+        rpc=["https://api.avax-test.network/ext/bc/C/rpc"],
+        tokens={"USDC": "0x5425890298aed601595a70AB815c96711a31Bc65"},
+        confirmations=3,
+        explorer_tx="https://testnet.snowtrace.io/tx/{}",
+        native_symbol="AVAX",
+    )
+
+    scfg.configure(
+        wallet="0xYourWallet",
+        testnet=True,
+        chains=["base", "avalanche"],      # leave out to offer all built-ins + yours
+    )
+```
+
+| `add_chain()` argument | Meaning |
+|---|---|
+| `key` | Your name for the chain: lowercase letters, digits, `_`, `-`. It is stored in players' receipts, so **never change it after release**. It can't reuse a built-in key (`"arc"` is built in now: if your game added Arc itself, delete that `add_chain()` call; purchases it recorded stay valid, see [Arc](arc.md#upgrading-to-the-version-with-arc-built-in)) |
+| `name` | Shown to players on the network button (at most 32 characters) |
+| `chain_id` | The EVM chain id (see [chainlist.org](https://chainlist.org)). Wallets use it to switch networks, and QR codes carry it |
+| `rpc` | One URL or a list, tried in order. `https://` only, except `http://127.0.0.1` / `http://localhost` for a local test node. The **last** one is also handed to the player's browser wallet if it needs to add the network, so put a public endpoint last |
+| `tokens` | `{"USDC": "0x…"}` and/or `"USDT"`. Copy addresses from Circle's / Tether's official lists, never from a block explorer search |
+| `confirmations` | Blocks to wait before a payment counts. Use the chain's finality: a few for fast-finality chains, more for chains that reorg |
+| `explorer_tx` | Transaction page with `{}` where the hash goes |
+| `native_symbol` | The gas token (`"AVAX"`, `"ETH"`, …), named in "you need gas" warnings. Default `"ETH"` |
+| `fee_hint` | `"lowest"`, `"low"` (default) or `"high"`, shown under the network name |
+| `testnet` | `False` (default) adds the chain for real-money games; `True` for `configure(testnet=True)` games. Add it twice with the same key to have both |
+| `max_log_range` | Blocks per `eth_getLogs` call to start with (default 1000). The plugin shrinks it by itself when an endpoint complains |
+
+Rules your chain must follow (checked when the game starts where possible):
+
+- **EVM only.** The plugin finds payments through ERC-20 `Transfer` events over Ethereum
+  JSON-RPC (`eth_getLogs`, `eth_getTransactionReceipt`, …). Tron, Bitcoin and other non-EVM
+  chains can't be added this way. Solana is built in: see [Solana](solana.md).
+- **The token must not be the chain's gas coin.** On chains like Arc, where USDC *is* the
+  gas coin, a plain wallet send logs no ERC-20 event at the token contract, so `add_chain()`
+  would miss it. Arc is built in for that reason (see [Arc](arc.md)).
+- **6-decimal tokens only.** The item code lives in the last four of six decimals. This
+  rules out BNB Chain's USDC/USDT (18 decimals). The plugin can't check this offline, so
+  confirm `decimals()` on the explorer before you ship.
+- **The endpoint must serve `eth_getLogs`** for recent blocks. Most do; check it with a test
+  payment on the chain's testnet.
+- **Test it first.** Make one payment on the testnet version of your chain, then one small
+  real payment, before you release.
+
+## Item options
+
+`scfg.add_item(item_id, code, price, token, title, min_price=None)`
+
+- `item_id`: lowercase letters, digits, `_` and `-`.
+- `price`: a **string** like `"4.99"` (at most 2 decimals). Floats are refused.
+- `min_price`: the lowest amount that still unlocks the item (defaults to `price`).
+  - **Sales:** you can pass a lower `amount` to `pay()` as long as it's at least `min_price`.
+  - **Raising a price later:** keep `min_price` at the old price, so earlier buyers stay unlocked.

stablecoin_games_renpy-0.1.4/docs/developers/security/README.md

@@ -0,0 +1,24 @@
+# Security and limitations
+
+What the plugin protects against:
+- **Typing a fake purchase into the save data:** every receipt is re-checked on the blockchain at each launch, and invented ones are removed.
+- **Look-alike "USDC" tokens:** only the official contract addresses count.
+- **Fake transaction hashes sent to the browser page:** every hash is verified on-chain.
+
+What it **cannot** prevent (no server means nobody holds a secret):
+- A player reusing **someone else's real transaction hash**, or copying a `persistent` file.
+- **Patched game code**, or a player-controlled fake RPC endpoint.
+- A pirate re-releasing your game with their own wallet address.
+- **Rare amount collisions:** two players buying the same item within minutes of each other, paying by QR or manual transfer without pasting the hash (about 1 % chance per overlapping pair).
+
+So treat unlocks as **honour-grade**: right for supporter rewards and tips, weak for valuable content.
+
+## Debug menus and cheats
+If your game has a hidden debug mode or a level select, gate it with `owns()`. Otherwise it is an easy way around the paywall.
+
+## Platform rules
+- **Steam** forbids games that use cryptocurrencies.
+- **Google Play and the App Store** require their own billing for digital unlocks.
+- **itch.io and direct distribution** are the natural home for this plugin.
+
+Check each store's current terms yourself.

stablecoin_games_renpy-0.1.4/docs/developers/use/README.md

@@ -0,0 +1,45 @@
+# Use it
+
+```renpy
+label end_of_chapter1:
+    if not scfg.owns("chapter2"):
+        "Chapter 2 is available for 4.99 USDC."
+        $ result = scfg.pay("unlock", item="chapter2")
+
+    if scfg.owns("chapter2"):
+        jump chapter2
+    "Maybe later, then."
+```
+
+Tips (the player can change the suggested amount on the payment screen):
+
+```renpy
+$ result = scfg.pay("tip", amount="3.00", token="USDC")
+```
+
+Buttons in screens use non-blocking actions:
+
+```renpy
+textbutton "Support the developer" action ScfgPay("tip", amount="3", token="USDC")
+textbutton "Restore purchases" action CryptoRestore()
+```
+
+Every call and the `PaymentResult` fields are listed in the [API reference](api-reference.md).
+
+## Callbacks
+
+```renpy
+init python:
+    def on_payment(result):
+        if result.status == "paid":
+            achievement.grant("supporter")
+    scfg.on_result = on_payment          # also catches payments finished after a restart
+
+    # per call:
+    # $ scfg.pay("unlock", item="chapter2", callback=on_payment)
+```
+
+Rules:
+- Callbacks run on the main thread, for **side effects only**. Never call `jump`, `call` or `renpy.call_screen` inside one; change the story using `pay()`'s return value or `owns()`.
+- The receipt is saved **before** your callback runs. Ownership never depends on the callback.
+- A session can report `"cancelled"` or `"expired"` and **later** `"paid"` (the player paid late). Always treat `"paid"` as final.

stablecoin_games_renpy-0.1.4/installer/README.md

@@ -0,0 +1,62 @@
+# Stablecoin for Games
+
+Take tips and sell unlocks in **USDC** and **USDT** inside your Ren'Py game, on Ethereum,
+Arbitrum, Polygon, Base, Arc or Solana. The player's wallet pays yours directly. There is no
+store, account or server in between: the game watches the blockchain itself. Prices are in
+dollars. There are no tokens to buy and no NFTs.
+
+![A player tips 3 USDC on Arc in Ruby Dreams: pick an amount, pick a network, scan the QR code, payment confirmed](https://raw.githubusercontent.com/Repulse-Game-Studio/jrpg-stablecoin-games/main/.github/media/tip-arc.gif)
+
+This package installs the plugin into your Ren'Py project. Ren'Py only loads code from a
+game's own `game/` folder, so the plugin is copied there rather than installed into Python.
+
+## Install
+
+From your Ren'Py project folder (the one that contains `game/`):
+
+```bash
+uvx stablecoin-games-renpy install .
+```
+
+or, with pipx: `pipx run stablecoin-games-renpy install .`, or with Node: `npx stablecoin-games-renpy install .`
+
+That adds:
+
+```
+game/scfg/                        (screens, API, browser checkout page)
+game/python-packages/scfg_core/   (the engine; plain Python)
+```
+
+## Update
+
+```bash
+uvx stablecoin-games-renpy update .
+```
+
+It replaces those two folders with the latest version. Your own files, your configuration
+and your players' purchases are not touched.
+
+## Use it
+
+```renpy
+init python:
+    scfg.configure(wallet="0xYourWallet", testnet=True)
+    scfg.add_item("chapter2", code=1, price="4.99", token="USDC", title="Chapter 2")
+
+label end_of_chapter1:
+    $ result = scfg.pay("unlock", item="chapter2")
+    if scfg.owns("chapter2"):
+        jump chapter2
+```
+
+Requires Ren'Py 8.2 or newer. Read the
+[developer guide](https://jrpg.com/stablecoinforgames/docs/developers/install) and the
+[security notes](https://jrpg.com/stablecoinforgames/docs/developers/security) before you
+sell anything: without a server, unlocks are honour-grade.
+
+- Website: https://jrpg.com/stablecoinforgames/
+- Docs: https://jrpg.com/stablecoinforgames/docs/
+- Source and release zips: https://github.com/Repulse-Game-Studio/jrpg-stablecoin-games
+- itch.io: https://repulse-games.itch.io/stablecoin-for-games
+- npm: https://www.npmjs.com/package/stablecoin-games-renpy
+- License: MIT

stablecoin_games_renpy-0.1.4/installer/scfg_renpy/__init__.py

@@ -0,0 +1,4 @@
+"""Installer for the Stablecoin for Games Ren'Py plugin.
+
+Usage: `stablecoin-games-renpy install <project>`.
+"""

stablecoin_games_renpy-0.1.4/installer/scfg_renpy/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())