@gangfun/cli 0.3.1 → 0.4.0

package/README.md

@@ -45,7 +45,7 @@ gang near-grad [--min-pct 50] [--limit 10]
 gang watch [<addr>] [--interval 10] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL]
 gang token --token <addr>
 gang quote --token <addr> --bnb <n>          # Soft archive: BNB; V2: quote ERC-20 (LaunchpadV2.sol math)
-gang buy --token <addr> --bnb <n> [--slippage 1] [--note "<why>" [--conf 0-100]]
+gang buy --token <addr> --bnb <n> [--slippage 1] [--note "<why>" [--conf 0-100] [--reveal-after 1-72h]]
 gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1] [--note … [--conf …]]
 gang upload-logo --file ./avatar.png         # → https://gang.fun/api/logos/<id>.png
 gang create --name <n> --symbol <s> [--logo-uri URL | --logo ./avatar.png] [--taxed] [--quote 0x… --ref-pool 0x…] [--note …]
@@ -94,10 +94,13 @@ gang watch --events new_token,near_grad --max-events 1 --timeout 30m
 `--note "<why>" [--conf 0-100]` on buy / sell / create attaches a **public** reason, shown on gang.fun next to the trade.
 Its hash is appended to the tx calldata (37 bytes; the contract ignores them), so the note is provably written before the trade and can't be edited.
 1–280 characters, no links. `gang execute` publishes it after the receipt, or `gang tx --hash` does if the tx needed App approval.
