@toon-protocol/rig 2.0.0 → 2.1.0

package/dist/chunk-3EKP7PMM.js

@@ -0,0 +1,727 @@
+import {
+  recordKey
+} from "./chunk-O6TXHKWG.js";
+import {
+  MAX_OBJECT_SIZE
+} from "./chunk-X2CZPPDM.js";
+
+// src/standalone/nonce-guard.ts
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_DAEMON_PORT = 8787;
+function defaultDaemonPort() {
+  const env = process.env["TOON_CLIENT_HTTP_PORT"];
+  const parsed = env ? Number(env) : NaN;
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_DAEMON_PORT;
+}
+function defaultLockDir() {
+  return process.env["TOON_CLIENT_HOME"] ?? join(homedir(), ".toon-client");
+}
+var DaemonIdentityConflictError = class extends Error {
+  constructor(pubkey, daemonUrl) {
+    super(
+      `toon-clientd is running with this identity (${pubkey.slice(0, 8)}\u2026) at ${daemonUrl} \u2014 use daemon mode or stop the daemon. Two writers on one identity would race the payment channel's cumulative-claim watermark (double-charge hazard).`
+    );
+    this.pubkey = pubkey;
+    this.daemonUrl = daemonUrl;
+    this.name = "DaemonIdentityConflictError";
+  }
+  pubkey;
+  daemonUrl;
+};
+var StandaloneLockError = class extends Error {
+  constructor(pubkey, lockPath, holderPid) {
+    super(
+      `another standalone process (pid ${holderPid}) already holds the payment-channel lock for identity ${pubkey.slice(0, 8)}\u2026 (${lockPath}) \u2014 wait for it to finish or stop it. Two writers on one identity would race the cumulative-claim watermark.`
+    );
+    this.pubkey = pubkey;
+    this.lockPath = lockPath;
+    this.holderPid = holderPid;
+    this.name = "StandaloneLockError";
+  }
+  pubkey;
+  lockPath;
+  holderPid;
+};
+async function checkDaemonIdentity(pubkey, options = {}) {
+  const port = options.port ?? defaultDaemonPort();
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const url = `http://127.0.0.1:${port}/status`;
+  let daemonPubkey;
+  try {
+    const res = await fetchImpl(url, {
+      signal: AbortSignal.timeout(options.timeoutMs ?? 1500)
+    });
+    if (!res.ok) return;
+    const body = await res.json();
+    const candidate = body?.identity?.nostrPubkey;
+    if (typeof candidate === "string") daemonPubkey = candidate;
+  } catch {
+    return;
+  }
+  if (daemonPubkey !== void 0 && daemonPubkey === pubkey) {
+    throw new DaemonIdentityConflictError(pubkey, url);
+  }
+}
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+var NonceLock = class _NonceLock {
+  constructor(pubkey, lockPath) {
+    this.pubkey = pubkey;
+    this.lockPath = lockPath;
+    this.exitHandler = () => {
+      try {
+        unlinkSync(this.lockPath);
+      } catch {
+      }
+    };
+    process.once("exit", this.exitHandler);
+  }
+  pubkey;
+  lockPath;
+  released = false;
+  exitHandler;
+  static async acquire(pubkey, options = {}) {
+    const dir = options.dir ?? defaultLockDir();
+    const pid = options.pid ?? process.pid;
+    const lockPath = join(dir, `standalone-${pubkey}.lock`);
+    mkdirSync(dir, { recursive: true });
+    const payload = JSON.stringify(
+      {
+        pid,
+        pubkey,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      null,
+      2
+    );
+    for (let attempt = 0; attempt < 2; attempt++) {
+      try {
+        writeFileSync(lockPath, payload, { flag: "wx" });
+        return new _NonceLock(pubkey, lockPath);
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        let holderPid;
+        try {
+          const parsed = JSON.parse(
+            readFileSync(lockPath, "utf8")
+          );
+          if (typeof parsed.pid === "number") holderPid = parsed.pid;
+        } catch {
+        }
+        if (holderPid !== void 0 && holderPid !== pid && pidAlive(holderPid)) {
+          throw new StandaloneLockError(pubkey, lockPath, holderPid);
+        }
+        try {
+          unlinkSync(lockPath);
+        } catch {
+        }
+      }
+    }
+    throw new StandaloneLockError(pubkey, lockPath, -1);
+  }
+  /** Remove the lockfile and detach the exit hook. Idempotent. */
+  release() {
+    if (this.released) return;
+    this.released = true;
+    process.removeListener("exit", this.exitHandler);
+    try {
+      unlinkSync(this.lockPath);
+    } catch {
+    }
+  }
+};
+
+// src/standalone/standalone-publisher.ts
+import { ToonClient, parseFulfillHttp } from "@toon-protocol/client";
+var StandalonePublishError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StandalonePublishError";
+  }
+};
+function deriveRouteDestinations(anchor) {
+  const segs = anchor.split(".");
+  if (segs.at(-1) === "store" && segs.at(-2) === "relay") {
+    const base = segs.slice(0, -2).join(".");
+    return { publish: `${base}.relay`, store: `${base}.store` };
+  }
+  return { publish: anchor, store: anchor };
+}
+var ARWEAVE_TX_ID_REGEX = /^[A-Za-z0-9_-]{43}$/;
+function extractArweaveTxId(base64Data) {
+  const http = parseFulfillHttp(base64Data);
+  if (!http.isHttp) {
+    const legacy = Buffer.from(base64Data, "base64").toString("utf8");
+    if (!ARWEAVE_TX_ID_REGEX.test(legacy)) {
+      throw new StandalonePublishError(
+        `FULFILL data is not a valid Arweave tx ID: "${legacy}"`
+      );
+    }
+    return legacy;
+  }
+  if (http.status < 200 || http.status >= 300) {
+    throw new StandalonePublishError(
+      `git-object upload failed: store returned HTTP ${http.status}` + (http.body ? ` - ${http.body}` : "")
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(http.body);
+  } catch {
+    throw new StandalonePublishError(
+      `git-object upload response body was not valid JSON: "${http.body}"`
+    );
+  }
+  if (parsed.accept === false) {
+    const reason = typeof parsed.error === "string" ? `: ${parsed.error}` : "";
+    throw new StandalonePublishError(
+      `git-object upload rejected by store (accept:false)${reason}`
+    );
+  }
+  if (typeof parsed.txId === "string" && ARWEAVE_TX_ID_REGEX.test(parsed.txId)) {
+    return parsed.txId;
+  }
+  if (typeof parsed.data === "string" && parsed.data.length > 0) {
+    const decoded = Buffer.from(parsed.data, "base64").toString("utf8");
+    if (ARWEAVE_TX_ID_REGEX.test(decoded)) return decoded;
+  }
+  throw new StandalonePublishError(
+    `git-object upload response did not contain a valid Arweave tx ID: "${http.body}"`
+  );
+}
+function channelInternals(client) {
+  const c = client;
+  const negotiations = c.peerNegotiations instanceof Map ? c.peerNegotiations : void 0;
+  const cm = c.channelManager && typeof c.channelManager.trackChannel === "function" && c.channelManager.peerChannels instanceof Map ? c.channelManager : void 0;
+  const onChain = c.onChainChannelClient && c.onChainChannelClient.channelContext instanceof Map ? c.onChainChannelClient : void 0;
+  return {
+    ...negotiations ? { peerNegotiations: negotiations } : {},
+    ...cm ? { channelManager: cm } : {},
+    ...onChain ? { onChainChannelClient: onChain } : {}
+  };
+}
+var StandalonePublisher = class {
+  client;
+  ownsClient;
+  publishDestination;
+  storeDestination;
+  channelDestination;
+  eventFee;
+  uploadFeePerByte;
+  daemonPort;
+  lockDir;
+  fetchImpl;
+  channelMap;
+  /** ILP anchor the channel is keyed by in the map (peer/apex destination). */
+  channelAnchor;
+  negotiationFallbacks;
+  warn;
+  lock;
+  channelId;
+  readyPromise;
+  /** Guard + client start only (no channel) — see {@link startClientOnly}. */
+  clientReadyPromise;
+  /** True when the last start() RESUMED the recorded channel (#263). */
+  lastOpenResumed = false;
+  constructor(options) {
+    if (options.client && options.clientConfig) {
+      throw new Error(
+        "StandalonePublisher: provide either `clientConfig` or `client`, not both"
+      );
+    }
+    if (options.client) {
+      this.client = options.client;
+      this.ownsClient = false;
+    } else if (options.clientConfig) {
+      this.client = new ToonClient(options.clientConfig);
+      this.ownsClient = true;
+    } else {
+      throw new Error(
+        "StandalonePublisher: one of `clientConfig` (mnemonic-based ToonClient config) or `client` is required"
+      );
+    }
+    const anchor = options.channelDestination ?? options.clientConfig?.destinationAddress;
+    const routes = anchor ? deriveRouteDestinations(anchor) : void 0;
+    this.publishDestination = options.publishDestination ?? routes?.publish;
+    this.storeDestination = options.storeDestination ?? routes?.store;
+    this.channelDestination = options.channelDestination;
+    this.eventFee = options.eventFee ?? 1n;
+    this.uploadFeePerByte = options.uploadFeePerByte ?? 10n;
+    this.daemonPort = options.daemonPort;
+    this.lockDir = options.lockDir;
+    this.fetchImpl = options.fetchImpl;
+    this.channelMap = options.channelMap;
+    this.channelAnchor = anchor;
+    this.negotiationFallbacks = options.negotiationFallbacks;
+    this.warn = options.warn ?? ((line) => process.stderr.write(`${line}
+`));
+  }
+  /** Hex Nostr pubkey of the embedded identity (available before start). */
+  getPublicKey() {
+    return this.client.getPublicKey();
+  }
+  /**
+   * Run the nonce guard, start the embedded client, and open (or resume) the
+   * payment channel. Called lazily by the first paid operation; safe to call
+   * eagerly to fail fast. Idempotent.
+   */
+  start() {
+    this.readyPromise ??= (async () => {
+      await this.startClientOnly();
+      try {
+        this.channelId = await this.openOrResumeChannel();
+      } catch (err) {
+        this.lock?.release();
+        this.lock = void 0;
+        this.clientReadyPromise = void 0;
+        throw err;
+      }
+    })().catch((err) => {
+      this.readyPromise = void 0;
+      throw err;
+    });
+    return this.readyPromise;
+  }
+  /**
+   * Run the nonce guard and start the embedded client WITHOUT touching the
+   * payment channel (#263): `channel close`/`settle` operate on a RECORDED
+   * channel and must never open a fresh one as a side effect of starting.
+   * Idempotent; `start()` layers the channel open/resume on top of this.
+   */
+  startClientOnly() {
+    this.clientReadyPromise ??= this.doStartClient().catch((err) => {
+      this.clientReadyPromise = void 0;
+      throw err;
+    });
+    return this.clientReadyPromise;
+  }
+  async doStartClient() {
+    const pubkey = this.client.getPublicKey();
+    await checkDaemonIdentity(pubkey, {
+      ...this.daemonPort !== void 0 ? { port: this.daemonPort } : {},
+      ...this.fetchImpl ? { fetchImpl: this.fetchImpl } : {}
+    });
+    this.lock = await NonceLock.acquire(pubkey, {
+      ...this.lockDir !== void 0 ? { dir: this.lockDir } : {}
+    });
+    try {
+      if (this.client.isStarted?.() !== true) {
+        await this.client.start();
+      }
+      this.applyNegotiationFallbacks();
+    } catch (err) {
+      this.lock.release();
+      this.lock = void 0;
+      throw err;
+    }
+  }
+  /**
+   * Back-fill negotiated peer metadata the announce did not carry
+   * (#264/#260 root cause 3): after the client's bootstrap negotiation, any
+   * peer negotiation missing `tokenNetwork`/`tokenAddress` gets the derived
+   * per-chain fallback for its negotiated chain, BEFORE the lazy channel
+   * open reads them. Announced values are never overridden.
+   */
+  applyNegotiationFallbacks() {
+    const fallbacks = this.negotiationFallbacks;
+    if (!fallbacks) return;
+    const negotiations = channelInternals(this.client).peerNegotiations;
+    if (!negotiations) {
+      this.warn(
+        "rig: settlement fallbacks configured but the client does not expose negotiation internals \u2014 on-chain channel opening may fail if the peer announced no TokenNetwork"
+      );
+      return;
+    }
+    for (const negotiation of negotiations.values()) {
+      if (!negotiation.tokenNetwork) {
+        const tokenNetwork = fallbacks.tokenNetworks?.[negotiation.chain];
+        if (tokenNetwork) negotiation.tokenNetwork = tokenNetwork;
+      }
+      if (!negotiation.tokenAddress) {
+        const tokenAddress = fallbacks.preferredTokens?.[negotiation.chain];
+        if (tokenAddress) negotiation.tokenAddress = tokenAddress;
+      }
+    }
+  }
+  /**
+   * Open the payment channel — or, when the channel map has a record for
+   * (identity, anchor), RESUME the recorded on-chain channel (#262).
+   *
+   * Resume seeds the client's ChannelManager (`trackChannel` rehydrates the
+   * cumulative-claim watermark from channels.json; `peerChannels` makes the
+   * subsequent `openChannel` return the same id instead of opening on-chain).
+   * A fresh open is RECORDED so the next invocation resumes it. A corrupt map
+   * file throws BEFORE anything is opened — never a silent duplicate open.
+   */
+  async openOrResumeChannel() {
+    const map = this.channelMap;
+    if (!map) {
+      return this.client.openChannel(this.channelDestination);
+    }
+    if (!this.channelAnchor) {
+      this.warn(
+        "rig: no channel anchor destination configured \u2014 the peer\u2192channel mapping cannot be persisted, so this run may open a fresh channel"
+      );
+      return this.client.openChannel(this.channelDestination);
+    }
+    const anchor = this.channelAnchor;
+    const identity = this.client.getPublicKey();
+    const candidates = map.listFor(identity, anchor);
+    const internals = channelInternals(this.client);
+    const resumed = await this.resumeRecordedChannel(map, candidates, internals);
+    const channelId = await this.client.openChannel(this.channelDestination);
+    if (resumed && channelId === resumed.channelId) {
+      this.lastOpenResumed = true;
+      map.touch(recordKey(resumed));
+    } else {
+      this.lastOpenResumed = false;
+      this.recordOpenedChannel(map, internals, identity, anchor, channelId);
+    }
+    return channelId;
+  }
+  /**
+   * Try to resume one recorded channel: the first candidate whose peer is
+   * still negotiated on the SAME chain + tokenNetwork and whose watermark
+   * does not show it closed/settled. Returns the resumed record, if any.
+   */
+  async resumeRecordedChannel(map, candidates, internals) {
+    if (candidates.length === 0) return void 0;
+    const cm = internals.channelManager;
+    if (!cm?.trackChannel || !cm.peerChannels) {
+      this.warn(
+        "rig: a recorded channel exists but the client does not expose channel internals to resume it \u2014 a fresh channel may be opened"
+      );
+      return void 0;
+    }
+    for (const record of candidates) {
+      const negotiation = internals.peerNegotiations?.get(record.peerId);
+      if (!negotiation || negotiation.chain !== record.chain || (negotiation.tokenNetwork ?? "") !== record.tokenNetwork) {
+        continue;
+      }
+      const watermark = map.readWatermark(record.channelId);
+      if (watermark?.closedAt !== void 0 || watermark?.settledAt !== void 0) {
+        continue;
+      }
+      if (!watermark) {
+        this.warn(
+          `rig: resuming channel ${record.channelId} with no local claim watermark (${map.watermarkPath}) \u2014 if this channel was claimed against before, the peer will reject the stale claims; remove its entry from ${map.mapPath} to open a fresh channel instead`
+        );
+      }
+      cm.trackChannel(record.channelId, record.context);
+      cm.peerChannels.set(record.peerId, record.channelId);
+      if (record.context.chainType === "evm" && this.client.rehydrateChannelDeposit) {
+        try {
+          const deposit = await this.client.rehydrateChannelDeposit(
+            record.channelId,
+            {
+              chain: record.chain,
+              tokenNetworkAddress: record.context.tokenNetworkAddress
+            }
+          );
+          if (deposit !== void 0) {
+            map.touch(recordKey(record), {
+              depositTotal: deposit.toString()
+            });
+          }
+        } catch (err) {
+          this.warn(
+            `rig: deposit re-read for resumed channel ${record.channelId} failed: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+      return record;
+    }
+    return void 0;
+  }
+  /** Record a freshly opened channel (+ seed its claim watermark at 0/0). */
+  recordOpenedChannel(map, internals, identity, destination, channelId) {
+    let peerId;
+    for (const [peer, channel] of internals.channelManager?.peerChannels ?? []) {
+      if (channel === channelId) {
+        peerId = peer;
+        break;
+      }
+    }
+    const negotiation = peerId !== void 0 ? internals.peerNegotiations?.get(peerId) : void 0;
+    if (peerId === void 0 || !negotiation) {
+      this.warn(
+        `rig: opened channel ${channelId} but could not record the peer\u2192channel mapping (client does not expose negotiation internals) \u2014 the NEXT invocation may open another channel`
+      );
+      return;
+    }
+    let depositTotal;
+    try {
+      depositTotal = this.client.getChannelDepositTotal?.(channelId);
+    } catch {
+    }
+    map.record({
+      channelId,
+      peerId,
+      identity,
+      destination,
+      chain: negotiation.chain,
+      tokenNetwork: negotiation.tokenNetwork ?? "",
+      // Context mirrors the daemon's persistApexChannel shape — exactly what
+      // trackChannel needs on resume.
+      context: {
+        chainType: negotiation.chainType,
+        chainId: typeof negotiation.chainId === "number" ? negotiation.chainId : 0,
+        tokenNetworkAddress: negotiation.tokenNetwork ?? "",
+        ...negotiation.tokenAddress ? { tokenAddress: negotiation.tokenAddress } : {},
+        recipient: negotiation.settlementAddress
+      },
+      ...depositTotal !== void 0 && depositTotal > 0n ? { depositTotal: depositTotal.toString() } : {}
+    });
+    map.seedWatermark(channelId);
+  }
+  /** Release the identity lock and stop the embedded client (if we own it). */
+  async stop() {
+    this.lock?.release();
+    this.lock = void 0;
+    this.readyPromise = void 0;
+    this.clientReadyPromise = void 0;
+    this.channelId = void 0;
+    if (this.ownsClient && this.client.isStarted?.() !== false) {
+      await this.client.stop();
+    }
+  }
+  // ── Money lifecycle (#263) ──────────────────────────────────────────────────
+  /**
+   * Explicit `rig channel open`: the SAME resume-or-open path the lazy paid
+   * writes use (guard → start → resume the recorded channel or open + record
+   * a fresh one), surfaced with a receipt — plus an optional extra collateral
+   * deposit on top of the open/resume.
+   */
+  async openChannelExplicit(opts) {
+    await this.start();
+    const channelId = this.requireChannel();
+    const identity = this.client.getPublicKey();
+    const destination = this.channelAnchor ?? "";
+    const record = this.channelMap && this.channelAnchor ? this.channelMap.listFor(identity, this.channelAnchor).find((r) => r.channelId === channelId) : void 0;
+    const outcome = {
+      channelId,
+      resumed: this.lastOpenResumed,
+      destination,
+      ...record ? { chain: record.chain, peerId: record.peerId } : {},
+      ...record?.depositTotal !== void 0 ? { depositTotal: record.depositTotal } : {}
+    };
+    if (opts?.deposit !== void 0 && opts.deposit > 0n) {
+      if (!this.client.depositToChannel) {
+        throw new StandalonePublishError(
+          "this client build does not support channel deposits (depositToChannel is unavailable)"
+        );
+      }
+      const deposited = await this.client.depositToChannel(
+        channelId,
+        opts.deposit
+      );
+      outcome.depositAdded = opts.deposit.toString();
+      outcome.depositTotal = deposited.depositTotal;
+      if (deposited.txHash) outcome.depositTxHash = deposited.txHash;
+      if (record) {
+        this.channelMap?.touch(recordKey(record), {
+          depositTotal: deposited.depositTotal
+        });
+      }
+    }
+    return outcome;
+  }
+  /**
+   * Adopt a RECORDED channel into the running client so on-chain close/
+   * settle/deposit can act on it: `trackChannel` rehydrates the claim
+   * watermark + withdraw timers from channels.json, `peerChannels` binds the
+   * peer, and the on-chain client's context cache is re-seeded (it only
+   * learns context at open time — a resumed channel would otherwise throw
+   * "No on-chain context").
+   */
+  adoptRecordedChannel(record) {
+    const internals = channelInternals(this.client);
+    const cm = internals.channelManager;
+    if (cm?.trackChannel && cm.peerChannels) {
+      cm.trackChannel(record.channelId, record.context);
+      cm.peerChannels.set(record.peerId, record.channelId);
+    }
+    const contextCache = internals.onChainChannelClient?.channelContext;
+    if (contextCache && !contextCache.has(record.channelId)) {
+      contextCache.set(record.channelId, {
+        chain: record.chain,
+        tokenNetworkAddress: record.context.tokenNetworkAddress,
+        ...record.context.tokenAddress ? { tokenAddress: record.context.tokenAddress } : {}
+      });
+    }
+  }
+  /**
+   * Close a recorded channel: starts the on-chain settlement challenge
+   * window. The client persists `closedAt`/`settleableAt` into the claim
+   * watermark store, which is exactly where `rig channel list`/`balance`
+   * derive the closing/settleable/settled status from. Guard + client start,
+   * but NEVER a channel open ({@link startClientOnly}).
+   */
+  async closeRecordedChannel(record) {
+    await this.startClientOnly();
+    if (!this.client.closeChannel) {
+      throw new StandalonePublishError(
+        "this client build does not support closing channels (closeChannel is unavailable)"
+      );
+    }
+    this.adoptRecordedChannel(record);
+    const result = await this.client.closeChannel(record.channelId);
+    this.channelMap?.touch(recordKey(record));
+    return result;
+  }
+  /**
+   * Settle a recorded channel after its challenge window — releases the
+   * remaining collateral. The client enforces the `now >= settleableAt` time
+   * guard BEFORE spending gas (a too-early call throws its retryable
+   * SettleTooEarlyError) and persists `settledAt` into the watermark store.
+   */
+  async settleRecordedChannel(record) {
+    await this.startClientOnly();
+    if (!this.client.settleChannel) {
+      throw new StandalonePublishError(
+        "this client build does not support settling channels (settleChannel is unavailable)"
+      );
+    }
+    this.adoptRecordedChannel(record);
+    const result = await this.client.settleChannel(record.channelId);
+    this.channelMap?.touch(recordKey(record));
+    return result;
+  }
+  /**
+   * On-chain wallet balances for the embedded identity — a FREE read on the
+   * UNSTARTED client (no nonce guard, no uplink, no channel): the client
+   * reads the settlement chain its channels actually use (its EVM key is
+   * derived at construction; Solana/Mina keys only exist after a start, so
+   * those chains appear once a start-requiring command ran — same
+   * best-effort contract as the client's own getBalances).
+   */
+  async readWalletBalances() {
+    if (!this.client.getBalances) return [];
+    return await this.client.getBalances();
+  }
+  // ── Publisher ─────────────────────────────────────────────────────────────
+  /**
+   * Fee rates for `planPush` estimation: the flat per-event fee and the
+   * per-byte upload rate this publisher pays (daemon `feePerEvent` and seed
+   * bid-rate conventions; override via options).
+   */
+  getFeeRates() {
+    return Promise.resolve({
+      uploadFeePerByte: this.uploadFeePerByte,
+      eventFee: this.eventFee
+    });
+  }
+  /**
+   * Upload one git object as a kind:5094 store write (Git-SHA/Git-Type/Repo
+   * tagged — the proven seed-pipeline shape), signing one balance-proof claim
+   * for `body.length × uploadFeePerByte`.
+   */
+  async uploadGitObject(upload) {
+    if (upload.body.length > MAX_OBJECT_SIZE) {
+      throw new StandalonePublishError(
+        `git object ${upload.sha} exceeds the ${MAX_OBJECT_SIZE}-byte limit: ${upload.body.length} bytes`
+      );
+    }
+    await this.start();
+    const channelId = this.requireChannel();
+    const fee = BigInt(upload.body.length) * this.uploadFeePerByte;
+    const event = this.client.signEvent({
+      kind: 5094,
+      content: "",
+      created_at: nowSeconds(),
+      tags: [
+        ["i", upload.body.toString("base64"), "blob"],
+        ["bid", fee.toString(), "usdc"],
+        ["output", "application/octet-stream"],
+        ["Git-SHA", upload.sha],
+        ["Git-Type", upload.type],
+        ["Repo", upload.repoId]
+      ]
+    });
+    const claim = await this.client.signBalanceProof(channelId, fee);
+    const result = await this.client.publishEvent(event, {
+      ...this.storeDestination ? { destination: this.storeDestination } : {},
+      claim,
+      ilpAmount: fee,
+      // The store backend serves POST /store (not the relay's /write).
+      proxyPath: "/store"
+    });
+    if (!result.success) {
+      throw new StandalonePublishError(
+        `git-object upload rejected (${upload.sha}): ${result.error ?? "store rejected the write"}`
+      );
+    }
+    if (!result.data) {
+      throw new StandalonePublishError(
+        `git-object upload FULFILL carried no data (${upload.sha}); expected the Arweave tx ID`
+      );
+    }
+    return { txId: extractArweaveTxId(result.data), feePaid: fee };
+  }
+  /**
+   * Sign the event with the embedded identity and pay-to-publish it through
+   * the relay write route, one claim for the flat per-event fee.
+   *
+   * `relayUrls` is the interface's plural forward-compat surface (parked
+   * #84): the standalone impl routes over ILP to its single configured
+   * publish destination, so more than one relay is refused rather than
+   * silently half-published.
+   */
+  async publishEvent(event, relayUrls) {
+    if (relayUrls.length > 1) {
+      throw new StandalonePublishError(
+        `multi-relay publish is not supported yet (got ${relayUrls.length} relays) \u2014 the standalone publisher routes to a single relay destination (#84 parked)`
+      );
+    }
+    await this.start();
+    const channelId = this.requireChannel();
+    const signed = this.client.signEvent(event);
+    const fee = this.eventFee;
+    const claim = await this.client.signBalanceProof(channelId, fee);
+    const result = await this.client.publishEvent(signed, {
+      ...this.publishDestination ? { destination: this.publishDestination } : {},
+      claim,
+      ilpAmount: fee
+    });
+    if (!result.success) {
+      throw new StandalonePublishError(
+        `publish rejected (kind ${event.kind}): ${result.error ?? "relay rejected the event"}`
+      );
+    }
+    return { eventId: result.eventId ?? signed.id, feePaid: fee };
+  }
+  requireChannel() {
+    if (!this.channelId) {
+      throw new StandalonePublishError(
+        "no payment channel open \u2014 start() did not complete"
+      );
+    }
+    return this.channelId;
+  }
+};
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+export {
+  DEFAULT_DAEMON_PORT,
+  defaultDaemonPort,
+  defaultLockDir,
+  DaemonIdentityConflictError,
+  StandaloneLockError,
+  checkDaemonIdentity,
+  NonceLock,
+  StandalonePublishError,
+  deriveRouteDestinations,
+  extractArweaveTxId,
+  StandalonePublisher
+};
+//# sourceMappingURL=chunk-3EKP7PMM.js.map