@rozoai/checkout 0.1.1 → 0.1.3

package/docs/QUICKSTART.md

@@ -54,6 +54,26 @@ LINK="https://payments.coinbase.com/payment-links/pl_01YOURLINKID"
 Chain ids: `1` Ethereum · `56` BNB Chain · `137` Polygon · `8453` Base ·
 `900` Solana · `1500` Stellar · `lightning` Bitcoin Lightning.
 
+## Which wallet do I need?
+
+**One wallet, on one chain — not one per chain.** Pick whichever coin you
+already hold and pay from wherever it already lives.
+
+Any wallet works, and so does an exchange withdrawal: Mode A below just prints
+a deposit block, and you send exactly that `amount` of that `tokenSymbol`, on
+that `chain`, to that `receiverAddress`. Nothing connects to a site and nothing
+is approved in a browser. In practice people use MetaMask or Rabby on the EVM
+chains, Phantom or Solflare on Solana, and a Lightning wallet such as Phoenix
+or Wallet of Satoshi for BTC.
+
+Two cases differ. **Stellar** routes through a shared address plus
+`receiverMemo`, so whatever you send from must let you set a memo — omit it and
+the payment is lost. **Lightning** pays the BOLT11 invoice in
+`deposit.lnInvoice`; there is no address to send to.
+
+Only `--send` (Mode B) needs a private key, from `ROZO_CHECKOUT_EVM_KEY` or
+`ROZO_CHECKOUT_SOL_KEY`, and it covers EVM chains and Solana only.
+
 ## 1. Quote it (read-only, free)
 
 ```bash
@@ -131,7 +151,10 @@ scripts require.
 }
 ```
 
-Send exactly the fields this block gives you. For Lightning,
+Send exactly the fields this block gives you. On Stellar the memo is
+**`MEMO_TEXT`** even when it looks numeric — sending it as `MEMO_ID` will not
+match. `deposit.expiresIn` tells you how long the order stays valid. For
+Lightning,
 `deposit.lnInvoice` holds the BOLT11 string to scan, and `deposit.amount` is
 in satoshis.
 
@@ -154,22 +177,113 @@ That is the whole of Mode A. Skip to step 5.
 
 ### The optional way: let the script pay (Mode B)
 
-Only if you want this machine to sign for you, and only on EVM chains and
-Solana. This is the only part that needs a private key:
+Only if you want this machine to sign for you, and only on **EVM chains and
+Solana** — there is no `--send` for Stellar or Lightning, which are paid from
+your own wallet. This is the only part that needs a key.
+
+**Solana — use the keypair you already have.** If you have ever run
+`solana-keygen`, `~/.config/solana/id.json` already exists and is used
+automatically:
 
 ```bash
-# Preview exactly what would be signed — signs nothing
-ROZO_CHECKOUT_SOL_KEY=<base58 secret key> \
-  node scripts/dist/send-sol.js --rozo-payment-id <rozoPaymentId> --dry-run
+node scripts/dist/send-sol.js --rozo-payment-id <rozoPaymentId> --send
+```
 
-# Actually send. --send is mandatory.
-ROZO_CHECKOUT_SOL_KEY=<base58 secret key> \
-  node scripts/dist/send-sol.js --rozo-payment-id <rozoPaymentId> --send
+**EVM — use an encrypted keystore.** Export a V3 JSON keystore from your
+wallet and point at it. The passphrase is prompted; it is never a flag:
+
+```bash
+ROZO_CHECKOUT_EVM_KEYSTORE=~/wallets/hot.json \
+  node scripts/dist/send-evm.js --rozo-payment-id <rozoPaymentId> --send
 ```
 
