@toon-protocol/rig 3.6.0 → 4.0.0

package/dist/chunk-IZ6KLYQ6.js

@@ -1,724 +0,0 @@
-import {
-  DEFAULT_CONTENT_TYPE,
-  NonceLock,
-  checkDaemonIdentity,
-  contentTypeForPath,
-  recordKey
-} from "./chunk-LCYCKWAT.js";
-import {
-  MAX_OBJECT_SIZE
-} from "./chunk-B5ISARMU.js";
-
-// src/standalone/standalone-publisher.ts
-import { ToonClient, extractArweaveTxId } 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 };
-}
-function channelBindingKey(peerId, chain, tokenNetwork) {
-  return `${peerId}|${chain}|${tokenNetwork}`;
-}
-function peerIdFromBindingKey(key) {
-  return key.split("|")[0] ?? key;
-}
-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;
-  routePrices;
-  daemonPort;
-  skipDaemonCheck;
-  lockDir;
-  fetchImpl;
-  channelMap;
-  /** ILP anchor the channel is keyed by in the map (peer/apex destination). */
-  channelAnchor;
-  negotiationFallbacks;
-  warn;
-  storeClientConfig;
-  injectedStoreClient;
-  /** Lazily built on the first store write — see {@link storeLeg}. */
-  storeClient;
-  storeChannelId;
-  storeLegPromise;
-  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.routePrices = options.routePrices;
-    this.daemonPort = options.daemonPort;
-    this.skipDaemonCheck = options.skipDaemonCheck ?? false;
-    this.lockDir = options.lockDir;
-    this.fetchImpl = options.fetchImpl;
-    this.channelMap = options.channelMap;
-    this.channelAnchor = anchor;
-    if (options.storeClient && options.storeClientConfig) {
-      throw new Error(
-        "StandalonePublisher: provide either `storeClientConfig` or `storeClient`, not both"
-      );
-    }
-    this.storeClientConfig = options.storeClientConfig;
-    this.injectedStoreClient = options.storeClient;
-    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();
-    if (!this.skipDaemonCheck) {
-      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() {
-    return this.openOrResumeChannelOn(this.client, this.channelDestination, {
-      anchor: this.channelAnchor,
-      trackResumeState: true
-    });
-  }
-  /**
-   * {@link openOrResumeChannel} for an arbitrary client + destination, so
-   * the store leg gets the same resume-before-open guarantee (and the same
-   * corruption check) as the publish leg rather than a second, weaker path.
-   *
-   * `anchor` defaults to the destination: a leg other than the publish one
-   * is keyed in the channel map by the route it pays for.
-   * `trackResumeState` is publish-only — {@link lastOpenResumed} feeds the
-   * `resumed` field of this publisher's channel status, which describes the
-   * publish channel and would be wrong to overwrite from a store open.
-   */
-  async openOrResumeChannelOn(client, destination, opts = {}) {
-    const map = this.channelMap;
-    const trackResumeState = opts.trackResumeState ?? false;
-    if (!map) {
-      return client.openChannel(destination);
-    }
-    const anchorFor = opts.anchor ?? destination;
-    if (!anchorFor) {
-      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 client.openChannel(destination);
-    }
-    const anchor = anchorFor;
-    const identity = client.getPublicKey();
-    const candidates = map.listFor(identity, anchor);
-    const internals = channelInternals(client);
-    const resumed = await this.resumeRecordedChannel(
-      map,
-      candidates,
-      internals,
-      client
-    );
-    const channelId = await client.openChannel(destination);
-    if (resumed && channelId === resumed.channelId) {
-      if (trackResumeState) this.lastOpenResumed = true;
-      map.touch(recordKey(resumed));
-    } else {
-      if (trackResumeState) this.lastOpenResumed = false;
-      this.recordOpenedChannel(
-        map,
-        internals,
-        identity,
-        anchor,
-        channelId,
-        client
-      );
-    }
-    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, client) {
-    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(
-        channelBindingKey(record.peerId, record.chain, record.tokenNetwork),
-        record.channelId
-      );
-      if (record.context.chainType === "evm" && record.depositTotal === void 0 && client.rehydrateChannelDeposit) {
-        try {
-          const deposit = await 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, client) {
-    let peerId;
-    for (const [key, channel] of internals.channelManager?.peerChannels ?? []) {
-      if (channel === channelId) {
-        peerId = peerIdFromBindingKey(key);
-        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 = 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.storeClient) {
-      const storeClient = this.storeClient;
-      this.storeClient = void 0;
-      this.storeLegPromise = void 0;
-      this.storeChannelId = void 0;
-      await storeClient.stop();
-    }
-    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(
-        channelBindingKey(record.peerId, record.chain, record.tokenNetwork),
-        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;
-  }
-  /**
-   * The full multi-chain wallet view (#299) for the embedded identity — native
-   * coin + configured tokens (USDC) per chain — a FREE read on the UNSTARTED
-   * client (no nonce guard, no uplink, no channel). The client derives the
-   * Solana/Mina addresses from the mnemonic on demand, so ALL configured chains
-   * appear even before a start. Best-effort per chain (an unreachable RPC yields
-   * an `unreadable` chain, not a failure). `fallback` supplies Solana/Mina RPC
-   * defaults (e.g. the network preset) for chains the config has no channel for.
-   */
-  async readWalletChainBalances(fallback) {
-    if (!this.client.getWalletBalances) return [];
-    return await this.client.getWalletBalances(fallback);
-  }
-  // ── Publisher ─────────────────────────────────────────────────────────────
-  /**
-   * Fee rates for `planPush` estimation, both flat per packet (ADR 0020),
-   * with the announced route prices folded in so the ESTIMATE always equals
-   * the CLAIMS: `eventFee` is returned pre-floored at the publish route price,
-   * and `uploadFee` IS the store route price.
-   */
-  getFeeRates() {
-    return Promise.resolve({
-      uploadFee: this.uploadFee(),
-      eventFee: this.effectiveEventFee()
-    });
-  }
-  /**
-   * The flat per-event claim: `eventFee`, floored at the publish route's
-   * announced price (the connector rejects a claim below it — F06).
-   */
-  effectiveEventFee() {
-    const min = this.routePrices?.publish ?? 0n;
-    return this.eventFee > min ? this.eventFee : min;
-  }
-  /**
-   * The per-upload claim: the store route's flat price, whatever the object's
-   * size. Byte-proportional pricing has no successor (ADR 0020) — the route
-   * table is the price list — and the connector charges this figure whether
-   * the body is 100 bytes or 100 KB.
-   */
-  uploadFee() {
-    return this.routePrices?.store ?? 0n;
-  }
-  /**
-   * 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 the store route's flat price
-   * ({@link StandalonePublisherOptions.routePrices}) — ADR 0020 prices a
-   * packet per handler, not per byte.
-   *
-   * #368: a blob's `Content-Type` is derived from its path extension (else
-   * octet-stream) and sent in the `output` tag, which the store forwards onto
-   * the Arweave upload's Content-Type — so a gateway serves `index.html` as
-   * `text/html`, not `application/octet-stream`. Non-blob objects (trees,
-   * commits, tags) are never served as files, so they stay octet-stream.
-   */
-  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 leg = await this.storeLeg();
-    const contentType = upload.type === "blob" ? contentTypeForPath(upload.path) : DEFAULT_CONTENT_TYPE;
-    const fee = this.uploadFee();
-    const event = leg.client.signEvent({
-      kind: 5094,
-      content: "",
-      created_at: nowSeconds(),
-      tags: [
-        ["i", upload.body.toString("base64"), "blob"],
-        ["bid", fee.toString(), "usdc"],
-        ["output", contentType],
-        ["Git-SHA", upload.sha],
-        ["Git-Type", upload.type],
-        ["Repo", upload.repoId]
-      ]
-    });
-    const claim = await leg.client.signBalanceProof(leg.channelId, fee);
-    const result = await leg.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.response) {
-      throw new StandalonePublishError(
-        `git-object upload FULFILL carried no sealed response (${upload.sha}); expected the Arweave tx ID`
-      );
-    }
-    return { txId: extractArweaveTxId(result.response), feePaid: fee };
-  }
-  /**
-   * Upload one raw blob (no git envelope) with an explicit `Content-Type`
-   * (#368) — a kind:5094 store write carrying just the `i`/`bid`/`output`
-   * tags (and an optional `Repo` provenance tag), NOT the Git-SHA/Git-Type
-   * tags. Without those the store keeps the bytes verbatim instead of
-   * re-deriving a git envelope, which is exactly what the ar.io path manifest
-   * needs. One balance-proof claim for the store route's flat price.
-   */
-  async uploadBlob(upload) {
-    if (upload.body.length > MAX_OBJECT_SIZE) {
-      throw new StandalonePublishError(
-        `blob exceeds the ${MAX_OBJECT_SIZE}-byte limit: ${upload.body.length} bytes`
-      );
-    }
-    await this.start();
-    const leg = await this.storeLeg();
-    const fee = this.uploadFee();
-    const event = leg.client.signEvent({
-      kind: 5094,
-      content: "",
-      created_at: nowSeconds(),
-      tags: [
-        ["i", upload.body.toString("base64"), "blob"],
-        ["bid", fee.toString(), "usdc"],
-        ["output", upload.contentType],
-        ...upload.repoId ? [["Repo", upload.repoId]] : []
-      ]
-    });
-    const claim = await leg.client.signBalanceProof(leg.channelId, fee);
-    const result = await leg.client.publishEvent(event, {
-      ...this.storeDestination ? { destination: this.storeDestination } : {},
-      claim,
-      ilpAmount: fee,
-      proxyPath: "/store"
-    });
-    if (!result.success) {
-      throw new StandalonePublishError(
-        `blob upload rejected: ${result.error ?? "store rejected the write"}`
-      );
-    }
-    if (!result.response) {
-      throw new StandalonePublishError(
-        "blob upload FULFILL carried no sealed response; expected the Arweave tx ID"
-      );
-    }
-    return { txId: extractArweaveTxId(result.response), 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.effectiveEventFee();
-    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;
-  }
-  /**
-   * The client + channel a STORE write must be paid on.
-   *
-   * With no `storeClientConfig` this is the publish leg unchanged — the
-   * single-node case, where the store terminates on the connector that
-   * already holds the channel. With one, the store node is a different
-   * connector holding a different channel, and paying it from the publish
-   * channel is precisely the `F01 - claim rejected: names a channel this
-   * connector has no record of` failure this exists to prevent.
-   *
-   * Built on FIRST STORE WRITE, not in `start()`: `rig push` with nothing to
-   * upload, and every read-only command, should not open a second on-chain
-   * channel (gas) for a leg they never use. Memoised on the promise so
-   * concurrent uploads share one open rather than racing two.
-   */
-  async storeLeg() {
-    const injected = this.injectedStoreClient;
-    const config = this.storeClientConfig;
-    if (!config && !injected) {
-      return { client: this.client, channelId: this.requireChannel() };
-    }
-    this.storeLegPromise ??= (async () => {
-      const client = injected ?? new ToonClient(config);
-      this.storeClient = client;
-      await client.start();
-      const channelId = await this.openOrResumeChannelOn(
-        client,
-        this.storeDestination
-      );
-      this.storeChannelId = channelId;
-      return { client, channelId };
-    })();
-    return this.storeLegPromise;
-  }
-};
-function nowSeconds() {
-  return Math.floor(Date.now() / 1e3);
-}
-
-export {
-  extractArweaveTxId,
-  StandalonePublishError,
-  deriveRouteDestinations,
-  StandalonePublisher
-};
-//# sourceMappingURL=chunk-IZ6KLYQ6.js.map