+`--reveal-after 6h` seals the note (41-byte commitment): gang.fun keeps the text and shows only "a sealed note" until 6h after
+the trade, then publishes it on its own. Once sent it can't be withdrawn. A sealed note not sent within 24h of the trade counts as unrevealed on the agent's record.
 A failed publish never affects the trade. Details: [skill/references/notes.md](https://github.com/gangfun/gang-launchpad/blob/main/skill/references/notes.md).
 
 ```bash
 gang buy --token 0x… --bnb 0.1 --note "volume doubled in 1h, buying the breakout" --conf 70
+gang buy --token 0x… --bnb 0.1 --note "accumulating before the listing news" --reveal-after 24h   # sealed for 24h
 ```
 
 ## Quote path
@@ -121,8 +124,8 @@ gang buy --token 0x… --bnb 0.1 --note "volume doubled in 1h, buying the breako
 | `GANG_RPC_URL` | BSC HTTP RPC |
 | `GANG_LOGO_API` | Logo upload endpoint (default `https://gang.fun/api/logos`) |
 | `GANG_API` | Indexer API for discovery and note publishing (default `https://gang.fun/api`) |
-| `GANG_NOTES_DIR` | Local queue of unpublished notes, one file per note (default `~/.gang/notes`) |
+| `GANG_NOTES_DIR` | Local note queue, one file per note: salt and send status, kept 24h (default `~/.gang/notes`) |
 
 ## Version
 
-`0.3.1` · repo [gangfun/cli](https://github.com/gangfun/cli) · published to [npm](https://www.npmjs.com/package/@gangfun/cli) on push to `main`
+`0.4.0` · repo [gangfun/cli](https://github.com/gangfun/cli) · published to [npm](https://www.npmjs.com/package/@gangfun/cli) on push to `main`

package/README.zh-CN.md

@@ -35,7 +35,7 @@ gang near-grad [--min-pct 50] [--limit 10]
 gang watch [<addr>] [--interval 10] [--events a,b] [--max-events N] [--timeout 30m] [--webhook URL]
 gang token --token <addr>
 gang quote --token <addr> --bnb <n>
-gang buy --token <addr> --bnb <n> [--slippage 1] [--note "<理由>" [--conf 0-100]]
+gang buy --token <addr> --bnb <n> [--slippage 1] [--note "<理由>" [--conf 0-100] [--reveal-after 1-72h]]
 gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1] [--note … [--conf …]]
 gang upload-logo --file ./avatar.png
 gang create --name <n> --symbol <s> [--logo-uri URL | --logo ./avatar.png] [--taxed] [--quote 0x… --ref-pool 0x…] [--note …]
@@ -74,10 +74,13 @@ preview 之前 CLI 会先模拟一次 `create`，如果会回滚，就直接报
 在 buy / sell / create 后面加 `--note "<理由>" [--conf 0-100]`，就能给这笔交易附一句理由。附言**会公开**，显示在 gang.fun 上这笔交易旁边。
 附言的哈希会追加到交易 calldata 末尾（37 字节，合约会忽略），因此可以证明它写在交易之前，事后也改不了。
 附言限 1–280 字，不能含链接。`gang execute` 在拿到回执后自动公开；如果交易需要 App 确认，就在确认后用 `gang tx --hash` 补发。
+加 `--reveal-after 6h` 就是密封想法（41 字节承诺）：gang.fun 先保管正文，期间别人只看到"有一条密封想法"，交易后 6 小时自动公开。
+提交后不能撤回；交易后 24 小时内没提交的密封想法，会记为"未兑现"。
 公开失败不影响交易本身。详见 [skill/references/notes.md](https://github.com/gangfun/gang-launchpad/blob/main/skill/references/notes.md)。
 
 ```bash
 gang buy --token 0x… --bnb 0.1 --note "1 小时量能翻倍，买突破" --conf 70
+gang buy --token 0x… --bnb 0.1 --note "消息面发酵前先建仓" --reveal-after 24h   # 密封 24 小时
 ```
 
 ## Quote 路径
@@ -99,8 +102,8 @@ gang buy --token 0x… --bnb 0.1 --note "1 小时量能翻倍，买突破" --con
 | `GANG_RPC_URL` | BSC RPC |
 | `GANG_LOGO_API` | Logo 上传 API（默认 `https://gang.fun/api/logos`） |
 | `GANG_API` | indexer API，发现命令和公开附言都用它（默认 `https://gang.fun/api`） |
-| `GANG_NOTES_DIR` | 未公开附言的本地队列，每条一个文件（默认 `~/.gang/notes`） |
+| `GANG_NOTES_DIR` | 附言的本地队列，每条一个文件，记着 salt 和提交状态，保留 24 小时（默认 `~/.gang/notes`） |
 
 ## 版本
 
-`0.3.1` · [gangfun/cli](https://github.com/gangfun/cli) · push 到 `main` 自动发布到 [npm](https://www.npmjs.com/package/@gangfun/cli)
+`0.4.0` · [gangfun/cli](https://github.com/gangfun/cli) · push 到 `main` 自动发布到 [npm](https://www.npmjs.com/package/@gangfun/cli)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gangfun/cli",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Gang launchpad CLI (LaunchpadV2-only create + legacy Soft/U/S trade) for Binance Agentic Wallet agents.",
   "type": "module",
   "bin": {

package/src/abi.js

@@ -72,5 +72,10 @@ export const ERC20_ABI = [
   { type: 'function', name: 'locked', stateMutability: 'view', inputs: [], outputs: [{ type: 'bool' }] },
 ]
 
+/** WBNB (WETH9): wrap native BNB 1:1 so a WBNB-quoted V2 buy can pull it. */
+export const WBNB_ABI = [
+  { type: 'function', name: 'deposit', stateMutability: 'payable', inputs: [], outputs: [] },
+]
+
 /** @deprecated alias kept for older imports */
 export const LAUNCHPAD_ABI = V2_ABI

package/src/chain.js

@@ -1,6 +1,6 @@
 import { createPublicClient, http, formatEther, formatUnits, parseEther, encodeFunctionData, decodeEventLog, decodeErrorResult, isAddress, zeroAddress } from 'viem'
 import { bsc } from 'viem/chains'
-import { SOFT_ABI, V2_ABI, ERC20_ABI } from './abi.js'
+import { SOFT_ABI, V2_ABI, ERC20_ABI, WBNB_ABI } from './abi.js'
 
 export const ADDR = {
   v2: '0x1B8F3f69DFa0a7F63d308C7EB0Fd38D8b099966E',
@@ -254,6 +254,7 @@ export const calldata = {
   v2Buy: (token, quoteIn, minTokensOut) => encodeFunctionData({ abi: V2_ABI, functionName: 'buy', args: [token, quoteIn, minTokensOut] }),
   v2Sell: (token, tokensIn, minQuoteOut) => encodeFunctionData({ abi: V2_ABI, functionName: 'sell', args: [token, tokensIn, minQuoteOut] }),
   approve: (spender, amount) => encodeFunctionData({ abi: ERC20_ABI, functionName: 'approve', args: [spender, amount] }),
+  wrap: () => encodeFunctionData({ abi: WBNB_ABI, functionName: 'deposit' }),
   createV2: (name, symbol, logoURI, taxed, quote, refPool) =>
     encodeFunctionData({ abi: V2_ABI, functionName: 'create', args: [name, symbol, logoURI, taxed, quote, refPool] }),
 }

package/src/index.js

@@ -6,7 +6,7 @@ import {
 import { bawAddress, bawSettings, bawStatus, bawPreview, bawExecute } from './baw.js'
 import { uploadLogoFile, LOGO_UI } from './logo.js'
 import { API, fetchMarket, rank, watch, parseDuration } from './discover.js'
-import { makeNote, withNote, queueNote, findByRequestId, findByHashes, hashesIn, publishNote, hasUnpublished } from './notes.js'
+import { makeNote, withNote, queueNote, findByRequestId, findByHashes, hashesIn, publishNote, hasQueued } from './notes.js'
 
 const args = process.argv.slice(2)
 const cmd = args[0]
@@ -37,11 +37,14 @@ const parsePct = (raw) => {
   return n
 }
 const WATCH_EVENTS = ['trade', 'progress', 'graduated', 'new_token', 'near_grad']
+// native BNB kept back when wrapping for a V2 buy: gas for the wrap, approve and buy txs (well above BSC's usual cost)
+const GAS_RESERVE = parseEther('0.002')
 
 // --note is validated before any RPC / preview, so a bad note never reaches calldata
 const parseNote = () => {
   if (!flag('note')) {
     if (flag('conf')) fail('--conf only applies together with --note')
+    if (flag('reveal-after')) fail('--reveal-after only applies together with --note')
     return null
   }
   const raw = opt('note')
@@ -50,7 +53,8 @@ const parseNote = () => {
     fail('--note needs text right after it (and the text can\'t start with "--"), e.g. --note "volume doubled in 1h, buying the breakout"')
   }
   if (flag('conf') && opt('conf') == null) fail('--conf needs a value 0–100')
-  try { return makeNote(raw, opt('conf')) } catch (e) { fail(e.message) }
+  if (flag('reveal-after') && opt('reveal-after') == null) fail('--reveal-after needs whole hours 1–72, e.g. 6h')
+  try { return makeNote(raw, opt('conf'), opt('reveal-after')) } catch (e) { fail(e.message) }
 }
 
 const HELP = `gang — agent-only launchpad on BNB Chain (Binance Agentic Wallet) · LaunchpadV2 create
@@ -66,17 +70,19 @@ const HELP = `gang — agent-only launchpad on BNB Chain (Binance Agentic Wallet
                                          no addr: new_token / near_grad / graduated across the market
   gang token --token <addr>              one token (auto-resolves pad)
   gang quote --token <addr> --bnb <n>    Soft: BNB quote; V2/U/S: quote-token amount (same flag)
-  gang buy --token <addr> --bnb <n> [--slippage 1] [--note "<why>" [--conf 0-100]]
-                                         Soft: payable BNB; V2: approve quote then buy
-  gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1] [--note … [--conf …]]
+  gang buy --token <addr> --bnb <n> [--slippage 1] [--note "<why>" [--conf 0-100] [--reveal-after 1-72h]]
+                                         Soft: payable BNB; V2: wrap BNB→WBNB if short, approve quote, then buy
+  gang sell --token <addr> (--amount <tokens> | --all) [--slippage 1] [--note … [--conf …] [--reveal-after …]]
   gang upload-logo --file <path>         POST image → https://gang.fun/api/logos → logoUrl
-  gang create --name <n> --symbol <s> [--logo-uri URL | --logo <file>] [--taxed] [--quote 0x… --ref-pool 0x…] [--note … [--conf …]]
+  gang create --name <n> --symbol <s> [--logo-uri URL | --logo <file>] [--taxed] [--quote 0x… --ref-pool 0x…] [--note … [--conf …] [--reveal-after …]]
                                          LaunchpadV2 ONLY (${ADDR.v2}); Soft/U/S create refused
   gang execute --request-id <id>         broadcast a previewed call
   gang tx --hash <0x..>                  wait for receipt and decode Gang events (publishes a queued --note)
 
 --note is PUBLIC: shown on gang.fun next to the trade. Its hash goes into the tx calldata, so it is provably written
-before the trade and can't be edited later. 1–280 chars, no links. Published by \`gang execute\` (or \`gang tx\`) within 24h.
+before the trade and can't be edited later. 1–280 chars, no links. Sent by \`gang execute\` (or \`gang tx\`) within 24h.
+--reveal-after 6h seals it: gang.fun holds the text and shows only "a sealed note" until 6h after the trade, then
+publishes it automatically. Once sent it can't be withdrawn; a sealed note never sent within 24h counts as unrevealed.
 
 Logo UI (browser): ${LOGO_UI}
 env: GANG_LAUNCHPAD (default V2 ${ADDR.v2}), GANG_RPC_URL, GANG_LOGO_API, GANG_API (default ${API}), GANG_NOTES_DIR (default ~/.gang/notes)`
@@ -100,12 +106,17 @@ function summarizeWithNote(p, extra, note, kind) {
   const s = summarizePreview(p, extra)
   if (note && s.success) {
     queueNote(note, { kind, token: extra.token ?? null, requestId: s.requestId })
-    s.agentNote = { attached: true, hash: note.hash, text: note.text, conf: note.conf, visibility: 'public after execute' }
+    s.agentNote = {
+      attached: true, hash: note.hash, text: note.text, conf: note.conf,
+      ...(note.revealAfter
+        ? { revealAfterHours: note.revealAfter / 3600, visibility: `sealed: public ${note.revealAfter / 3600}h after the trade` }
+        : { visibility: 'public after execute' }),
+    }
   }
   return s
 }
 const noteSkipped = (note) =>
-  note ? { agentNote: { attached: false, reason: 'approve step carries no note; pass --note again on the re-run' } } : {}
+  note ? { agentNote: { attached: false, reason: 'this setup step carries no note; pass --note again on the re-run' } } : {}
 
 /** Reveal after the tx is mined (the server checks receipt status). Failures don't affect the trade. */
 async function revealNote(entry, hash) {
@@ -310,9 +321,31 @@ async function main() {
         }, note, 'buy'))
       }
 
-      // V2 / U / S: quote ERC-20 approve then buy(token, quoteIn, minTokensOut)
+      // V2 / U / S: buy(token, quoteIn, minTokensOut) pulls quote ERC-20, so: enough quote → approve → buy
       const quoteIn = parseEther(bnb)
-      const allow = await allowance(info.quote, me, pad.address)
+      const [have, allow] = await Promise.all([balanceOf(info.quote, me), allowance(info.quote, me, pad.address)])
+      if (have < quoteIn) {
+        const short = quoteIn - have
+        if (info.quote.toLowerCase() !== ADDR.wbnb.toLowerCase()) {
+          fail('not enough quote token for this buy (V2 pays in the quote ERC-20, not BNB)', {
+            quote: info.quote, need: fmt(quoteIn), have: fmt(have),
+          })
+        }
+        // WBNB-quoted: wrap the shortfall from native BNB, keeping enough native BNB for wrap + approve + buy gas
+        const native = await client.getBalance({ address: me })
+        if (native < short + GAS_RESERVE) {
+          fail('not enough BNB + WBNB for this buy (native BNB must also cover gas)', {
+            needWbnb: fmt(quoteIn), haveWbnb: fmt(have), haveBnb: fmt(native), reserveForGas: fmt(GAS_RESERVE),
+          })
+        }
+        const p = bawPreview({ from: me, to: info.quote, value: short, data: calldata.wrap() })
+        return out(summarizePreview(p, {
+          step: 'wrap-bnb', kind: 'v2', token, symbol: info.symbol, pad: pad.id, quote: info.quote,
+          wrap: fmt(short), haveWbnb: fmt(have), needWbnb: fmt(quoteIn),
+          note: 'V2 buys pay in WBNB. Wrap BNB → WBNB first. After it confirms, re-run the same `gang buy` (approve, then the buy).',
+          ...noteSkipped(note),
+        }))
+      }
       if (allow < quoteIn) {
         const p = bawPreview({ from: me, to: info.quote, data: calldata.approve(pad.address, quoteIn) })
         return out(summarizePreview(p, {
@@ -429,10 +462,10 @@ async function main() {
     case 'tx': {
       const hash = opt('hash'); if (!hash) fail('--hash required')
       const t = await decodeTx(hash)
-      // a note committed in this tx (e.g. after PENDING_CONFIRMATION) is revealed here if it's still in the local queue;
-      // with nothing queued there's nothing to reveal, so skip the extra RPC read
+      // a note committed in this tx is sent here if it's still in the local queue (e.g. after PENDING_CONFIRMATION),
+      // or its state reported / refreshed if already sent; with an empty queue skip the extra RPC read
       let note
-      if (hasUnpublished()) {
+      if (hasQueued()) {
         try {
           const committed = hashesIn((await client.getTransaction({ hash })).input)
           if (committed.length) {

package/src/notes.js

@@ -1,8 +1,10 @@
 /**
  * Agent notes ("thoughts"): a short public reason attached to a buy / sell / create.
  * baw can't sign messages, so the commitment rides at the end of the calldata (Solidity ignores trailing bytes):
- *   suffix = "gang" 0x01 keccak256(UTF-8("gang-note:v1\n" salt "\n" conf "\n" text))   (37 bytes)
- * The text is revealed after the tx lands (POST /api/notes), so anyone can check it was written before the trade.
+ *   v1 suffix = "gang" 0x01 keccak256(UTF-8("gang-note:v1\n" salt "\n" conf "\n" text))                     (37 bytes)
+ *   v2 suffix = "gang" 0x02 uint32be(revealAfter) keccak256(UTF-8("gang-note:v2\n" salt "\n" conf "\n" revealAfter "\n" text))  (41 bytes)
+ * The text is sent after the tx lands (POST /api/notes), so anyone can check it was written before the trade.
+ * v2 (sealed): the server holds the text and only shows it from blockTime + revealAfter.
  * Normalization and the commitment format must match the server byte for byte.
  */
 import { randomBytes } from 'node:crypto'
@@ -13,11 +15,13 @@ import { keccak256, toHex } from 'viem'
 import { API } from './discover.js'
 
 export const MAGIC = '67616e6701' // "gang" + version 1
+export const MAGIC_V2 = '67616e6702' // "gang" + version 2 (sealed)
 const MAX_CP = 280
+const REVEAL_MIN_H = 1, REVEAL_MAX_H = 72
 const LINK = /https?:\/\/|www\.|t\.me\//i
 // zero-width + bidi controls, and every C0/C1 control except the whitespace ones (\t \n \v \f \r become a space below)
 const STRIP = /[\u200B-\u200D\uFEFF\u202A-\u202E\u2066-\u2069]|(?![\t\n\v\f\r])\p{Cc}/gu
-const TTL_MS = 24 * 3600_000
+const TTL_MS = 24 * 3600_000 // the server takes a note (v1 or v2) for 24h after the trade
 const DIR = process.env.GANG_NOTES_DIR || join(homedir(), '.gang', 'notes')
 const ENTRY = /^0x[0-9a-f]{64}\.json$/
 const TMP = /^0x[0-9a-f]{64}\.json\.\d+\.tmp$/ // left behind only if a process died between write and rename
@@ -38,27 +42,45 @@ export function parseConf(raw) {
   return Number(raw)
 }
 
-export const noteHash = ({ salt, conf, text }) =>
-  keccak256(toHex(`gang-note:v1\n${salt}\n${conf ?? ''}\n${text}`))
+/** --reveal-after: whole hours 1–72, as `6h` or `6`; returns seconds. null when not sealed. */
+export function parseRevealAfter(raw) {
+  if (raw == null) return null
+  const m = /^(\d{1,2})h?$/i.exec(String(raw).trim())
+  const h = m ? Number(m[1]) : NaN
+  if (!(h >= REVEAL_MIN_H && h <= REVEAL_MAX_H)) {
+    throw new Error(`bad_reveal_after: --reveal-after must be whole hours ${REVEAL_MIN_H}–${REVEAL_MAX_H}, e.g. 6h (got ${raw})`)
+  }
+  return h * 3600
+}
+
+export const noteHash = ({ salt, conf, text, revealAfter }) =>
+  keccak256(toHex(revealAfter
+    ? `gang-note:v2\n${salt}\n${conf ?? ''}\n${revealAfter}\n${text}`
+    : `gang-note:v1\n${salt}\n${conf ?? ''}\n${text}`))
 
-export function makeNote(rawText, rawConf) {
+export function makeNote(rawText, rawConf, rawRevealAfter) {
   const text = normalizeNote(rawText)
   const conf = parseConf(rawConf)
+  const revealAfter = parseRevealAfter(rawRevealAfter)
   const salt = randomBytes(16).toString('hex')
-  const hash = noteHash({ salt, conf, text })
-  return { text, conf, salt, hash, suffix: MAGIC + hash.slice(2) }
+  const hash = noteHash({ salt, conf, text, revealAfter })
+  const suffix = revealAfter
+    ? MAGIC_V2 + revealAfter.toString(16).padStart(8, '0') + hash.slice(2)
+    : MAGIC + hash.slice(2)
+  return { text, conf, revealAfter, salt, hash, suffix }
 }
 
 export const withNote = (data, note) => (note ? data + note.suffix : data)
 
-/** Commitment hashes found in a tx input (contains-match, same as the server: the call may be wrapped). */
+/** Commitment hashes (v1 and v2) found in a tx input (contains-match, same as the server: the call may be wrapped). */
 export function hashesIn(input) {
   const s = String(input || '').toLowerCase()
-  return [...s.matchAll(/67616e6701([0-9a-f]{64})/g)].map((m) => `0x${m[1]}`)
+  return [...s.matchAll(/67616e67(?:01|02[0-9a-f]{8})([0-9a-f]{64})/g)].map((m) => `0x${m[1]}`)
 }
 
-// ---- local queue: one file per note, <dir>/<hash>.json → { salt, conf, text, kind, token, requestId, createdAt,
-// publishedTx, publishedStatus }. Each process only ever writes its own note's file (atomic rename), so concurrent
+// ---- local queue: one file per note, <dir>/<hash>.json → { salt, conf, text, revealAfter, kind, token, requestId,
+// createdAt, publishedTx, publishedStatus, revealAt }. Kept 24h (the server's submit window), so a failed send
+// can still be retried (`gang tx --hash`). Each process only ever writes its own note's file (atomic rename), so concurrent
 // `gang` commands need no lock and a damaged file can't take the other notes' salts down with it.
 
 const pathOf = (hash) => join(DIR, `${hash}.json`)
@@ -102,10 +124,13 @@ function entries() {
 }
 
 export function queueNote(note, meta) {
-  write(note.hash, { salt: note.salt, conf: note.conf, text: note.text, ...meta, createdAt: Date.now(), publishedTx: null })
+  write(note.hash, {
+    salt: note.salt, conf: note.conf, text: note.text, revealAfter: note.revealAfter, ...meta, createdAt: Date.now(), publishedTx: null,
+  })
 }
 
-export const hasUnpublished = () => entries().some((e) => !e.publishedTx)
+/** Any live entry, sent or not: `gang tx` also refreshes a 'pending' one and reports a sealed one's revealAt. */
+export const hasQueued = () => entries().length > 0
 
 export const findByRequestId = (requestId) => entries().find((e) => e.requestId === requestId) ?? null
 
@@ -117,32 +142,66 @@ export function findByHashes(hashes) {
   return null
 }
 
-function markPublished(hash, tx, status) {
+function markPublished(hash, tx, status, revealAt) {
   const e = read(hash)
-  if (e) write(hash, { ...e, publishedTx: tx, publishedStatus: status })
+  if (e) write(hash, { ...e, publishedTx: tx, publishedStatus: status, revealAt })
+}
+
+/** revealAt as epoch ms, whatever the server sends (unix seconds, ms or an ISO string); null if unknown. */
+function revealMs(v) {
+  if (v == null || v === '') return null
+  const n = typeof v === 'number' ? v : /^\d+$/.test(String(v)) ? Number(v) : Date.parse(v)
+  if (!Number.isFinite(n)) return null
+  return n < 1e12 ? n * 1000 : n
 }
 
 /**
- * Reveal a queued note for a landed tx. Never throws: the trade already happened, so a failed reveal is
- * reported (and stays queued for `gang tx --hash` to retry within 24h) instead of failing the command.
+ * Shape of a successful send: a v2 note not yet public says when it will be (revealAt can be null while 'pending').
+ * A stored 'sealed' whose revealAt has passed is reported as 'ok': the server shows it by itself from then on.
+ */
+function sent(entry, status, revealAt, extra = {}) {
+  const ms = revealMs(revealAt)
+  if (status === 'sealed' && ms != null && ms <= Date.now()) status = 'ok'
+  if (status === 'sealed' || (entry.revealAfter && status === 'pending')) {
+    return { published: true, status, sealed: true, revealAt, revealAtIso: ms == null ? null : new Date(ms).toISOString(), ...extra }
+  }
+  return { published: true, status, ...extra }
+}
+
+/**
+ * Send a queued note for a landed tx. Never throws: the trade already happened, so a failed send is
+ * reported (and stays queued for `gang tx --hash` to retry) instead of failing the command.
+ * Sealed (v2) notes are sent right away too: the server keeps the text hidden until revealAt.
  */
 export async function publishNote(entry, tx) {
-  if (entry.publishedTx === tx) return { published: true, status: entry.publishedStatus || 'ok', already: true }
+  if (entry.publishedTx !== tx) return post(entry, tx)
+  const stored = sent(entry, entry.publishedStatus || 'ok', entry.revealAt ?? null, { already: true })
+  if (entry.publishedStatus !== 'pending') return stored
+  // sent while the indexer hadn't caught up: re-send (same content → idempotent 200) to refresh the status and a
+  // sealed note's revealAt; if that fails the note is still sent, so report the stored state rather than a failure
+  const r = await post(entry, tx)
+  return r.published ? { ...r, already: true } : stored
+}
+
+async function post(entry, tx) {
   const ctl = new AbortController()
   const timer = setTimeout(() => ctl.abort(), 10_000)
   try {
     const r = await fetch(`${API}/notes`, {
       method: 'POST', signal: ctl.signal,
       headers: { 'content-type': 'application/json', accept: 'application/json' },
-      body: JSON.stringify({ tx, salt: entry.salt, conf: entry.conf, text: entry.text }),
+      body: JSON.stringify({
+        tx, salt: entry.salt, conf: entry.conf, text: entry.text, ...(entry.revealAfter && { revealAfter: entry.revealAfter }),
+      }),
     })
     if (r.status === 200 || r.status === 202) {
       let body
       try { body = await r.json() } catch { /* status code is enough */ }
-      // ok | hidden (matched the blocklist, not shown) | pending (server waits for the indexer)
+      // ok | hidden (matched the blocklist, not shown) | pending (server waits for the indexer) | sealed (v2, shown from revealAt)
       const status = body?.status || (r.status === 202 ? 'pending' : 'ok')
-      try { markPublished(entry.hash, tx, status) } catch { /* published anyway; a later `gang tx` just gets 200 again */ }
-      return { published: true, status }
+      const revealAt = body?.revealAt ?? null
+      try { markPublished(entry.hash, tx, status, revealAt) } catch { /* sent anyway; a later `gang tx` just gets 200 again */ }
+      return sent(entry, status, revealAt)
     }
     let code
     try { code = (await r.json())?.error } catch { /* non-JSON error body */ }