-Use `send-evm.js` with `ROZO_CHECKOUT_EVM_KEY` for Ethereum, BNB Chain,
-Polygon and Base. A single payment may not exceed **$1,100**; above that, pay
-from your own wallet as above.
+Either file can also be given explicitly with `--keyfile <path>`, and
+`--dry-run` works with every source: it derives the address and runs all the
+checks without signing anything.
+
+**For unattended automation**, where nobody can type a passphrase, a raw key in
+the environment still works exactly as before — `ROZO_CHECKOUT_SOL_KEY` or
+`ROZO_CHECKOUT_EVM_KEY`, or `ROZO_CHECKOUT_KEYSTORE_PASSPHRASE` alongside a
+keystore. On a machine a person uses, prefer a key file.
+
+These settings can also live in a `.env` in the directory you run from (or
+`--env-file <path>`). Only `ROZO_CHECKOUT_*` keys are read from it, it is
+parsed as plain text and never run through a shell, and anything already in
+your real environment wins. **Add `.env` to your `.gitignore`.**
+
+A key file or `.env` must not be readable by other users (`chmod 600`) and must
+not be tracked by git. Both are refused rather than warned about.
+
+<details>
+<summary><b>Set up a local wallet for <code>--send</code></b> — .env template and per-wallet export steps</summary>
+
+**None of this is needed for the default path.** Paying from your own wallet
+needs no key and no configuration, and works with wallets that can never be
+used here — including hardware wallets and exchange accounts.
+
+A `.env` in the directory you run from, with every variable this tool reads:
+
+```bash
+# None of this is needed to pay from your own wallet. These are read only
+# when you use --send.
+
+# Solana secret key: a base58 string, or a JSON byte array. Only needed if you
+# do NOT have ~/.config/solana/id.json, which is picked up automatically.
+ROZO_CHECKOUT_SOL_KEY=REPLACE_ME_base58_secret_key
+
+# EVM raw private key: 64 hex characters, 0x prefix optional. The least safe
+# option — prefer the keystore below.
+ROZO_CHECKOUT_EVM_KEY=0x0000000000000000000000000000000000000000000000000000000000000000
+
+# EVM encrypted V3 keystore: path to the file. Preferred over the raw key.
+ROZO_CHECKOUT_EVM_KEYSTORE=/replace/me/keystores/my-hot-wallet
+
+# Passphrase for that keystore. Only for unattended runs; on a terminal you
+# are prompted instead, and nothing is stored.
+ROZO_CHECKOUT_KEYSTORE_PASSPHRASE=REPLACE_ME_not_a_real_passphrase
+
+# Optional RPC overrides, one per chain id. 8453 = Base, 900 = Solana.
+ROZO_CHECKOUT_RPC_8453=https://mainnet.base.org
+ROZO_CHECKOUT_RPC_900=https://api.mainnet-beta.solana.com
+```
+
+Then lock it down and keep it out of git:
+
+```bash
+chmod 600 .env
+echo '.env' >> .gitignore
+```
+
+**Solana**
+
+- `solana-keygen new` writes `~/.config/solana/id.json`. Nothing to configure —
+  it is found automatically. This is the path we recommend.
+- **Phantom** → Settings → Export Private Key gives a **base58** string. Put it
+  in `ROZO_CHECKOUT_SOL_KEY`.
+- **Solflare** exports a base58 string in current versions and a JSON byte
+  array in older ones. Both are accepted as-is.
+
+**EVM**
+
+- **MetaMask** and **Rabby** → Export private key gives 64 hex characters.
+  Paste it into `ROZO_CHECKOUT_EVM_KEY` as-is; the `0x` prefix is optional.
+- **Encrypted keystore (safer).** Browser wallets export raw keys, not
+  keystores. To turn one into an encrypted keystore, use Foundry:
+  `cast wallet import my-hot-wallet --interactive` prompts for the key and
+  writes an encrypted V3 keystore to `~/.foundry/keystores/my-hot-wallet`
+  (`--keystore-dir` changes where). Point `ROZO_CHECKOUT_EVM_KEYSTORE` at that
+  file. `geth account import` also produces a V3 keystore.
+
+**Wallets that cannot be used with `--send`:** hardware wallets (Ledger,
+Trezor), WalletConnect-only mobile wallets, and exchange accounts. None of them
+hand over a signing key, by design. Use the default keyless path instead — it
+works with all of them.
+
+</details>
+
+
+A single payment may not exceed **$1,100**; above that, pay from your own
+wallet as above.
 
 ```json
 {

package/docs/QUICKSTART.zh.md

@@ -44,6 +44,16 @@ LINK="https://payments.coinbase.com/payment-links/pl_01YOURLINKID"
 链 id：`1` Ethereum · `56` BNB Chain · `137` Polygon · `8453` Base ·
 `900` Solana · `1500` Stellar · `lightning` Bitcoin Lightning。
 
+## 我需要什么钱包？
+
+**一个钱包、一条链就够了——不需要每条链各准备一个。**挑一种你已经持有的币，然后从它现在所在的地方付款即可。
+
+任何钱包都可以，从交易所提币同样可以：下面的 Mode A 只是打印一段充值信息，你按其中给出的 `amount`、`tokenSymbol`、`chain`，把钱发到 `receiverAddress` 即可。全程不需要连接任何网站，也不需要在浏览器里做任何授权。实践中大家在 EVM 链上用 MetaMask 或 Rabby，在 Solana 上用 Phantom 或 Solflare，付 BTC 时用 Phoenix、Wallet of Satoshi 之类的闪电钱包。
+
+有两种情况不一样。**Stellar** 走的是共享地址加 `receiverMemo` 的方式，所以你的付款来源必须能填写 memo——漏掉 memo，这笔钱就丢了。**闪电网络**付的是 `deposit.lnInvoice` 里的 BOLT11 invoice，没有可转账的地址。
+
+只有 `--send`（Mode B）需要私钥，且仅支持 EVM 链和 Solana：Solana 直接用 `solana-keygen` 已经生成的 `~/.config/solana/id.json`，EVM 用加密的 keystore（口令交互式输入）。环境变量里的原始私钥保留给无人值守的自动化。
+
 ## 1. 报价（只读，免费）
 
 ```bash
