@unicitylabs/sphere-sdk 0.1.0

package/dist/impl/nodejs/index.cjs

@@ -0,0 +1,1767 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// impl/nodejs/index.ts
+var nodejs_exports = {};
+__export(nodejs_exports, {
+  FileStorageProvider: () => FileStorageProvider,
+  FileTokenStorageProvider: () => FileTokenStorageProvider,
+  NodeTrustBaseLoader: () => NodeTrustBaseLoader,
+  NostrTransportProvider: () => NostrTransportProvider,
+  UnicityAggregatorProvider: () => UnicityAggregatorProvider,
+  UnicityOracleProvider: () => UnicityOracleProvider,
+  createFileStorageProvider: () => createFileStorageProvider,
+  createFileTokenStorageProvider: () => createFileTokenStorageProvider,
+  createNodeProviders: () => createNodeProviders,
+  createNodeTrustBaseLoader: () => createNodeTrustBaseLoader,
+  createNodeWebSocketFactory: () => createNodeWebSocketFactory,
+  createNostrTransportProvider: () => createNostrTransportProvider,
+  createUnicityAggregatorProvider: () => createUnicityAggregatorProvider,
+  createUnicityOracleProvider: () => createUnicityOracleProvider
+});
+module.exports = __toCommonJS(nodejs_exports);
+
+// impl/nodejs/storage/FileStorageProvider.ts
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var FileStorageProvider = class {
+  id = "file-storage";
+  name = "File Storage";
+  type = "local";
+  dataDir;
+  filePath;
+  data = {};
+  status = "disconnected";
+  _identity = null;
+  constructor(config) {
+    if (typeof config === "string") {
+      this.dataDir = config;
+      this.filePath = path.join(config, "wallet.json");
+    } else {
+      this.dataDir = config.dataDir;
+      this.filePath = path.join(config.dataDir, config.fileName ?? "wallet.json");
+    }
+  }
+  setIdentity(identity) {
+    this._identity = identity;
+  }
+  getIdentity() {
+    return this._identity;
+  }
+  async connect() {
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+    if (fs.existsSync(this.filePath)) {
+      try {
+        const content = fs.readFileSync(this.filePath, "utf-8");
+        this.data = JSON.parse(content);
+      } catch {
+        this.data = {};
+      }
+    }
+    this.status = "connected";
+  }
+  async disconnect() {
+    await this.save();
+    this.status = "disconnected";
+  }
+  isConnected() {
+    return this.status === "connected";
+  }
+  getStatus() {
+    return this.status;
+  }
+  async get(key) {
+    return this.data[key] ?? null;
+  }
+  async set(key, value) {
+    this.data[key] = value;
+    await this.save();
+  }
+  async remove(key) {
+    delete this.data[key];
+    await this.save();
+  }
+  async has(key) {
+    return key in this.data;
+  }
+  async keys(prefix) {
+    const allKeys = Object.keys(this.data);
+    if (prefix) {
+      return allKeys.filter((k) => k.startsWith(prefix));
+    }
+    return allKeys;
+  }
+  async clear(prefix) {
+    if (prefix) {
+      const keysToDelete = Object.keys(this.data).filter((k) => k.startsWith(prefix));
+      for (const key of keysToDelete) {
+        delete this.data[key];
+      }
+    } else {
+      this.data = {};
+    }
+    await this.save();
+  }
+  async save() {
+    if (!fs.existsSync(this.dataDir)) {
+      fs.mkdirSync(this.dataDir, { recursive: true });
+    }
+    fs.writeFileSync(this.filePath, JSON.stringify(this.data, null, 2));
+  }
+};
+function createFileStorageProvider(config) {
+  return new FileStorageProvider(config);
+}
+
+// impl/nodejs/storage/FileTokenStorageProvider.ts
+var fs2 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+var FileTokenStorageProvider = class {
+  id = "file-token-storage";
+  name = "File Token Storage";
+  type = "local";
+  tokensDir;
+  status = "disconnected";
+  identity = null;
+  constructor(config) {
+    this.tokensDir = typeof config === "string" ? config : config.tokensDir;
+  }
+  setIdentity(identity) {
+    this.identity = identity;
+  }
+  async initialize() {
+    if (!fs2.existsSync(this.tokensDir)) {
+      fs2.mkdirSync(this.tokensDir, { recursive: true });
+    }
+    this.status = "connected";
+    return true;
+  }
+  async shutdown() {
+    this.status = "disconnected";
+  }
+  async connect() {
+    await this.initialize();
+  }
+  async disconnect() {
+    this.status = "disconnected";
+  }
+  isConnected() {
+    return this.status === "connected";
+  }
+  getStatus() {
+    return this.status;
+  }
+  async load() {
+    const data = {
+      _meta: {
+        version: 1,
+        address: this.identity?.address ?? "",
+        formatVersion: "2.0",
+        updatedAt: Date.now()
+      }
+    };
+    try {
+      const files = fs2.readdirSync(this.tokensDir).filter((f) => f.endsWith(".json") && f !== "_meta.json");
+      for (const file of files) {
+        try {
+          const content = fs2.readFileSync(path2.join(this.tokensDir, file), "utf-8");
+          const token = JSON.parse(content);
+          const key = `_${path2.basename(file, ".json")}`;
+          data[key] = token;
+        } catch {
+        }
+      }
+      return {
+        success: true,
+        data,
+        source: "local",
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        source: "local",
+        timestamp: Date.now()
+      };
+    }
+  }
+  async save(data) {
+    try {
+      fs2.writeFileSync(
+        path2.join(this.tokensDir, "_meta.json"),
+        JSON.stringify(data._meta, null, 2)
+      );
+      for (const [key, value] of Object.entries(data)) {
+        if (key.startsWith("_") && key !== "_meta" && key !== "_tombstones" && key !== "_outbox" && key !== "_sent" && key !== "_invalid") {
+          const tokenId = key.slice(1);
+          fs2.writeFileSync(
+            path2.join(this.tokensDir, `${tokenId}.json`),
+            JSON.stringify(value, null, 2)
+          );
+        }
+      }
+      if (data._tombstones) {
+        for (const tombstone of data._tombstones) {
+          const filePath = path2.join(this.tokensDir, `${tombstone.tokenId}.json`);
+          if (fs2.existsSync(filePath)) {
+            fs2.unlinkSync(filePath);
+          }
+        }
+      }
+      return {
+        success: true,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error",
+        timestamp: Date.now()
+      };
+    }
+  }
+  async sync(localData) {
+    const saveResult = await this.save(localData);
+    return {
+      success: saveResult.success,
+      merged: localData,
+      added: 0,
+      removed: 0,
+      conflicts: 0,
+      error: saveResult.error
+    };
+  }
+  async deleteToken(tokenId) {
+    const filePath = path2.join(this.tokensDir, `${tokenId}.json`);
+    if (fs2.existsSync(filePath)) {
+      fs2.unlinkSync(filePath);
+    }
+  }
+  async saveToken(tokenId, tokenData) {
+    fs2.writeFileSync(
+      path2.join(this.tokensDir, `${tokenId}.json`),
+      JSON.stringify(tokenData, null, 2)
+    );
+  }
+  async getToken(tokenId) {
+    const filePath = path2.join(this.tokensDir, `${tokenId}.json`);
+    if (!fs2.existsSync(filePath)) {
+      return null;
+    }
+    try {
+      const content = fs2.readFileSync(filePath, "utf-8");
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+  async listTokenIds() {
+    const files = fs2.readdirSync(this.tokensDir).filter((f) => f.endsWith(".json") && f !== "_meta.json");
+    return files.map((f) => path2.basename(f, ".json"));
+  }
+};
+function createFileTokenStorageProvider(config) {
+  return new FileTokenStorageProvider(config);
+}
+
+// impl/nodejs/transport/index.ts
+var import_ws = __toESM(require("ws"), 1);
+
+// transport/NostrTransportProvider.ts
+var import_buffer = require("buffer");
+var import_nostr_js_sdk = require("@unicitylabs/nostr-js-sdk");
+
+// transport/websocket.ts
+var WebSocketReadyState = {
+  CONNECTING: 0,
+  OPEN: 1,
+  CLOSING: 2,
+  CLOSED: 3
+};
+function defaultUUIDGenerator() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// constants.ts
+var STORAGE_PREFIX = "sphere_";
+var STORAGE_KEYS = {
+  /** Encrypted BIP39 mnemonic */
+  MNEMONIC: `${STORAGE_PREFIX}mnemonic`,
+  /** Encrypted master private key */
+  MASTER_KEY: `${STORAGE_PREFIX}master_key`,
+  /** BIP32 chain code */
+  CHAIN_CODE: `${STORAGE_PREFIX}chain_code`,
+  /** HD derivation path (full path like m/44'/0'/0'/0/0) */
+  DERIVATION_PATH: `${STORAGE_PREFIX}derivation_path`,
+  /** Base derivation path (like m/44'/0'/0' without chain/index) */
+  BASE_PATH: `${STORAGE_PREFIX}base_path`,
+  /** Derivation mode: bip32, wif_hmac, legacy_hmac */
+  DERIVATION_MODE: `${STORAGE_PREFIX}derivation_mode`,
+  /** Wallet source: mnemonic, file, unknown */
+  WALLET_SOURCE: `${STORAGE_PREFIX}wallet_source`,
+  /** Wallet existence flag */
+  WALLET_EXISTS: `${STORAGE_PREFIX}wallet_exists`,
+  /** Registered nametag (legacy - single address) */
+  NAMETAG: `${STORAGE_PREFIX}nametag`,
+  /** Current active address index */
+  CURRENT_ADDRESS_INDEX: `${STORAGE_PREFIX}current_address_index`,
+  /** Address nametags map (JSON: { "0": "alice", "1": "bob" }) */
+  ADDRESS_NAMETAGS: `${STORAGE_PREFIX}address_nametags`,
+  /** Token data */
+  TOKENS: `${STORAGE_PREFIX}tokens`,
+  /** Pending transfers */
+  PENDING_TRANSFERS: `${STORAGE_PREFIX}pending_transfers`,
+  /** Transfer outbox */
+  OUTBOX: `${STORAGE_PREFIX}outbox`,
+  /** Conversations */
+  CONVERSATIONS: `${STORAGE_PREFIX}conversations`,
+  /** Messages */
+  MESSAGES: `${STORAGE_PREFIX}messages`,
+  /** Transaction history */
+  TRANSACTION_HISTORY: `${STORAGE_PREFIX}transaction_history`,
+  /** Archived tokens (spent token history) */
+  ARCHIVED_TOKENS: `${STORAGE_PREFIX}archived_tokens`,
+  /** Tombstones (records of deleted/spent tokens) */
+  TOMBSTONES: `${STORAGE_PREFIX}tombstones`,
+  /** Forked tokens (alternative histories) */
+  FORKED_TOKENS: `${STORAGE_PREFIX}forked_tokens`
+};
+var DEFAULT_NOSTR_RELAYS = [
+  "wss://relay.unicity.network",
+  "wss://relay.damus.io",
+  "wss://nos.lol",
+  "wss://relay.nostr.band"
+];
+var NOSTR_EVENT_KINDS = {
+  /** NIP-04 encrypted direct message */
+  DIRECT_MESSAGE: 4,
+  /** Token transfer (Unicity custom - 31113) */
+  TOKEN_TRANSFER: 31113,
+  /** Payment request (Unicity custom - 31115) */
+  PAYMENT_REQUEST: 31115,
+  /** Payment request response (Unicity custom - 31116) */
+  PAYMENT_REQUEST_RESPONSE: 31116,
+  /** Nametag binding (NIP-78 app-specific data) */
+  NAMETAG_BINDING: 30078,
+  /** Public broadcast */
+  BROADCAST: 1
+};
+var DEFAULT_AGGREGATOR_URL = "https://aggregator.unicity.network/rpc";
+var DEV_AGGREGATOR_URL = "https://dev-aggregator.dyndns.org/rpc";
+var TEST_AGGREGATOR_URL = "https://goggregator-test.unicity.network";
+var DEFAULT_AGGREGATOR_TIMEOUT = 3e4;
+var DEFAULT_IPFS_GATEWAYS = [
+  "https://ipfs.unicity.network",
+  "https://dweb.link",
+  "https://ipfs.io"
+];
+var DEFAULT_BASE_PATH = "m/44'/0'/0'";
+var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
+var DEFAULT_ELECTRUM_URL = "wss://fulcrum.alpha.unicity.network:50004";
+var TEST_ELECTRUM_URL = "wss://fulcrum.alpha.testnet.unicity.network:50004";
+var TEST_NOSTR_RELAYS = [
+  "wss://nostr-relay.testnet.unicity.network"
+];
+var NETWORKS = {
+  mainnet: {
+    name: "Mainnet",
+    aggregatorUrl: DEFAULT_AGGREGATOR_URL,
+    nostrRelays: DEFAULT_NOSTR_RELAYS,
+    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+    electrumUrl: DEFAULT_ELECTRUM_URL
+  },
+  testnet: {
+    name: "Testnet",
+    aggregatorUrl: TEST_AGGREGATOR_URL,
+    nostrRelays: TEST_NOSTR_RELAYS,
+    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+    electrumUrl: TEST_ELECTRUM_URL
+  },
+  dev: {
+    name: "Development",
+    aggregatorUrl: DEV_AGGREGATOR_URL,
+    nostrRelays: TEST_NOSTR_RELAYS,
+    ipfsGateways: DEFAULT_IPFS_GATEWAYS,
+    electrumUrl: TEST_ELECTRUM_URL
+  }
+};
+var TIMEOUTS = {
+  /** WebSocket connection timeout */
+  WEBSOCKET_CONNECT: 1e4,
+  /** Nostr relay reconnect delay */
+  NOSTR_RECONNECT_DELAY: 3e3,
+  /** Max reconnect attempts */
+  MAX_RECONNECT_ATTEMPTS: 5,
+  /** Proof polling interval */
+  PROOF_POLL_INTERVAL: 1e3,
+  /** Sync interval */
+  SYNC_INTERVAL: 6e4
+};
+
+// transport/NostrTransportProvider.ts
+var EVENT_KINDS = NOSTR_EVENT_KINDS;
+var NostrTransportProvider = class {
+  id = "nostr";
+  name = "Nostr Transport";
+  type = "p2p";
+  description = "P2P messaging via Nostr protocol";
+  config;
+  identity = null;
+  keyManager = null;
+  status = "disconnected";
+  // WebSocket connections to relays
+  connections = /* @__PURE__ */ new Map();
+  reconnectAttempts = /* @__PURE__ */ new Map();
+  // Event handlers
+  messageHandlers = /* @__PURE__ */ new Set();
+  transferHandlers = /* @__PURE__ */ new Set();
+  paymentRequestHandlers = /* @__PURE__ */ new Set();
+  paymentRequestResponseHandlers = /* @__PURE__ */ new Set();
+  broadcastHandlers = /* @__PURE__ */ new Map();
+  eventCallbacks = /* @__PURE__ */ new Set();
+  // Subscriptions
+  subscriptions = /* @__PURE__ */ new Map();
+  // subId -> relays
+  constructor(config) {
+    this.config = {
+      relays: config.relays ?? [...DEFAULT_NOSTR_RELAYS],
+      timeout: config.timeout ?? TIMEOUTS.WEBSOCKET_CONNECT,
+      autoReconnect: config.autoReconnect ?? true,
+      reconnectDelay: config.reconnectDelay ?? TIMEOUTS.NOSTR_RECONNECT_DELAY,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? TIMEOUTS.MAX_RECONNECT_ATTEMPTS,
+      debug: config.debug ?? false,
+      createWebSocket: config.createWebSocket,
+      generateUUID: config.generateUUID ?? defaultUUIDGenerator
+    };
+  }
+  // ===========================================================================
+  // BaseProvider Implementation
+  // ===========================================================================
+  async connect() {
+    if (this.status === "connected") return;
+    this.status = "connecting";
+    try {
+      const connectPromises = this.config.relays.map(
+        (relay) => this.connectToRelay(relay)
+      );
+      await Promise.allSettled(connectPromises);
+      if (this.connections.size === 0) {
+        throw new Error("Failed to connect to any relay");
+      }
+      this.status = "connected";
+      this.emitEvent({ type: "transport:connected", timestamp: Date.now() });
+      this.log("Connected to", this.connections.size, "relays");
+      if (this.identity) {
+        this.subscribeToEvents();
+      }
+    } catch (error) {
+      this.status = "error";
+      throw error;
+    }
+  }
+  async disconnect() {
+    for (const [url, ws] of this.connections) {
+      ws.close();
+      this.connections.delete(url);
+    }
+    this.subscriptions.clear();
+    this.status = "disconnected";
+    this.emitEvent({ type: "transport:disconnected", timestamp: Date.now() });
+    this.log("Disconnected from all relays");
+  }
+  isConnected() {
+    return this.status === "connected" && this.connections.size > 0;
+  }
+  getStatus() {
+    return this.status;
+  }
+  // ===========================================================================
+  // Dynamic Relay Management
+  // ===========================================================================
+  /**
+   * Get list of configured relay URLs
+   */
+  getRelays() {
+    return [...this.config.relays];
+  }
+  /**
+   * Get list of currently connected relay URLs
+   */
+  getConnectedRelays() {
+    return Array.from(this.connections.keys());
+  }
+  /**
+   * Add a new relay dynamically
+   * Will connect immediately if provider is already connected
+   */
+  async addRelay(relayUrl) {
+    if (this.config.relays.includes(relayUrl)) {
+      this.log("Relay already configured:", relayUrl);
+      return false;
+    }
+    this.config.relays.push(relayUrl);
+    if (this.status === "connected") {
+      try {
+        await this.connectToRelay(relayUrl);
+        this.log("Added and connected to relay:", relayUrl);
+        this.emitEvent({
+          type: "transport:relay_added",
+          timestamp: Date.now(),
+          data: { relay: relayUrl, connected: true }
+        });
+        return true;
+      } catch (error) {
+        this.log("Failed to connect to new relay:", relayUrl, error);
+        this.emitEvent({
+          type: "transport:relay_added",
+          timestamp: Date.now(),
+          data: { relay: relayUrl, connected: false, error: String(error) }
+        });
+        return false;
+      }
+    }
+    this.emitEvent({
+      type: "transport:relay_added",
+      timestamp: Date.now(),
+      data: { relay: relayUrl, connected: false }
+    });
+    return true;
+  }
+  /**
+   * Remove a relay dynamically
+   * Will disconnect from the relay if connected
+   */
+  async removeRelay(relayUrl) {
+    const index = this.config.relays.indexOf(relayUrl);
+    if (index === -1) {
+      this.log("Relay not found:", relayUrl);
+      return false;
+    }
+    this.config.relays.splice(index, 1);
+    const ws = this.connections.get(relayUrl);
+    if (ws) {
+      ws.close();
+      this.connections.delete(relayUrl);
+      this.reconnectAttempts.delete(relayUrl);
+      this.log("Removed and disconnected from relay:", relayUrl);
+    }
+    this.emitEvent({
+      type: "transport:relay_removed",
+      timestamp: Date.now(),
+      data: { relay: relayUrl }
+    });
+    if (this.connections.size === 0 && this.status === "connected") {
+      this.status = "error";
+      this.emitEvent({
+        type: "transport:error",
+        timestamp: Date.now(),
+        data: { error: "No connected relays remaining" }
+      });
+    }
+    return true;
+  }
+  /**
+   * Check if a relay is configured
+   */
+  hasRelay(relayUrl) {
+    return this.config.relays.includes(relayUrl);
+  }
+  /**
+   * Check if a relay is currently connected
+   */
+  isRelayConnected(relayUrl) {
+    const ws = this.connections.get(relayUrl);
+    return ws !== void 0 && ws.readyState === WebSocketReadyState.OPEN;
+  }
+  // ===========================================================================
+  // TransportProvider Implementation
+  // ===========================================================================
+  setIdentity(identity) {
+    this.identity = identity;
+    const secretKey = import_buffer.Buffer.from(identity.privateKey, "hex");
+    this.keyManager = import_nostr_js_sdk.NostrKeyManager.fromPrivateKey(secretKey);
+    const nostrPubkey = this.keyManager.getPublicKeyHex();
+    this.log("Identity set, Nostr pubkey:", nostrPubkey.slice(0, 16) + "...");
+    if (this.isConnected()) {
+      this.subscribeToEvents();
+    }
+  }
+  /**
+   * Get the Nostr-format public key (32 bytes / 64 hex chars)
+   * This is the x-coordinate only, without the 02/03 prefix.
+   */
+  getNostrPubkey() {
+    if (!this.keyManager) {
+      throw new Error("KeyManager not initialized - call setIdentity first");
+    }
+    return this.keyManager.getPublicKeyHex();
+  }
+  async sendMessage(recipientPubkey, content) {
+    this.ensureReady();
+    const event = await this.createEncryptedEvent(
+      EVENT_KINDS.DIRECT_MESSAGE,
+      content,
+      [["p", recipientPubkey]]
+    );
+    await this.publishEvent(event);
+    this.emitEvent({
+      type: "message:sent",
+      timestamp: Date.now(),
+      data: { recipient: recipientPubkey }
+    });
+    return event.id;
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  async sendTokenTransfer(recipientPubkey, payload) {
+    this.ensureReady();
+    const content = "token_transfer:" + JSON.stringify(payload);
+    const event = await this.createEncryptedEvent(
+      EVENT_KINDS.TOKEN_TRANSFER,
+      content,
+      [
+        ["p", recipientPubkey],
+        ["d", "token-transfer"],
+        ["type", "token_transfer"]
+      ]
+    );
+    await this.publishEvent(event);
+    this.emitEvent({
+      type: "transfer:sent",
+      timestamp: Date.now(),
+      data: { recipient: recipientPubkey }
+    });
+    return event.id;
+  }
+  onTokenTransfer(handler) {
+    this.transferHandlers.add(handler);
+    return () => this.transferHandlers.delete(handler);
+  }
+  async sendPaymentRequest(recipientPubkey, payload) {
+    this.ensureReady();
+    const requestId = this.config.generateUUID();
+    const amount = typeof payload.amount === "bigint" ? payload.amount.toString() : payload.amount;
+    const requestContent = {
+      requestId,
+      amount,
+      coinId: payload.coinId,
+      message: payload.message,
+      recipientNametag: payload.recipientNametag,
+      deadline: Date.now() + 5 * 60 * 1e3
+      // 5 minutes default
+    };
+    const content = "payment_request:" + JSON.stringify(requestContent);
+    const tags = [
+      ["p", recipientPubkey],
+      ["type", "payment_request"],
+      ["amount", amount]
+    ];
+    if (payload.recipientNametag) {
+      tags.push(["recipient", payload.recipientNametag]);
+    }
+    const event = await this.createEncryptedEvent(
+      EVENT_KINDS.PAYMENT_REQUEST,
+      content,
+      tags
+    );
+    await this.publishEvent(event);
+    this.log("Sent payment request:", event.id);
+    return event.id;
+  }
+  onPaymentRequest(handler) {
+    this.paymentRequestHandlers.add(handler);
+    return () => this.paymentRequestHandlers.delete(handler);
+  }
+  async sendPaymentRequestResponse(recipientPubkey, payload) {
+    this.ensureReady();
+    const responseContent = {
+      requestId: payload.requestId,
+      responseType: payload.responseType,
+      message: payload.message,
+      transferId: payload.transferId
+    };
+    const content = "payment_response:" + JSON.stringify(responseContent);
+    const event = await this.createEncryptedEvent(
+      EVENT_KINDS.PAYMENT_REQUEST_RESPONSE,
+      content,
+      [
+        ["p", recipientPubkey],
+        ["e", payload.requestId],
+        // Reference to original request
+        ["d", "payment-request-response"],
+        ["type", "payment_response"]
+      ]
+    );
+    await this.publishEvent(event);
+    this.log("Sent payment request response:", event.id, "type:", payload.responseType);
+    return event.id;
+  }
+  onPaymentRequestResponse(handler) {
+    this.paymentRequestResponseHandlers.add(handler);
+    return () => this.paymentRequestResponseHandlers.delete(handler);
+  }
+  async resolveNametag(nametag) {
+    this.ensureReady();
+    const hashedNametag = (0, import_nostr_js_sdk.hashNametag)(nametag);
+    let events = await this.queryEvents({
+      kinds: [EVENT_KINDS.NAMETAG_BINDING],
+      "#t": [hashedNametag],
+      limit: 1
+    });
+    if (events.length === 0) {
+      events = await this.queryEvents({
+        kinds: [EVENT_KINDS.NAMETAG_BINDING],
+        "#d": [hashedNametag],
+        limit: 1
+      });
+    }
+    if (events.length === 0) return null;
+    const bindingEvent = events[0];
+    if (bindingEvent.pubkey) {
+      return bindingEvent.pubkey;
+    }
+    const pubkeyTag = bindingEvent.tags.find((t) => t[0] === "p");
+    if (pubkeyTag?.[1]) return pubkeyTag[1];
+    return null;
+  }
+  async publishNametag(nametag, address) {
+    this.ensureReady();
+    const hashedNametag = (0, import_nostr_js_sdk.hashNametag)(nametag);
+    const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, address, [
+      ["d", hashedNametag],
+      ["a", address]
+    ]);
+    await this.publishEvent(event);
+    this.log("Published nametag binding:", nametag);
+  }
+  async registerNametag(nametag, _publicKey) {
+    this.ensureReady();
+    const nostrPubkey = this.getNostrPubkey();
+    const existing = await this.resolveNametag(nametag);
+    this.log("registerNametag:", nametag, "existing:", existing, "myPubkey:", nostrPubkey);
+    if (existing && existing !== nostrPubkey) {
+      this.log("Nametag already taken:", nametag, "- owner:", existing);
+      return false;
+    }
+    const hashedNametag = (0, import_nostr_js_sdk.hashNametag)(nametag);
+    const content = JSON.stringify({
+      nametag_hash: hashedNametag,
+      address: nostrPubkey,
+      verified: Date.now()
+    });
+    const event = await this.createEvent(EVENT_KINDS.NAMETAG_BINDING, content, [
+      ["d", hashedNametag],
+      ["nametag", hashedNametag],
+      ["t", hashedNametag],
+      ["address", nostrPubkey]
+    ]);
+    await this.publishEvent(event);
+    this.log("Registered nametag:", nametag, "for pubkey:", nostrPubkey.slice(0, 16) + "...");
+    return true;
+  }
+  subscribeToBroadcast(tags, handler) {
+    const key = tags.sort().join(":");
+    if (!this.broadcastHandlers.has(key)) {
+      this.broadcastHandlers.set(key, /* @__PURE__ */ new Set());
+      if (this.isConnected()) {
+        this.subscribeToTags(tags);
+      }
+    }
+    this.broadcastHandlers.get(key).add(handler);
+    return () => {
+      this.broadcastHandlers.get(key)?.delete(handler);
+      if (this.broadcastHandlers.get(key)?.size === 0) {
+        this.broadcastHandlers.delete(key);
+      }
+    };
+  }
+  async publishBroadcast(content, tags) {
+    this.ensureReady();
+    const eventTags = tags?.map((t) => ["t", t]) ?? [];
+    const event = await this.createEvent(EVENT_KINDS.BROADCAST, content, eventTags);
+    await this.publishEvent(event);
+    return event.id;
+  }
+  // ===========================================================================
+  // Event Subscription
+  // ===========================================================================
+  onEvent(callback) {
+    this.eventCallbacks.add(callback);
+    return () => this.eventCallbacks.delete(callback);
+  }
+  // ===========================================================================
+  // Private: Connection Management
+  // ===========================================================================
+  async connectToRelay(url) {
+    return new Promise((resolve, reject) => {
+      const ws = this.config.createWebSocket(url);
+      const timeout = setTimeout(() => {
+        ws.close();
+        reject(new Error(`Connection timeout: ${url}`));
+      }, this.config.timeout);
+      ws.onopen = () => {
+        clearTimeout(timeout);
+        this.connections.set(url, ws);
+        this.reconnectAttempts.set(url, 0);
+        this.log("Connected to relay:", url);
+        resolve();
+      };
+      ws.onerror = (error) => {
+        clearTimeout(timeout);
+        this.log("Relay error:", url, error);
+        reject(error);
+      };
+      ws.onclose = () => {
+        this.connections.delete(url);
+        if (this.config.autoReconnect && this.status === "connected") {
+          this.scheduleReconnect(url);
+        }
+      };
+      ws.onmessage = (event) => {
+        this.handleRelayMessage(url, event.data);
+      };
+    });
+  }
+  scheduleReconnect(url) {
+    const attempts = this.reconnectAttempts.get(url) ?? 0;
+    if (attempts >= this.config.maxReconnectAttempts) {
+      this.log("Max reconnect attempts reached for:", url);
+      return;
+    }
+    this.reconnectAttempts.set(url, attempts + 1);
+    const delay = this.config.reconnectDelay * Math.pow(2, attempts);
+    this.emitEvent({ type: "transport:reconnecting", timestamp: Date.now() });
+    setTimeout(() => {
+      this.connectToRelay(url).catch(() => {
+      });
+    }, delay);
+  }
+  // ===========================================================================
+  // Private: Message Handling
+  // ===========================================================================
+  handleRelayMessage(relay, data) {
+    try {
+      const message = JSON.parse(data);
+      const [type, ...args] = message;
+      switch (type) {
+        case "EVENT":
+          this.handleEvent(args[1]);
+          break;
+        case "EOSE":
+          break;
+        case "OK":
+          break;
+        case "NOTICE":
+          this.log("Relay notice:", relay, args[0]);
+          break;
+      }
+    } catch (error) {
+      this.log("Failed to parse relay message:", error);
+    }
+  }
+  async handleEvent(event) {
+    try {
+      switch (event.kind) {
+        case EVENT_KINDS.DIRECT_MESSAGE:
+          await this.handleDirectMessage(event);
+          break;
+        case EVENT_KINDS.TOKEN_TRANSFER:
+          await this.handleTokenTransfer(event);
+          break;
+        case EVENT_KINDS.PAYMENT_REQUEST:
+          await this.handlePaymentRequest(event);
+          break;
+        case EVENT_KINDS.PAYMENT_REQUEST_RESPONSE:
+          await this.handlePaymentRequestResponse(event);
+          break;
+        case EVENT_KINDS.BROADCAST:
+          this.handleBroadcast(event);
+          break;
+      }
+    } catch (error) {
+      this.log("Failed to handle event:", error);
+    }
+  }
+  async handleDirectMessage(event) {
+    if (!this.identity || !this.keyManager) return;
+    if (event.pubkey === this.keyManager.getPublicKeyHex()) return;
+    const content = await this.decryptContent(event.content, event.pubkey);
+    const message = {
+      id: event.id,
+      senderPubkey: event.pubkey,
+      content,
+      timestamp: event.created_at * 1e3,
+      encrypted: true
+    };
+    this.emitEvent({ type: "message:received", timestamp: Date.now() });
+    for (const handler of this.messageHandlers) {
+      try {
+        handler(message);
+      } catch (error) {
+        this.log("Message handler error:", error);
+      }
+    }
+  }
+  async handleTokenTransfer(event) {
+    if (!this.identity) return;
+    const content = await this.decryptContent(event.content, event.pubkey);
+    const payload = JSON.parse(content);
+    const transfer = {
+      id: event.id,
+      senderPubkey: event.pubkey,
+      payload,
+      timestamp: event.created_at * 1e3
+    };
+    this.emitEvent({ type: "transfer:received", timestamp: Date.now() });
+    for (const handler of this.transferHandlers) {
+      try {
+        handler(transfer);
+      } catch (error) {
+        this.log("Transfer handler error:", error);
+      }
+    }
+  }
+  async handlePaymentRequest(event) {
+    if (!this.identity) return;
+    try {
+      const content = await this.decryptContent(event.content, event.pubkey);
+      const requestData = JSON.parse(content);
+      const request = {
+        id: event.id,
+        senderPubkey: event.pubkey,
+        request: {
+          requestId: requestData.requestId,
+          amount: requestData.amount,
+          coinId: requestData.coinId,
+          message: requestData.message,
+          recipientNametag: requestData.recipientNametag,
+          metadata: requestData.metadata
+        },
+        timestamp: event.created_at * 1e3
+      };
+      this.log("Received payment request:", request.id);
+      for (const handler of this.paymentRequestHandlers) {
+        try {
+          handler(request);
+        } catch (error) {
+          this.log("Payment request handler error:", error);
+        }
+      }
+    } catch (error) {
+      this.log("Failed to handle payment request:", error);
+    }
+  }
+  async handlePaymentRequestResponse(event) {
+    if (!this.identity) return;
+    try {
+      const content = await this.decryptContent(event.content, event.pubkey);
+      const responseData = JSON.parse(content);
+      const response = {
+        id: event.id,
+        responderPubkey: event.pubkey,
+        response: {
+          requestId: responseData.requestId,
+          responseType: responseData.responseType,
+          message: responseData.message,
+          transferId: responseData.transferId
+        },
+        timestamp: event.created_at * 1e3
+      };
+      this.log("Received payment request response:", response.id, "type:", responseData.responseType);
+      for (const handler of this.paymentRequestResponseHandlers) {
+        try {
+          handler(response);
+        } catch (error) {
+          this.log("Payment request response handler error:", error);
+        }
+      }
+    } catch (error) {
+      this.log("Failed to handle payment request response:", error);
+    }
+  }
+  handleBroadcast(event) {
+    const tags = event.tags.filter((t) => t[0] === "t").map((t) => t[1]);
+    const broadcast = {
+      id: event.id,
+      authorPubkey: event.pubkey,
+      content: event.content,
+      tags,
+      timestamp: event.created_at * 1e3
+    };
+    for (const [key, handlers] of this.broadcastHandlers) {
+      const subscribedTags = key.split(":");
+      if (tags.some((t) => subscribedTags.includes(t))) {
+        for (const handler of handlers) {
+          try {
+            handler(broadcast);
+          } catch (error) {
+            this.log("Broadcast handler error:", error);
+          }
+        }
+      }
+    }
+  }
+  // ===========================================================================
+  // Private: Event Creation & Publishing
+  // ===========================================================================
+  async createEvent(kind, content, tags) {
+    if (!this.identity) throw new Error("Identity not set");
+    if (!this.keyManager) throw new Error("KeyManager not initialized");
+    const signedEvent = import_nostr_js_sdk.Event.create(this.keyManager, {
+      kind,
+      content,
+      tags
+    });
+    const event = {
+      id: signedEvent.id,
+      kind: signedEvent.kind,
+      content: signedEvent.content,
+      tags: signedEvent.tags,
+      pubkey: signedEvent.pubkey,
+      created_at: signedEvent.created_at,
+      sig: signedEvent.sig
+    };
+    return event;
+  }
+  async createEncryptedEvent(kind, content, tags) {
+    if (!this.keyManager) throw new Error("KeyManager not initialized");
+    const recipientTag = tags.find((t) => t[0] === "p");
+    if (!recipientTag || !recipientTag[1]) {
+      throw new Error("No recipient pubkey in tags for encryption");
+    }
+    const recipientPubkey = recipientTag[1];
+    const encrypted = await import_nostr_js_sdk.NIP04.encryptHex(
+      content,
+      this.keyManager.getPrivateKeyHex(),
+      recipientPubkey
+    );
+    return this.createEvent(kind, encrypted, tags);
+  }
+  async publishEvent(event) {
+    const message = JSON.stringify(["EVENT", event]);
+    const publishPromises = Array.from(this.connections.values()).map((ws) => {
+      return new Promise((resolve, reject) => {
+        if (ws.readyState !== WebSocketReadyState.OPEN) {
+          reject(new Error("WebSocket not open"));
+          return;
+        }
+        ws.send(message);
+        resolve();
+      });
+    });
+    await Promise.any(publishPromises);
+  }
+  async queryEvents(filter) {
+    if (this.connections.size === 0) {
+      throw new Error("No connected relays");
+    }
+    const queryPromises = Array.from(this.connections.values()).map(
+      (ws) => this.queryEventsFromRelay(ws, filter)
+    );
+    const results = await Promise.allSettled(queryPromises);
+    for (const result of results) {
+      if (result.status === "fulfilled" && result.value.length > 0) {
+        return result.value;
+      }
+    }
+    return [];
+  }
+  async queryEventsFromRelay(ws, filter) {
+    const subId = this.config.generateUUID().slice(0, 8);
+    const events = [];
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.unsubscribeFromRelay(ws, subId);
+        resolve(events);
+      }, 5e3);
+      const originalHandler = ws.onmessage;
+      ws.onmessage = (event) => {
+        const message = JSON.parse(event.data);
+        const [type, sid, data] = message;
+        if (sid !== subId) {
+          originalHandler?.call(ws, event);
+          return;
+        }
+        if (type === "EVENT") {
+          events.push(data);
+        } else if (type === "EOSE") {
+          clearTimeout(timeout);
+          ws.onmessage = originalHandler;
+          this.unsubscribeFromRelay(ws, subId);
+          resolve(events);
+        }
+      };
+      ws.send(JSON.stringify(["REQ", subId, filter]));
+    });
+  }
+  unsubscribeFromRelay(ws, subId) {
+    if (ws.readyState === WebSocketReadyState.OPEN) {
+      ws.send(JSON.stringify(["CLOSE", subId]));
+    }
+  }
+  // ===========================================================================
+  // Private: Subscriptions
+  // ===========================================================================
+  subscribeToEvents() {
+    if (!this.identity || !this.keyManager) return;
+    const subId = "main";
+    const nostrPubkey = this.keyManager.getPublicKeyHex();
+    const filter = {
+      kinds: [
+        EVENT_KINDS.DIRECT_MESSAGE,
+        EVENT_KINDS.TOKEN_TRANSFER,
+        EVENT_KINDS.PAYMENT_REQUEST,
+        EVENT_KINDS.PAYMENT_REQUEST_RESPONSE
+      ],
+      "#p": [nostrPubkey],
+      since: Math.floor(Date.now() / 1e3) - 86400
+      // Last 24h
+    };
+    const message = JSON.stringify(["REQ", subId, filter]);
+    for (const ws of this.connections.values()) {
+      if (ws.readyState === WebSocketReadyState.OPEN) {
+        ws.send(message);
+      }
+    }
+    this.subscriptions.set(subId, Array.from(this.connections.keys()));
+    this.log("Subscribed to events");
+  }
+  subscribeToTags(tags) {
+    const subId = `tags:${tags.join(":")}`;
+    const filter = {
+      kinds: [EVENT_KINDS.BROADCAST],
+      "#t": tags,
+      since: Math.floor(Date.now() / 1e3) - 3600
+      // Last hour
+    };
+    const message = JSON.stringify(["REQ", subId, filter]);
+    for (const ws of this.connections.values()) {
+      if (ws.readyState === WebSocketReadyState.OPEN) {
+        ws.send(message);
+      }
+    }
+    this.subscriptions.set(subId, Array.from(this.connections.keys()));
+  }
+  // ===========================================================================
+  // Private: Encryption
+  // ===========================================================================
+  async decryptContent(content, senderPubkey) {
+    if (!this.keyManager) throw new Error("KeyManager not initialized");
+    const decrypted = await import_nostr_js_sdk.NIP04.decryptHex(
+      content,
+      this.keyManager.getPrivateKeyHex(),
+      senderPubkey
+    );
+    return this.stripContentPrefix(decrypted);
+  }
+  /**
+   * Strip known content prefixes (nostr-js-sdk compatibility)
+   * Handles: payment_request:, token_transfer:, etc.
+   */
+  stripContentPrefix(content) {
+    const prefixes = [
+      "payment_request:",
+      "token_transfer:",
+      "payment_response:"
+    ];
+    for (const prefix of prefixes) {
+      if (content.startsWith(prefix)) {
+        return content.slice(prefix.length);
+      }
+    }
+    return content;
+  }
+  // ===========================================================================
+  // Private: Helpers
+  // ===========================================================================
+  ensureReady() {
+    if (!this.isConnected()) {
+      throw new Error("NostrTransportProvider not connected");
+    }
+    if (!this.identity) {
+      throw new Error("Identity not set");
+    }
+  }
+  emitEvent(event) {
+    for (const callback of this.eventCallbacks) {
+      try {
+        callback(event);
+      } catch (error) {
+        this.log("Event callback error:", error);
+      }
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[NostrTransportProvider]", ...args);
+    }
+  }
+};
+
+// impl/nodejs/transport/index.ts
+function createNodeWebSocketFactory() {
+  return (url) => {
+    return new import_ws.default(url);
+  };
+}
+function createNostrTransportProvider(config) {
+  return new NostrTransportProvider({
+    ...config,
+    createWebSocket: createNodeWebSocketFactory()
+  });
+}
+
+// impl/nodejs/oracle/index.ts
+var fs3 = __toESM(require("fs"), 1);
+
+// oracle/UnicityAggregatorProvider.ts
+var import_StateTransitionClient = require("@unicitylabs/state-transition-sdk/lib/StateTransitionClient");
+var import_AggregatorClient = require("@unicitylabs/state-transition-sdk/lib/api/AggregatorClient");
+var import_RootTrustBase = require("@unicitylabs/state-transition-sdk/lib/bft/RootTrustBase");
+var import_Token = require("@unicitylabs/state-transition-sdk/lib/token/Token");
+var import_InclusionProofUtils = require("@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils");
+var UnicityAggregatorProvider = class {
+  id = "unicity-aggregator";
+  name = "Unicity Aggregator";
+  type = "network";
+  description = "Unicity state transition aggregator (oracle implementation)";
+  config;
+  status = "disconnected";
+  eventCallbacks = /* @__PURE__ */ new Set();
+  // SDK clients
+  aggregatorClient = null;
+  stateTransitionClient = null;
+  trustBase = null;
+  /** Get the current trust base */
+  getTrustBase() {
+    return this.trustBase;
+  }
+  /** Get the state transition client */
+  getStateTransitionClient() {
+    return this.stateTransitionClient;
+  }
+  /** Get the aggregator client */
+  getAggregatorClient() {
+    return this.aggregatorClient;
+  }
+  // Cache for spent states (immutable)
+  spentCache = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = {
+      url: config.url,
+      apiKey: config.apiKey ?? "",
+      timeout: config.timeout ?? DEFAULT_AGGREGATOR_TIMEOUT,
+      skipVerification: config.skipVerification ?? false,
+      debug: config.debug ?? false,
+      trustBaseLoader: config.trustBaseLoader
+    };
+  }
+  // ===========================================================================
+  // BaseProvider Implementation
+  // ===========================================================================
+  async connect() {
+    if (this.status === "connected") return;
+    this.status = "connecting";
+    this.status = "connected";
+    this.emitEvent({ type: "oracle:connected", timestamp: Date.now() });
+    this.log("Connected to oracle:", this.config.url);
+  }
+  async disconnect() {
+    this.status = "disconnected";
+    this.emitEvent({ type: "oracle:disconnected", timestamp: Date.now() });
+    this.log("Disconnected from oracle");
+  }
+  isConnected() {
+    return this.status === "connected";
+  }
+  getStatus() {
+    return this.status;
+  }
+  // ===========================================================================
+  // OracleProvider Implementation
+  // ===========================================================================
+  async initialize(trustBase) {
+    this.aggregatorClient = new import_AggregatorClient.AggregatorClient(
+      this.config.url,
+      this.config.apiKey || null
+    );
+    this.stateTransitionClient = new import_StateTransitionClient.StateTransitionClient(this.aggregatorClient);
+    if (trustBase) {
+      this.trustBase = trustBase;
+    } else if (!this.config.skipVerification && this.config.trustBaseLoader) {
+      try {
+        const trustBaseJson = await this.config.trustBaseLoader.load();
+        if (trustBaseJson) {
+          this.trustBase = import_RootTrustBase.RootTrustBase.fromJSON(trustBaseJson);
+        }
+      } catch (error) {
+        this.log("Failed to load trust base:", error);
+      }
+    }
+    await this.connect();
+    this.log("Initialized with trust base:", !!this.trustBase);
+  }
+  /**
+   * Submit a transfer commitment to the aggregator.
+   * Accepts either an SDK TransferCommitment or a simple commitment object.
+   */
+  async submitCommitment(commitment) {
+    this.ensureConnected();
+    try {
+      let requestId;
+      if (this.isSdkTransferCommitment(commitment)) {
+        const response = await this.stateTransitionClient.submitTransferCommitment(commitment);
+        requestId = commitment.requestId?.toString() ?? response.status;
+      } else {
+        const response = await this.rpcCall("submitCommitment", {
+          sourceToken: commitment.sourceToken,
+          recipient: commitment.recipient,
+          salt: Array.from(commitment.salt),
+          data: commitment.data
+        });
+        requestId = response.requestId ?? "";
+      }
+      this.emitEvent({
+        type: "commitment:submitted",
+        timestamp: Date.now(),
+        data: { requestId }
+      });
+      return {
+        success: true,
+        requestId,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMsg,
+        timestamp: Date.now()
+      };
+    }
+  }
+  /**
+   * Submit a mint commitment to the aggregator (SDK only)
+   * @param commitment - SDK MintCommitment instance
+   */
+  async submitMintCommitment(commitment) {
+    this.ensureConnected();
+    try {
+      const response = await this.stateTransitionClient.submitMintCommitment(commitment);
+      const requestId = commitment.requestId?.toString() ?? response.status;
+      this.emitEvent({
+        type: "commitment:submitted",
+        timestamp: Date.now(),
+        data: { requestId }
+      });
+      return {
+        success: true,
+        requestId,
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMsg,
+        timestamp: Date.now()
+      };
+    }
+  }
+  isSdkTransferCommitment(commitment) {
+    return commitment !== null && typeof commitment === "object" && "requestId" in commitment && typeof commitment.requestId?.toString === "function";
+  }
+  async getProof(requestId) {
+    this.ensureConnected();
+    try {
+      const response = await this.rpcCall("getInclusionProof", { requestId });
+      if (!response.proof) {
+        return null;
+      }
+      return {
+        requestId,
+        roundNumber: response.roundNumber ?? 0,
+        proof: response.proof,
+        timestamp: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async waitForProof(requestId, options) {
+    const timeout = options?.timeout ?? this.config.timeout;
+    const pollInterval = options?.pollInterval ?? TIMEOUTS.PROOF_POLL_INTERVAL;
+    const startTime = Date.now();
+    let attempt = 0;
+    while (Date.now() - startTime < timeout) {
+      options?.onPoll?.(++attempt);
+      const proof = await this.getProof(requestId);
+      if (proof) {
+        this.emitEvent({
+          type: "proof:received",
+          timestamp: Date.now(),
+          data: { requestId, roundNumber: proof.roundNumber }
+        });
+        return proof;
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    }
+    throw new Error(`Timeout waiting for proof: ${requestId}`);
+  }
+  async validateToken(tokenData) {
+    this.ensureConnected();
+    try {
+      if (this.trustBase && !this.config.skipVerification) {
+        try {
+          const sdkToken = await import_Token.Token.fromJSON(tokenData);
+          const verifyResult = await sdkToken.verify(this.trustBase);
+          const stateHash = await sdkToken.state.calculateHash();
+          const stateHashStr = stateHash.toJSON();
+          const valid2 = verifyResult.isSuccessful;
+          this.emitEvent({
+            type: "validation:completed",
+            timestamp: Date.now(),
+            data: { valid: valid2 }
+          });
+          return {
+            valid: valid2,
+            spent: false,
+            // Spend check is separate
+            stateHash: stateHashStr,
+            error: valid2 ? void 0 : "SDK verification failed"
+          };
+        } catch (sdkError) {
+          this.log("SDK validation failed, falling back to RPC:", sdkError);
+        }
+      }
+      const response = await this.rpcCall("validateToken", { token: tokenData });
+      const valid = response.valid ?? false;
+      const spent = response.spent ?? false;
+      this.emitEvent({
+        type: "validation:completed",
+        timestamp: Date.now(),
+        data: { valid }
+      });
+      if (response.stateHash && spent) {
+        this.spentCache.set(response.stateHash, true);
+      }
+      return {
+        valid,
+        spent,
+        stateHash: response.stateHash,
+        error: response.error
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        spent: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Wait for inclusion proof using SDK (for SDK commitments)
+   */
+  async waitForProofSdk(commitment, signal) {
+    this.ensureConnected();
+    if (!this.trustBase) {
+      throw new Error("Trust base not initialized");
+    }
+    return await (0, import_InclusionProofUtils.waitInclusionProof)(
+      this.trustBase,
+      this.stateTransitionClient,
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      commitment,
+      signal
+    );
+  }
+  async isSpent(stateHash) {
+    if (this.spentCache.has(stateHash)) {
+      return this.spentCache.get(stateHash);
+    }
+    this.ensureConnected();
+    try {
+      const response = await this.rpcCall("isSpent", { stateHash });
+      const spent = response.spent ?? false;
+      if (spent) {
+        this.spentCache.set(stateHash, true);
+      }
+      return spent;
+    } catch {
+      return false;
+    }
+  }
+  async getTokenState(tokenId) {
+    this.ensureConnected();
+    try {
+      const response = await this.rpcCall("getTokenState", { tokenId });
+      if (!response.state) {
+        return null;
+      }
+      return {
+        tokenId,
+        stateHash: response.state.stateHash ?? "",
+        spent: response.state.spent ?? false,
+        roundNumber: response.state.roundNumber,
+        lastUpdated: Date.now()
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getCurrentRound() {
+    if (this.aggregatorClient) {
+      const blockHeight = await this.aggregatorClient.getBlockHeight();
+      return Number(blockHeight);
+    }
+    return 0;
+  }
+  async mint(params) {
+    this.ensureConnected();
+    try {
+      const response = await this.rpcCall("mint", {
+        coinId: params.coinId,
+        amount: params.amount,
+        recipientAddress: params.recipientAddress,
+        recipientPubkey: params.recipientPubkey
+      });
+      return {
+        success: true,
+        requestId: response.requestId,
+        tokenId: response.tokenId
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  // ===========================================================================
+  // Event Subscription
+  // ===========================================================================
+  onEvent(callback) {
+    this.eventCallbacks.add(callback);
+    return () => this.eventCallbacks.delete(callback);
+  }
+  // ===========================================================================
+  // Private: RPC
+  // ===========================================================================
+  async rpcCall(method, params) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      const response = await fetch(this.config.url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: Date.now(),
+          method,
+          params
+        }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const result = await response.json();
+      if (result.error) {
+        throw new Error(result.error.message ?? "RPC error");
+      }
+      return result.result ?? {};
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  // ===========================================================================
+  // Private: Helpers
+  // ===========================================================================
+  ensureConnected() {
+    if (this.status !== "connected") {
+      throw new Error("UnicityAggregatorProvider not connected");
+    }
+  }
+  emitEvent(event) {
+    for (const callback of this.eventCallbacks) {
+      try {
+        callback(event);
+      } catch (error) {
+        this.log("Event callback error:", error);
+      }
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[UnicityAggregatorProvider]", ...args);
+    }
+  }
+};
+var UnicityOracleProvider = UnicityAggregatorProvider;
+
+// impl/nodejs/oracle/index.ts
+var NodeTrustBaseLoader = class {
+  filePath;
+  constructor(filePath = "./trustbase-testnet.json") {
+    this.filePath = filePath;
+  }
+  async load() {
+    try {
+      if (fs3.existsSync(this.filePath)) {
+        const content = fs3.readFileSync(this.filePath, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return null;
+  }
+};
+function createNodeTrustBaseLoader(filePath) {
+  return new NodeTrustBaseLoader(filePath);
+}
+function createUnicityAggregatorProvider(config) {
+  const { trustBasePath, ...restConfig } = config;
+  return new UnicityAggregatorProvider({
+    ...restConfig,
+    trustBaseLoader: createNodeTrustBaseLoader(trustBasePath)
+  });
+}
+var createUnicityOracleProvider = createUnicityAggregatorProvider;
+
+// impl/shared/resolvers.ts
+function getNetworkConfig(network = "mainnet") {
+  return NETWORKS[network];
+}
+function resolveTransportConfig(network, config) {
+  const networkConfig = getNetworkConfig(network);
+  let relays;
+  if (config?.relays) {
+    relays = config.relays;
+  } else {
+    relays = [...networkConfig.nostrRelays];
+    if (config?.additionalRelays) {
+      relays = [...relays, ...config.additionalRelays];
+    }
+  }
+  return {
+    relays,
+    timeout: config?.timeout,
+    autoReconnect: config?.autoReconnect,
+    debug: config?.debug,
+    // Browser-specific
+    reconnectDelay: config?.reconnectDelay,
+    maxReconnectAttempts: config?.maxReconnectAttempts
+  };
+}
+function resolveOracleConfig(network, config) {
+  const networkConfig = getNetworkConfig(network);
+  return {
+    url: config?.url ?? networkConfig.aggregatorUrl,
+    apiKey: config?.apiKey,
+    timeout: config?.timeout,
+    skipVerification: config?.skipVerification,
+    debug: config?.debug,
+    // Node.js-specific
+    trustBasePath: config?.trustBasePath
+  };
+}
+function resolveL1Config(network, config) {
+  if (config === void 0) {
+    return void 0;
+  }
+  const networkConfig = getNetworkConfig(network);
+  return {
+    electrumUrl: config.electrumUrl ?? networkConfig.electrumUrl,
+    defaultFeeRate: config.defaultFeeRate,
+    enableVesting: config.enableVesting
+  };
+}
+
+// impl/nodejs/index.ts
+function createNodeProviders(config) {
+  const network = config?.network ?? "mainnet";
+  const transportConfig = resolveTransportConfig(network, config?.transport);
+  const oracleConfig = resolveOracleConfig(network, config?.oracle);
+  const l1Config = resolveL1Config(network, config?.l1);
+  return {
+    storage: createFileStorageProvider({
+      dataDir: config?.dataDir ?? "./sphere-data"
+    }),
+    tokenStorage: createFileTokenStorageProvider({
+      tokensDir: config?.tokensDir ?? "./sphere-tokens"
+    }),
+    transport: createNostrTransportProvider({
+      relays: transportConfig.relays,
+      timeout: transportConfig.timeout,
+      autoReconnect: transportConfig.autoReconnect,
+      debug: transportConfig.debug
+    }),
+    oracle: createUnicityAggregatorProvider({
+      url: oracleConfig.url,
+      apiKey: oracleConfig.apiKey,
+      timeout: oracleConfig.timeout,
+      trustBasePath: oracleConfig.trustBasePath,
+      skipVerification: oracleConfig.skipVerification,
+      debug: oracleConfig.debug
+    }),
+    l1: l1Config
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileStorageProvider,
+  FileTokenStorageProvider,
+  NodeTrustBaseLoader,
+  NostrTransportProvider,
+  UnicityAggregatorProvider,
+  UnicityOracleProvider,
+  createFileStorageProvider,
+  createFileTokenStorageProvider,
+  createNodeProviders,
+  createNodeTrustBaseLoader,
+  createNodeWebSocketFactory,
+  createNostrTransportProvider,
+  createUnicityAggregatorProvider,
+  createUnicityOracleProvider
+});
+//# sourceMappingURL=index.cjs.map