@empereur-rouge/pms-sdk 0.3.0 → 0.3.2

package/README.md

@@ -132,6 +132,43 @@ const client = new PmsClient({
 > [!IMPORTANT]
 > La clé API est **obligatoire**. Obtenez-la depuis votre dashboard PMS ou auprès de l'administrateur du réseau.
 
+#### Wallet (Custodial — Server-Side)
+
+Ces méthodes créent/restaurent des wallets **côté serveur**. L'adresse retournée est au format Bech32 (ex: `8e1a...`).
+
+```typescript
+// Créer un nouveau wallet (serveur génère les clés)
+const wallet = await client.createWallet();
+// Réponse (WalletResponse):
+// {
+//   address: "8e1ahpltzjauwev6lf0jql...",
+//   private_key_b64: "2lM0rVdFXX...",
+//   private_key_hex: "da5334ad57455d74...",
+//   public_key_hex: "04593037fa9d4f6ea2...",
+//   x25519_pub_hex: "266bcd33ab2d20d2...",
+//   mnemonic_words: ["gain", "space", "color", ...]
+// }
+```
+
+```typescript
+// Restaurer un wallet depuis un mnemonic (24 mots BIP39)
+const restored = await client.restoreFromMnemonic(
+  "gain space color filter buzz bind side before sauce twist slam history chief patch desk chunk way oblige output turtle purchase scare token rapid"
+);
+console.log(restored.address); // "8e1ahpltzjauwev6lf0jql..."
+```
+
+```typescript
+// Restaurer un wallet depuis une clé privée hex
+const imported = await client.restoreFromPrivateKey(
+  "da5334ad57455d74e5150e4eb06398ce9cf27762b6f29eac7f82f178bee07406"
+);
+console.log(imported.address); // même adresse que ci-dessus
+```
+
+> [!NOTE]
+> Le mnemonic et la clé privée produisent **exactement la même adresse** — la dérivation est déterministe.
+
 #### Méthodes de Lecture
 
 ```typescript
@@ -407,6 +444,7 @@ import type {
   SubmitResponse,
   BalanceInfo,
   SupplyInfo,
+  WalletResponse,
   
   // NFT
   NftMetadata,

package/dist/index.cjs

@@ -625,6 +625,147 @@ var PmsClient = class {
     return res;
   }
   // ═══════════════════════════════════════════════════════════════════════
+  // Activité du wallet
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Récupère l'activité complète d'un wallet avec classification sémantique.
+   *
+   * Chaque activité est classifiée (transfer_in, fee_received, nft_mint, freeze, etc.)
+   * avec direction, montant et contrepartie.
+   *
+   * @param address - Adresse du wallet (bech32 ou hex)
+   * @param options - Filtres et pagination
+   * @returns Activités paginées
+   *
+   * @example
+   * ```typescript
+   * // Toute l'activité
+   * const activity = await client.getActivity("8eabc...");
+   *
+   * // Seulement les fees reçues
+   * const fees = await client.getActivity("8eabc...", {
+   *   type: ["fee_received"],
+   *   limit: 20,
+   * });
+   *
+   * // Pagination
+   * const page2 = await client.getActivity("8eabc...", {
+   *   after_ts: activity.next_after_ts,
+   *   after_id: activity.next_after_id,
+   * });
+   * ```
+   */
+  async getActivity(address, options) {
+    const params = new URLSearchParams();
+    if (options?.type && options.type.length > 0) {
+      params.set("type", options.type.join(","));
+    }
+    if (options?.limit !== void 0) {
+      params.set("limit", String(options.limit));
+    }
+    if (options?.after_ts !== void 0) {
+      params.set("after_ts", String(options.after_ts));
+    }
+    if (options?.after_id !== void 0) {
+      params.set("after_id", options.after_id);
+    }
+    if (options?.asset_id !== void 0) {
+      params.set("asset_id", options.asset_id);
+    }
+    const qs = params.toString();
+    const path = `/v1/wallet/${encodeURIComponent(address)}/activity${qs ? `?${qs}` : ""}`;
+    return this.fetch(path);
+  }
+  /**
+   * Écoute l'activité d'un wallet en temps réel via Server-Sent Events (SSE).
+   *
+   * Retourne une fonction de nettoyage pour fermer la connexion.
+   *
+   * @param address - Adresse du wallet (bech32 ou hex)
+   * @param options - Callbacks et filtres
+   * @returns Fonction pour fermer le flux SSE
+   *
+   * @example
+   * ```typescript
+   * const stop = client.streamActivity("8eabc...", {
+   *   type: ["transfer_in", "fee_received"],
+   *   onActivity: (item) => {
+   *     console.log(`${item.activity_type}: ${item.amount} ${item.direction}`);
+   *   },
+   *   onError: (err) => console.error(err),
+   * });
+   *
+   * // Plus tard: fermer la connexion
+   * stop();
+   * ```
+   */
+  streamActivity(address, options) {
+    const params = new URLSearchParams();
+    if (options.type && options.type.length > 0) {
+      params.set("type", options.type.join(","));
+    }
+    const qs = params.toString();
+    const path = `/v1/wallet/${encodeURIComponent(address)}/activity/stream${qs ? `?${qs}` : ""}`;
+    const url = `${this.config.nodeUrl}${path}`;
+    const controller = new AbortController();
+    const signal = options.signal ? mergeAbortSignals(options.signal, controller.signal) : controller.signal;
+    (async () => {
+      try {
+        const headers = {
+          "Accept": "text/event-stream"
+        };
+        if (this.config.apiKey) {
+          headers["X-API-Key"] = this.config.apiKey;
+        }
+        const resp = await fetch(url, { headers, signal });
+        if (!resp.ok) {
+          throw new Error(`SSE connection failed: ${resp.status} ${resp.statusText}`);
+        }
+        if (!resp.body) {
+          throw new Error("SSE response has no body");
+        }
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          let currentEvent = "";
+          let currentData = "";
+          for (const line of lines) {
+            if (line.startsWith("event:")) {
+              currentEvent = line.slice(6).trim();
+            } else if (line.startsWith("data:")) {
+              currentData = line.slice(5).trim();
+            } else if (line === "" && currentData) {
+              if (currentEvent === "activity" && currentData) {
+                try {
+                  const item = JSON.parse(currentData);
+                  options.onActivity(item);
+                } catch (e) {
+                }
+              } else if (currentEvent === "warning") {
+              }
+              currentEvent = "";
+              currentData = "";
+            }
+          }
+        }
+        options.onClose?.();
+      } catch (err) {
+        if (err.name === "AbortError") {
+          options.onClose?.();
+        } else {
+          options.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    })();
+    return () => controller.abort();
+  }
+  // ═══════════════════════════════════════════════════════════════════════
   // Méthodes d'écriture (POST)
   // ═══════════════════════════════════════════════════════════════════════
   /**
@@ -1119,6 +1260,13 @@ var PmsClient = class {
     }
   }
 };
+function mergeAbortSignals(a, b) {
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PmsClient,

package/dist/index.d.cts

@@ -529,6 +529,81 @@ interface WalletHistoryResp {
     items: HistoryItem[];
     count: number;
 }
+/**
+ * Type d'activité sémantique pour un wallet.
+ *
+ * - Transferts: "transfer_in", "transfer_out", "transfer_self"
+ * - Fees: "fee_received"
+ * - Minting: "mint"
+ * - NFT: "nft_mint", "nft_transfer_in", "nft_transfer_out", "nft_burn", "nft_use"
+ * - Bridge: "bridge_lock_in", "bridge_lock_out", "bridge_mint"
+ * - Compliance: "freeze", "unfreeze", "seized", "seize_received", "reversed", "reverse_received"
+ * - Token: "token_create"
+ * - Reward: "reward"
+ */
+type ActivityType = "transfer_in" | "transfer_out" | "transfer_self" | "fee_received" | "reward" | "mint" | "nft_mint" | "nft_transfer_in" | "nft_transfer_out" | "nft_burn" | "nft_use" | "bridge_lock_in" | "bridge_lock_out" | "bridge_mint" | "freeze" | "unfreeze" | "seized" | "seize_received" | "reversed" | "reverse_received" | "token_create";
+/** Direction de l'activité */
+type ActivityDirection = "in" | "out" | "info";
+/** Élément d'activité classifié pour un wallet */
+interface ActivityItem {
+    /** ID du bloc contenant l'activité */
+    block_id: string;
+    /** Timestamp en millisecondes */
+    ts_ms: number;
+    /** Type d'activité sémantique */
+    activity_type: ActivityType;
+    /** Direction: "in" (reçu), "out" (envoyé), "info" (informatif) */
+    direction: ActivityDirection;
+    /** Montant net pour cette adresse (positif = reçu), absent pour NFT/compliance */
+    amount?: string;
+    /** Asset ID (undefined = PMS natif) */
+    asset_id?: string;
+    /** Adresse de la contrepartie */
+    counterparty?: string;
+    /** Payload brut pour détails complets */
+    payload: any;
+}
+/** Réponse de l'endpoint GET /v1/wallet/{address}/activity */
+interface ActivityResp {
+    /** Adresse du wallet */
+    address: string;
+    /** Éléments d'activité classifiés */
+    items: ActivityItem[];
+    /** Nombre d'éléments retournés */
+    count: number;
+    /** Timestamp cursor pour la pagination (next page) */
+    next_after_ts?: number;
+    /** Block ID cursor pour la pagination (next page) */
+    next_after_id?: string;
+    /** Indique s'il y a plus de résultats */
+    has_more: boolean;
+}
+/** Options pour getActivity() */
+interface ActivityOptions {
+    /** Filtrer par type(s) d'activité (ex: ["fee_received", "transfer_in"]) */
+    type?: ActivityType[];
+    /** Nombre max d'éléments (défaut: 50, max: 500) */
+    limit?: number;
+    /** Cursor de pagination: timestamp */
+    after_ts?: number;
+    /** Cursor de pagination: block ID */
+    after_id?: string;
+    /** Filtrer par asset ID */
+    asset_id?: string;
+}
+/** Options pour streamActivity() */
+interface StreamActivityOptions {
+    /** Filtrer par type(s) d'activité */
+    type?: ActivityType[];
+    /** Callback appelé pour chaque activité en temps réel */
+    onActivity: (item: ActivityItem) => void;
+    /** Callback appelé en cas d'erreur */
+    onError?: (error: Error) => void;
+    /** Callback appelé à la fermeture du flux */
+    onClose?: () => void;
+    /** Signal d'annulation */
+    signal?: AbortSignal;
+}
 interface RuntimeConfig {
     fee_rate_bps: number;
     base_fee: string;
@@ -743,6 +818,59 @@ declare class PmsClient {
         limit?: number;
         decryptionWallet?: PmsWallet;
     }): Promise<WalletHistoryResp>;
+    /**
+     * Récupère l'activité complète d'un wallet avec classification sémantique.
+     *
+     * Chaque activité est classifiée (transfer_in, fee_received, nft_mint, freeze, etc.)
+     * avec direction, montant et contrepartie.
+     *
+     * @param address - Adresse du wallet (bech32 ou hex)
+     * @param options - Filtres et pagination
+     * @returns Activités paginées
+     *
+     * @example
+     * ```typescript
+     * // Toute l'activité
+     * const activity = await client.getActivity("8eabc...");
+     *
+     * // Seulement les fees reçues
+     * const fees = await client.getActivity("8eabc...", {
+     *   type: ["fee_received"],
+     *   limit: 20,
+     * });
+     *
+     * // Pagination
+     * const page2 = await client.getActivity("8eabc...", {
+     *   after_ts: activity.next_after_ts,
+     *   after_id: activity.next_after_id,
+     * });
+     * ```
+     */
+    getActivity(address: string, options?: ActivityOptions): Promise<ActivityResp>;
+    /**
+     * Écoute l'activité d'un wallet en temps réel via Server-Sent Events (SSE).
+     *
+     * Retourne une fonction de nettoyage pour fermer la connexion.
+     *
+     * @param address - Adresse du wallet (bech32 ou hex)
+     * @param options - Callbacks et filtres
+     * @returns Fonction pour fermer le flux SSE
+     *
+     * @example
+     * ```typescript
+     * const stop = client.streamActivity("8eabc...", {
+     *   type: ["transfer_in", "fee_received"],
+     *   onActivity: (item) => {
+     *     console.log(`${item.activity_type}: ${item.amount} ${item.direction}`);
+     *   },
+     *   onError: (err) => console.error(err),
+     * });
+     *
+     * // Plus tard: fermer la connexion
+     * stop();
+     * ```
+     */
+    streamActivity(address: string, options: StreamActivityOptions): () => void;
     /**
      * Récupère la configuration publique du nœud (frais, PoW, recipient, etc.)
      */
@@ -915,4 +1043,4 @@ declare function formatAmount(sats: bigint): string;
  */
 declare function decryptPayload(encrypted: EncryptedPayload, recipientPrivateKeyHex: string): string;
 
-export { type BalanceInfo, type Block, type BurnNftResponse, type CoordinatorInfoResponse, type CubeAttributes, type HistoryItem, type MintCubeResponse, type NftMetadata, type NftResponse, PmsClient, type PmsClientConfig, PmsWallet, type PrepareTxRequest, type PrepareTxResponse, type RuntimeConfig, type SubmitResponse, type SupplyInfo, type TokenMetadata, type Utxo, type UtxoDetail, type WalletHistoryResp, type WalletResponse, decryptPayload, formatAmount, fromHex, isValidMnemonic, parseAmount, toHex };
+export { type ActivityDirection, type ActivityItem, type ActivityOptions, type ActivityResp, type ActivityType, type BalanceInfo, type Block, type BurnNftResponse, type CoordinatorInfoResponse, type CubeAttributes, type HistoryItem, type MintCubeResponse, type NftMetadata, type NftResponse, PmsClient, type PmsClientConfig, PmsWallet, type PrepareTxRequest, type PrepareTxResponse, type RuntimeConfig, type StreamActivityOptions, type SubmitResponse, type SupplyInfo, type TokenMetadata, type Utxo, type UtxoDetail, type WalletHistoryResp, type WalletResponse, decryptPayload, formatAmount, fromHex, isValidMnemonic, parseAmount, toHex };

package/dist/index.d.ts

@@ -529,6 +529,81 @@ interface WalletHistoryResp {
     items: HistoryItem[];
     count: number;
 }
+/**
+ * Type d'activité sémantique pour un wallet.
+ *
+ * - Transferts: "transfer_in", "transfer_out", "transfer_self"
+ * - Fees: "fee_received"
+ * - Minting: "mint"
+ * - NFT: "nft_mint", "nft_transfer_in", "nft_transfer_out", "nft_burn", "nft_use"
+ * - Bridge: "bridge_lock_in", "bridge_lock_out", "bridge_mint"
+ * - Compliance: "freeze", "unfreeze", "seized", "seize_received", "reversed", "reverse_received"
+ * - Token: "token_create"
+ * - Reward: "reward"
+ */
+type ActivityType = "transfer_in" | "transfer_out" | "transfer_self" | "fee_received" | "reward" | "mint" | "nft_mint" | "nft_transfer_in" | "nft_transfer_out" | "nft_burn" | "nft_use" | "bridge_lock_in" | "bridge_lock_out" | "bridge_mint" | "freeze" | "unfreeze" | "seized" | "seize_received" | "reversed" | "reverse_received" | "token_create";
+/** Direction de l'activité */
+type ActivityDirection = "in" | "out" | "info";
+/** Élément d'activité classifié pour un wallet */
+interface ActivityItem {
+    /** ID du bloc contenant l'activité */
+    block_id: string;
+    /** Timestamp en millisecondes */
+    ts_ms: number;
+    /** Type d'activité sémantique */
+    activity_type: ActivityType;
+    /** Direction: "in" (reçu), "out" (envoyé), "info" (informatif) */
+    direction: ActivityDirection;
+    /** Montant net pour cette adresse (positif = reçu), absent pour NFT/compliance */
+    amount?: string;
+    /** Asset ID (undefined = PMS natif) */
+    asset_id?: string;
+    /** Adresse de la contrepartie */
+    counterparty?: string;
+    /** Payload brut pour détails complets */
+    payload: any;
+}
+/** Réponse de l'endpoint GET /v1/wallet/{address}/activity */
+interface ActivityResp {
+    /** Adresse du wallet */
+    address: string;
+    /** Éléments d'activité classifiés */
+    items: ActivityItem[];
+    /** Nombre d'éléments retournés */
+    count: number;
+    /** Timestamp cursor pour la pagination (next page) */
+    next_after_ts?: number;
+    /** Block ID cursor pour la pagination (next page) */
+    next_after_id?: string;
+    /** Indique s'il y a plus de résultats */
+    has_more: boolean;
+}
+/** Options pour getActivity() */
+interface ActivityOptions {
+    /** Filtrer par type(s) d'activité (ex: ["fee_received", "transfer_in"]) */
+    type?: ActivityType[];
+    /** Nombre max d'éléments (défaut: 50, max: 500) */
+    limit?: number;
+    /** Cursor de pagination: timestamp */
+    after_ts?: number;
+    /** Cursor de pagination: block ID */
+    after_id?: string;
+    /** Filtrer par asset ID */
+    asset_id?: string;
+}
+/** Options pour streamActivity() */
+interface StreamActivityOptions {
+    /** Filtrer par type(s) d'activité */
+    type?: ActivityType[];
+    /** Callback appelé pour chaque activité en temps réel */
+    onActivity: (item: ActivityItem) => void;
+    /** Callback appelé en cas d'erreur */
+    onError?: (error: Error) => void;
+    /** Callback appelé à la fermeture du flux */
+    onClose?: () => void;
+    /** Signal d'annulation */
+    signal?: AbortSignal;
+}
 interface RuntimeConfig {
     fee_rate_bps: number;
     base_fee: string;
@@ -743,6 +818,59 @@ declare class PmsClient {
         limit?: number;
         decryptionWallet?: PmsWallet;
     }): Promise<WalletHistoryResp>;
+    /**
+     * Récupère l'activité complète d'un wallet avec classification sémantique.
+     *
+     * Chaque activité est classifiée (transfer_in, fee_received, nft_mint, freeze, etc.)
+     * avec direction, montant et contrepartie.
+     *
+     * @param address - Adresse du wallet (bech32 ou hex)
+     * @param options - Filtres et pagination
+     * @returns Activités paginées
+     *
+     * @example
+     * ```typescript
+     * // Toute l'activité
+     * const activity = await client.getActivity("8eabc...");
+     *
+     * // Seulement les fees reçues
+     * const fees = await client.getActivity("8eabc...", {
+     *   type: ["fee_received"],
+     *   limit: 20,
+     * });
+     *
+     * // Pagination
+     * const page2 = await client.getActivity("8eabc...", {
+     *   after_ts: activity.next_after_ts,
+     *   after_id: activity.next_after_id,
+     * });
+     * ```
+     */
+    getActivity(address: string, options?: ActivityOptions): Promise<ActivityResp>;
+    /**
+     * Écoute l'activité d'un wallet en temps réel via Server-Sent Events (SSE).
+     *
+     * Retourne une fonction de nettoyage pour fermer la connexion.
+     *
+     * @param address - Adresse du wallet (bech32 ou hex)
+     * @param options - Callbacks et filtres
+     * @returns Fonction pour fermer le flux SSE
+     *
+     * @example
+     * ```typescript
+     * const stop = client.streamActivity("8eabc...", {
+     *   type: ["transfer_in", "fee_received"],
+     *   onActivity: (item) => {
+     *     console.log(`${item.activity_type}: ${item.amount} ${item.direction}`);
+     *   },
+     *   onError: (err) => console.error(err),
+     * });
+     *
+     * // Plus tard: fermer la connexion
+     * stop();
+     * ```
+     */
+    streamActivity(address: string, options: StreamActivityOptions): () => void;
     /**
      * Récupère la configuration publique du nœud (frais, PoW, recipient, etc.)
      */
@@ -915,4 +1043,4 @@ declare function formatAmount(sats: bigint): string;
  */
 declare function decryptPayload(encrypted: EncryptedPayload, recipientPrivateKeyHex: string): string;
 
-export { type BalanceInfo, type Block, type BurnNftResponse, type CoordinatorInfoResponse, type CubeAttributes, type HistoryItem, type MintCubeResponse, type NftMetadata, type NftResponse, PmsClient, type PmsClientConfig, PmsWallet, type PrepareTxRequest, type PrepareTxResponse, type RuntimeConfig, type SubmitResponse, type SupplyInfo, type TokenMetadata, type Utxo, type UtxoDetail, type WalletHistoryResp, type WalletResponse, decryptPayload, formatAmount, fromHex, isValidMnemonic, parseAmount, toHex };
+export { type ActivityDirection, type ActivityItem, type ActivityOptions, type ActivityResp, type ActivityType, type BalanceInfo, type Block, type BurnNftResponse, type CoordinatorInfoResponse, type CubeAttributes, type HistoryItem, type MintCubeResponse, type NftMetadata, type NftResponse, PmsClient, type PmsClientConfig, PmsWallet, type PrepareTxRequest, type PrepareTxResponse, type RuntimeConfig, type StreamActivityOptions, type SubmitResponse, type SupplyInfo, type TokenMetadata, type Utxo, type UtxoDetail, type WalletHistoryResp, type WalletResponse, decryptPayload, formatAmount, fromHex, isValidMnemonic, parseAmount, toHex };

package/dist/index.js

@@ -592,6 +592,147 @@ var PmsClient = class {
     return res;
   }
   // ═══════════════════════════════════════════════════════════════════════
+  // Activité du wallet
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Récupère l'activité complète d'un wallet avec classification sémantique.
+   *
+   * Chaque activité est classifiée (transfer_in, fee_received, nft_mint, freeze, etc.)
+   * avec direction, montant et contrepartie.
+   *
+   * @param address - Adresse du wallet (bech32 ou hex)
+   * @param options - Filtres et pagination
+   * @returns Activités paginées
+   *
+   * @example
+   * ```typescript
+   * // Toute l'activité
+   * const activity = await client.getActivity("8eabc...");
+   *
+   * // Seulement les fees reçues
+   * const fees = await client.getActivity("8eabc...", {
+   *   type: ["fee_received"],
+   *   limit: 20,
+   * });
+   *
+   * // Pagination
+   * const page2 = await client.getActivity("8eabc...", {
+   *   after_ts: activity.next_after_ts,
+   *   after_id: activity.next_after_id,
+   * });
+   * ```
+   */
+  async getActivity(address, options) {
+    const params = new URLSearchParams();
+    if (options?.type && options.type.length > 0) {
+      params.set("type", options.type.join(","));
+    }
+    if (options?.limit !== void 0) {
+      params.set("limit", String(options.limit));
+    }
+    if (options?.after_ts !== void 0) {
+      params.set("after_ts", String(options.after_ts));
+    }
+    if (options?.after_id !== void 0) {
+      params.set("after_id", options.after_id);
+    }
+    if (options?.asset_id !== void 0) {
+      params.set("asset_id", options.asset_id);
+    }
+    const qs = params.toString();
+    const path = `/v1/wallet/${encodeURIComponent(address)}/activity${qs ? `?${qs}` : ""}`;
+    return this.fetch(path);
+  }
+  /**
+   * Écoute l'activité d'un wallet en temps réel via Server-Sent Events (SSE).
+   *
+   * Retourne une fonction de nettoyage pour fermer la connexion.
+   *
+   * @param address - Adresse du wallet (bech32 ou hex)
+   * @param options - Callbacks et filtres
+   * @returns Fonction pour fermer le flux SSE
+   *
+   * @example
+   * ```typescript
+   * const stop = client.streamActivity("8eabc...", {
+   *   type: ["transfer_in", "fee_received"],
+   *   onActivity: (item) => {
+   *     console.log(`${item.activity_type}: ${item.amount} ${item.direction}`);
+   *   },
+   *   onError: (err) => console.error(err),
+   * });
+   *
+   * // Plus tard: fermer la connexion
+   * stop();
+   * ```
+   */
+  streamActivity(address, options) {
+    const params = new URLSearchParams();
+    if (options.type && options.type.length > 0) {
+      params.set("type", options.type.join(","));
+    }
+    const qs = params.toString();
+    const path = `/v1/wallet/${encodeURIComponent(address)}/activity/stream${qs ? `?${qs}` : ""}`;
+    const url = `${this.config.nodeUrl}${path}`;
+    const controller = new AbortController();
+    const signal = options.signal ? mergeAbortSignals(options.signal, controller.signal) : controller.signal;
+    (async () => {
+      try {
+        const headers = {
+          "Accept": "text/event-stream"
+        };
+        if (this.config.apiKey) {
+          headers["X-API-Key"] = this.config.apiKey;
+        }
+        const resp = await fetch(url, { headers, signal });
+        if (!resp.ok) {
+          throw new Error(`SSE connection failed: ${resp.status} ${resp.statusText}`);
+        }
+        if (!resp.body) {
+          throw new Error("SSE response has no body");
+        }
+        const reader = resp.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          buffer += decoder.decode(value, { stream: true });
+          const lines = buffer.split("\n");
+          buffer = lines.pop() ?? "";
+          let currentEvent = "";
+          let currentData = "";
+          for (const line of lines) {
+            if (line.startsWith("event:")) {
+              currentEvent = line.slice(6).trim();
+            } else if (line.startsWith("data:")) {
+              currentData = line.slice(5).trim();
+            } else if (line === "" && currentData) {
+              if (currentEvent === "activity" && currentData) {
+                try {
+                  const item = JSON.parse(currentData);
+                  options.onActivity(item);
+                } catch (e) {
+                }
+              } else if (currentEvent === "warning") {
+              }
+              currentEvent = "";
+              currentData = "";
+            }
+          }
+        }
+        options.onClose?.();
+      } catch (err) {
+        if (err.name === "AbortError") {
+          options.onClose?.();
+        } else {
+          options.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+      }
+    })();
+    return () => controller.abort();
+  }
+  // ═══════════════════════════════════════════════════════════════════════
   // Méthodes d'écriture (POST)
   // ═══════════════════════════════════════════════════════════════════════
   /**
@@ -1086,6 +1227,13 @@ var PmsClient = class {
     }
   }
 };
+function mergeAbortSignals(a, b) {
+  const controller = new AbortController();
+  const onAbort = () => controller.abort();
+  a.addEventListener("abort", onAbort, { once: true });
+  b.addEventListener("abort", onAbort, { once: true });
+  return controller.signal;
+}
 export {
   PmsClient,
   PmsWallet,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@empereur-rouge/pms-sdk",
-    "version": "0.3.0",
+    "version": "0.3.2",
     "description": "TypeScript SDK for PMS (Planetary Monetary System) — wallet management, transactions, NFTs, and DAG interactions",
     "author": "empereur-rouge",
     "license": "MIT",