@@ -119,7 +129,7 @@ node scripts/dist/create-order.js --url "$LINK" --chain 900 --token USDT --confi
 }
 ```
 
-严格按这个信息块给出的字段来发送。对于 Lightning，`deposit.lnInvoice` 里是供扫码的
+严格按这个信息块给出的字段来发送。Stellar 上的 memo 即使看起来是纯数字，也**始终是 `MEMO_TEXT`** —— 按 `MEMO_ID` 发送不会被匹配上。`deposit.expiresIn` 会告诉你订单还有多久过期。对于 Lightning，`deposit.lnInvoice` 里是供扫码的
 BOLT11 字符串，`deposit.amount` 的单位是聪 (satoshis)。
 
 ## 4. 付款
@@ -140,21 +150,99 @@ BOLT11 字符串，`deposit.amount` 的单位是聪 (satoshis)。
 
 ### 可选的方式：让脚本替你付（模式 B）
 
-只有当你想让这台机器替你签名时才需要，而且仅限 EVM 链与 Solana。这是唯一需要私钥的
-部分：
+只有当你想让这台机器替你签名时才需要，而且**只支持 EVM 链和 Solana** —— Stellar 和
+闪电网络没有 `--send`，只能用你自己的钱包付。这是整个流程里唯一需要私钥的部分。
+
+**Solana —— 直接用你已有的密钥对。** 只要你跑过 `solana-keygen`，
+`~/.config/solana/id.json` 就已经存在，脚本会自动使用它：
+
+```bash
+node scripts/dist/send-sol.js --rozo-payment-id <rozoPaymentId> --send
+```
+
+**EVM —— 用加密的 keystore。** 从你的钱包导出一个 V3 JSON keystore 并指向它。
+口令 (passphrase) 会交互式提示输入，永远不会作为命令行参数传递：
+
+```bash
+ROZO_CHECKOUT_EVM_KEYSTORE=~/wallets/hot.json \
+  node scripts/dist/send-evm.js --rozo-payment-id <rozoPaymentId> --send
+```
+
+两种文件也都可以用 `--keyfile <path>` 显式指定；`--dry-run` 对所有来源都有效：
+它会推导出地址并跑完所有检查，但不签任何名。
+
+**用于无人值守的自动化**（没有人能输入口令的场景），环境变量里的原始私钥依然照旧
+可用 —— `ROZO_CHECKOUT_SOL_KEY` 或 `ROZO_CHECKOUT_EVM_KEY`，或者配合 keystore 使用
+`ROZO_CHECKOUT_KEYSTORE_PASSPHRASE`。在有人使用的机器上，优先用密钥文件。
+
+这些设置也可以放在你运行命令所在目录的 `.env` 里（或者用 `--env-file <path>` 指定）。
+其中只有 `ROZO_CHECKOUT_*` 开头的键会被读取，文件按纯文本解析、绝不交给 shell 执行，
+而且真实环境变量优先级更高。**记得把 `.env` 加进 `.gitignore`。**
+
+密钥文件和 `.env` 都不能被其他用户读取（`chmod 600`），也不能被 git 跟踪。这两种情况都会被
+直接拒绝，而不是只给个警告。
+
+<details>
+<summary><b>为 <code>--send</code> 配置本地钱包</b> —— .env 模板与各钱包导出步骤</summary>
+
+**默认路径不需要这里的任何东西。** 用你自己的钱包付款既不需要私钥也不需要任何配置，
+而且支持那些在这里根本用不了的钱包 —— 包括硬件钱包和交易所账户。
+
+在你运行命令的目录放一个 `.env`，下面列出了本工具会读取的全部变量：
 
 ```bash
