Accept Nano payments without a processor

NANO_RPC=https://your-node.example/rpc node accept-nano.mjs nano_1yourAddress… 0.05

NANO_RPC=https://your-node.example/rpc node accept-nano.mjs --check <send block hash> <your address> <amount in raw>

// Accept one Nano payment without a payment processor.
// From the nano133.com guide "Accept Nano payments without a processor".
// Node.js 18 or newer, no packages. MIT license.
//
//   NANO_RPC=https://your-node.example/rpc node accept-nano.mjs <your nano_ address> <price in XNO>
//       makes a checkout with a unique amount, prints the payment link, and
//       waits (15 minutes) until a confirmed send of exactly that amount arrives.
//
//   NANO_RPC=… node accept-nano.mjs --check <send block hash> <your address> <amount in raw>
//       checks one block the way the checkout does, without a payment.
//
// Use your own node: its answers decide what you credit.

const RPC = process.env.NANO_RPC;
const RAW_PER_XNO = 10n ** 30n;
const STEP = 10n ** 26n; // prices round up to 0.0001 XNO; the unique tail lives below it
const OPEN_MS = 15 * 60_000;

async function rpc(body) {
  const res = await fetch(RPC, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(body), signal: AbortSignal.timeout(10_000) });
  const json = await res.json();
  if (json.error) throw new Error(`${body.action}: ${json.error}`);
  return json;
}

/** "0.05" XNO → raw, rounded up to 0.0001 XNO. */
function priceRaw(xno) {
  const [whole, frac = ""] = String(xno).split(".");
  const raw = BigInt(whole || "0") * RAW_PER_XNO + BigInt((frac + "0".repeat(30)).slice(0, 30));
  return ((raw + STEP - 1n) / STEP) * STEP;
}

/** The price plus a random tail of 1 to 999999 raw: this checkout's own amount. */
const uniqueAmount = (price) => price + BigInt(1 + Math.floor(Math.random() * 999_999));

const toXno = (raw) => {
  const s = raw.toString().padStart(31, "0");
  const frac = s.slice(-30).replace(/0+$/, "");
  return `${s.slice(0, -30).replace(/^0+(?=\d)/, "")}${frac ? `.${frac}` : ""}`;
};

/**
 * Does `hash` pay this checkout? A send, to `to`, of exactly `amount`,
 * first seen by the node inside the window, and confirmed.
 */
async function check(hash, to, amount, window) {
  const b = await rpc({ action: "block_info", hash, json_block: "true" });
  const subtype = b.subtype ?? b.contents.subtype;
  if (subtype !== "send") return "not a send";
  if (b.contents.link_as_account !== to) return "sent to another address";
  if (b.amount !== amount) return "another amount";
  const seen = Number(b.local_timestamp ?? 0) * 1000;
  if (window && (seen < window.from || seen > window.until)) return "sent outside this checkout's window";
  return b.confirmed === "true" ? "paid" : "not confirmed yet";
}

/** Sends of exactly `amount` to `to`: still receivable, or already received by a wallet. */
async function candidates(to, amount) {
  const hashes = new Set();
  const r = await rpc({ action: "receivable", account: to, count: "50", threshold: amount, source: "true" });
  for (const [hash, v] of Object.entries(r.blocks || {})) if (v.amount === amount) hashes.add(hash);
  // A wallet that receives by itself takes the send off the receivable list: look in the history too.
  const h = await rpc({ action: "account_history", account: to, count: "50", raw: "true" }).catch(() => ({ history: [] }));
  for (const e of h.history || []) if (e.subtype === "receive" && e.amount === amount) hashes.add(e.link);
  return [...hashes];
}

if (!RPC) {
  console.error("Set NANO_RPC to your node's RPC URL.");
  process.exit(1);
}
const args = process.argv.slice(2);

if (args[0] === "--check") {
  const [, hash, to, amount] = args;
  console.log(await check(hash, to, amount, null));
} else {
  const [to, price] = args;
  if (!/^nano_[13][13456789abcdefghijkmnopqrstuwxyz]{59}$/.test(to ?? "") || !(Number(price) > 0)) {
    console.error("Usage: node accept-nano.mjs <your nano_ address> <price in XNO>");
    process.exit(1);
  }
  const amount = uniqueAmount(priceRaw(price)).toString();
  const window = { from: Date.now() - 60_000, until: Date.now() + OPEN_MS };
  console.log(`Pay exactly Ӿ${toXno(BigInt(amount))}`);
  console.log(`Wallet link: nano:${to}?amount=${amount}`);
  console.log("Waiting for the payment…");
  const seen = new Set();
  while (Date.now() < window.until) {
    for (const hash of await candidates(to, amount)) {
      const result = await check(hash, to, amount, window);
      if (result === "paid") {
        console.log(`Paid: block ${hash}. Record this hash so it pays only one checkout.`);
        process.exit(0);
      }
      if (!seen.has(hash + result)) console.log(`${hash.slice(0, 12)}…: ${result}`);
      seen.add(hash + result);
    }
    await new Promise((r) => setTimeout(r, 2000));
  }
  console.log("The checkout expired with no payment.");
}