-# 预览将要签名的确切内容 —— 不会签任何名
-ROZO_CHECKOUT_SOL_KEY=<base58 secret key> \
-  node scripts/dist/send-sol.js --rozo-payment-id <rozoPaymentId> --dry-run
+# 用你自己的钱包付款不需要下面任何一项。它们只在你使用 --send 时才被读取。
+
+# Solana 私钥：base58 字符串，或 JSON 字节数组。只有在你没有
+# ~/.config/solana/id.json（它会被自动识别）时才需要填。
+ROZO_CHECKOUT_SOL_KEY=REPLACE_ME_base58_secret_key
+
+# EVM 原始私钥：0x 加 64 位十六进制。这是最不安全的方式 —— 优先用下面的 keystore。
+ROZO_CHECKOUT_EVM_KEY=0x0000000000000000000000000000000000000000000000000000000000000000
 
-# 真正发送。--send 是必需的。
-ROZO_CHECKOUT_SOL_KEY=<base58 secret key> \
-  node scripts/dist/send-sol.js --rozo-payment-id <rozoPaymentId> --send
+# EVM 加密 V3 keystore：文件路径。比上面的原始私钥更推荐。
+ROZO_CHECKOUT_EVM_KEYSTORE=/replace/me/keystores/my-hot-wallet
+
+# 该 keystore 的口令。只在无人值守时需要；在终端上会交互式提示，且不会被保存。
+ROZO_CHECKOUT_KEYSTORE_PASSPHRASE=REPLACE_ME_not_a_real_passphrase
+
+# 可选的 RPC 覆盖，按链 id 一条。8453 = Base，900 = Solana。
+ROZO_CHECKOUT_RPC_8453=https://mainnet.base.org
+ROZO_CHECKOUT_RPC_900=https://api.mainnet-beta.solana.com
 ```
 
-Ethereum、BNB Chain、Polygon 和 Base 用 `send-evm.js` 配合 `ROZO_CHECKOUT_EVM_KEY`。
-单笔付款不得超过 **$1,100**；超过这个数就按上面的方式用你自己的钱包付。
+然后锁好权限，并确保它不进 git：
+
+```bash
+chmod 600 .env
+echo '.env' >> .gitignore
+```
+
+**Solana**
+
+- `solana-keygen new` 会写出 `~/.config/solana/id.json`。什么都不用配 —— 它会被自动
+  找到。这是我们推荐的方式。
+- **Phantom** → Settings → Export Private Key 给出的是 **base58** 字符串，填进
+  `ROZO_CHECKOUT_SOL_KEY`。
+- **Solflare** 新版本导出 base58 字符串，旧版本导出 JSON 字节数组。两种都可以直接用。
+
+**EVM**
+
+- **MetaMask** 和 **Rabby** → 导出私钥给出的是 64 位十六进制字符串。直接原样粘贴到
+  `ROZO_CHECKOUT_EVM_KEY` 即可；`0x` 前缀加不加都行。
+- **加密 keystore（更安全）。** 浏览器钱包只能导出原始私钥，不能导出 keystore。
+  想把私钥变成加密 keystore，可以用 Foundry：`cast wallet import my-hot-wallet
+  --interactive` 会提示你输入私钥，并把加密的 V3 keystore 写到
+  `~/.foundry/keystores/my-hot-wallet`（用 `--keystore-dir` 可改目录）。然后把
+  `ROZO_CHECKOUT_EVM_KEYSTORE` 指向该文件。`geth account import` 同样会生成 V3 keystore。
+
+**不能用于 `--send` 的钱包：** 硬件钱包（Ledger、Trezor）、只支持 WalletConnect 的
+手机钱包，以及交易所账户。它们在设计上就不会交出签名私钥。这类用户请走默认的无私钥
+路径 —— 那条路对它们全都适用。
+
+</details>
+
+单笔付款不得超过 **$1,100**；超过就按上面的方式用你自己的钱包付。
 
 ```json
 {

package/docs/README.es.md

@@ -34,11 +34,32 @@ npx @rozoai/checkout pay <coinbase-link> --with usdt-solana
 | Polygon | `usdt-polygon` `usdc-polygon` | `137` | 6 decimales |
 | Base | `usdc-base` | `8453` | 6 decimales |
 | Solana | `usdt-solana` `usdc-solana` | `900` | SPL; SOL nativo no admitido |
-| Stellar | `usdc-stellar` | `1500` | memo obligatorio — se muestra en el bloque de depósito |
+| Stellar | `usdc-stellar` | `1500` | memo `MEMO_TEXT` obligatorio — se muestra en el bloque de depósito |
 | Bitcoin Lightning | `btc-lightning` | `lightning` | BOLT11; importes en satoshis |
 
 Las monedas de gas nativas (SOL, BNB, ETH, MATIC) y el BTC on-chain no se aceptan.
 
+## ¿Qué wallet necesito?
+
+**Una wallet, en una cadena: no hace falta una por cada cadena.** Elige de la
+tabla de arriba la moneda que ya tengas y paga desde donde ya esté.
+
+- **Sirve cualquier wallet, y también un retiro desde un exchange.** La vía por
+  defecto solo imprime un bloque de depósito: envía exactamente ese `amount` de
+  ese `tokenSymbol`, en esa `chain`, a esa `receiverAddress`. Nada se conecta a
+  ningún sitio ni se aprueba en el navegador. En la práctica la gente usa
+  MetaMask o Rabby en las cadenas EVM, Phantom o Solflare en Solana, y una
+  wallet Lightning como Phoenix o Wallet of Satoshi para BTC.
+- **Stellar es la que exige cuidado.** Sus depósitos se enrutan mediante una
+  dirección compartida más `receiverMemo`, así que aquello desde lo que envíes
+  — exchange o wallet — debe permitirte fijar un memo. Si lo omites, el pago se
+  pierde.
+- **Lightning paga una factura, no una dirección.** Escanea o pega
+  `deposit.lnInvoice`; no hay ninguna dirección a la que enviar.
+- **Solo `--send` necesita una clave privada**, leída de
+  `ROZO_CHECKOUT_EVM_KEY` o `ROZO_CHECKOUT_SOL_KEY`, y cubre únicamente las
+  cadenas EVM y Solana. Todo lo demás no usa claves.
+
 ## Usarlo desde el agente
 
 La carga útil es la misma en todas partes: el comando de una línea de arriba, o
@@ -82,7 +103,7 @@ Para pagar un enlace de pago de OpenRouter / Coinbase, ejecuta:
 npx @rozoai/checkout pay <coinbase-link> --with usdt-solana
 ```
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado, y solo admite cadenas EVM y Solana (Stellar y Lightning son solo Modo A).
 </details>
 
 <details>
@@ -96,7 +117,7 @@ propio comando:
 npx @rozoai/checkout pay <coinbase-link> --with usdt-solana
 ```
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado.
 </details>
 
 <details>
@@ -109,7 +130,7 @@ Para pagar un enlace de pago de OpenRouter / Coinbase, ejecuta:
 npx @rozoai/checkout pay <coinbase-link> --with usdt-solana
 ```
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado.
 </details>
 
 <details>
@@ -122,7 +143,7 @@ Para pagar un enlace de pago de OpenRouter / Coinbase, ejecuta:
 npx @rozoai/checkout pay <coinbase-link> --with usdt-solana
 ```
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado.
 </details>
 
 <details>
@@ -136,7 +157,7 @@ Descarga https://checkout.rozo.ai/llms.txt y luego paga este enlace de OpenRoute
 npx @rozoai/checkout pay <coinbase-link> --with usdt-solana
 ```
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado.
 </details>
 
 <details>
@@ -149,7 +170,7 @@ con un pago que se dispara desde un script o desde un canal de chat:
 openclaw agent exec "Pay this OpenRouter link with USDT on Solana by running: npx @rozoai/checkout pay <coinbase-link> --with usdt-solana"
 ```
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado.
 </details>
 
 <details>
@@ -163,7 +184,7 @@ Paga este enlace de OpenRouter con USDT en Solana ejecutando:
 npx @rozoai/checkout pay <coinbase-link> --with usdt-solana
 ```
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado.
 </details>
 
 <details>
@@ -212,7 +233,76 @@ para pagar este enlace de OpenRouter: <coinbase-link>
 Si el agente no tiene shell pero puede hacer peticiones HTTP, puede manejar
 directamente los cuatro endpoints públicos — ver [cómo funciona](how-it-works.md).
 
-Billetera: cualquier billetera, **sin clave**. `--send` sí necesita la clave del entorno.
+Billetera: cualquier billetera, **sin clave**. Solo `--send` la necesita: firma localmente con el par de claves de la CLI de Solana o un keystore cifrado.
+</details>
+
+<details>
+<summary><b>Configurar una billetera local para <code>--send</code></b> — plantilla .env y pasos de exportación por billetera</summary>
+
+**Nada de esto hace falta para la ruta por defecto.** Pagar desde la propia
+billetera no necesita clave ni configuración, y funciona con billeteras que aquí
+nunca se pueden usar, incluidas las de hardware y las cuentas de exchange.
+
+Un `.env` en el directorio desde el que se ejecuta, con todas las variables que
+esta herramienta lee:
+
+```bash
+# Nada de esto hace falta para pagar desde la propia billetera. Solo se lee
+# cuando se usa --send.
+
+# Clave secreta de Solana: una cadena base58 o un arreglo JSON de bytes. Solo
+# hace falta si NO se tiene ~/.config/solana/id.json, que se detecta solo.
+ROZO_CHECKOUT_SOL_KEY=REPLACE_ME_base58_secret_key
+
+# Clave privada EVM en bruto: 0x seguido de 64 caracteres hex. La opción menos
+# segura: es preferible el keystore de abajo.
+ROZO_CHECKOUT_EVM_KEY=0x0000000000000000000000000000000000000000000000000000000000000000
+
+# Keystore V3 cifrado para EVM: ruta al archivo. Preferible a la clave en bruto.
+ROZO_CHECKOUT_EVM_KEYSTORE=/replace/me/keystores/my-hot-wallet
+
+# Frase de contraseña de ese keystore. Solo para ejecuciones desatendidas; en
+# una terminal se solicita y no se guarda nada.
+ROZO_CHECKOUT_KEYSTORE_PASSPHRASE=REPLACE_ME_not_a_real_passphrase
+
+# Sobrescrituras de RPC opcionales, una por id de cadena. 8453 = Base,
+# 900 = Solana.
+ROZO_CHECKOUT_RPC_8453=https://mainnet.base.org
+ROZO_CHECKOUT_RPC_900=https://api.mainnet-beta.solana.com
+```
+
+Después, restringir permisos y mantenerlo fuera de git:
+
+```bash
+chmod 600 .env
+echo '.env' >> .gitignore
+```
+
+**Solana**
+
+- `solana-keygen new` escribe `~/.config/solana/id.json`. No hay nada que
+  configurar: se encuentra automáticamente. Es la ruta recomendada.
+- **Phantom** → Settings → Export Private Key da una cadena **base58**. Va en
+  `ROZO_CHECKOUT_SOL_KEY`.
+- **Solflare** exporta una cadena base58 en las versiones actuales y un arreglo
+  JSON de bytes en las antiguas. Ambos se aceptan tal cual.
+
+**EVM**
+
+- **MetaMask** y **Rabby** exportan la clave privada como 64 caracteres hex.
+  Pegarla tal cual en `ROZO_CHECKOUT_EVM_KEY`; el prefijo `0x` es opcional.
+- **Keystore cifrado (más seguro).** Las billeteras de navegador exportan claves
+  en bruto, no keystores. Para convertir una en un keystore cifrado, usar
+  Foundry: `cast wallet import my-hot-wallet --interactive` pide la clave y
+  escribe un keystore V3 cifrado en `~/.foundry/keystores/my-hot-wallet`
+  (`--keystore-dir` cambia la ubicación). Apuntar `ROZO_CHECKOUT_EVM_KEYSTORE` a
+  ese archivo. `geth account import` también genera un keystore V3.
+
+**Billeteras que no se pueden usar con `--send`:** billeteras de hardware
+(Ledger, Trezor), billeteras móviles solo con WalletConnect y cuentas de
+exchange. Por diseño, ninguna entrega una clave de firma. Esos casos usan la
+ruta por defecto sin clave, que funciona con todas ellas.
+
 </details>
 
 ## Tres reglas que conviene conocer
@@ -239,6 +329,21 @@ La lista completa de lo que esta herramienta se niega a hacer, y por qué, está
 
 ## Registro de cambios
 
+- **0.1.3** — Correcciones surgidas del primer pago real. Los bundles ya no fallan
+  con `__filename is not defined` en Node 22+ (el banner de esbuild ahora define
+  `__filename`/`__dirname` además de `require`, y las pruebas ejecutan cada bundle
+  de verdad). Los depósitos de Stellar indican el tipo de memo (`MEMO_TEXT`, aunque
+  el memo parezca numérico). Las órdenes muestran la validez restante como duración
+  ("expires in 47m") en el bloque de depósito y en `status`, con el comando exacto
+  para crear una nueva. Reutilizar una orden impaga existente, y pedir una moneda
+  distinta a la suya, ahora se explican en lugar de parecer errores.
+- **0.1.2** — El Modo B ya no necesita una clave privada en bruto en una variable
+  de entorno. En Solana usa el `~/.config/solana/id.json` que `solana-keygen` ya
+  creó; en EVM un keystore V3 cifrado cuya frase de contraseña se solicita.
+  `--keyfile` indica cualquiera de los dos explícitamente, y los ajustes pueden
+  venir de un `.env` incluido en `.gitignore`. Las claves en bruto del entorno
+  siguen funcionando para automatización desatendida. Los archivos de claves y
+  el `.env` deben ser `chmod 600` y no estar bajo seguimiento de git.
 - **0.1.1** — un solo límite de gasto en lugar de dos: un pago individual no
   puede superar los $1,100 (dimensionado para una compra de crédito de $1,000
   más su comisión del 5%); se eliminan el tope acumulado por sesión y la bandera