@empereur-rouge/pms-sdk 0.3.8 → 0.7.1

package/dist/index.js

@@ -9,6 +9,7 @@ import { wordlist } from "@scure/bip39/wordlists/english";
 // src/utils.ts
 import { sha256 } from "@noble/hashes/sha2";
 import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { base64, bech32m } from "@scure/base";
 function sha256Hash(data) {
   return sha256(data);
 }
@@ -21,12 +22,103 @@ function fromHex(hex) {
 function encodeUtf8(str) {
   return new TextEncoder().encode(str);
 }
-function computeBlockId(parents, payloadJson, nonce) {
-  const parentsStr = parents.sort().join(",");
-  const payloadStr = payloadJson ?? "";
-  const content = `${parentsStr}|${payloadStr}|${nonce}`;
-  const hash = sha256Hash(encodeUtf8(content));
-  return toHex(hash);
+function toBase64(bytes) {
+  return base64.encode(bytes);
+}
+function txSigningMessage(networkId, inputs, outputs, fee) {
+  const canonInputs = inputs.map((i) => ({
+    out: { txid: i.out.txid, index: i.out.index }
+  }));
+  const canonOutputs = outputs.map((o) => {
+    const out = {
+      address: o.address,
+      amount: o.amount
+    };
+    if (o.asset_id !== void 0 && o.asset_id !== null) {
+      out.asset_id = o.asset_id;
+    }
+    if (o.locked_until !== void 0 && o.locked_until !== null) {
+      out.locked_until = o.locked_until;
+    }
+    if (o.spend_condition !== void 0 && o.spend_condition !== null) {
+      out.spend_condition = o.spend_condition;
+    }
+    if (o.created_at !== void 0 && o.created_at !== null) {
+      out.created_at = o.created_at;
+    }
+    return out;
+  });
+  const canon = {
+    network_id: networkId,
+    inputs: canonInputs,
+    outputs: canonOutputs,
+    fee
+  };
+  return toHex(sha256Hash(encodeUtf8(JSON.stringify(canon))));
+}
+var PLAIN_VARIANT_TO_PAYLOAD_TYPE = {
+  Genesis: "Genesis",
+  Mint: "Mint",
+  TxUtxo: "Transaction",
+  Milestone: "Milestone",
+  Nft: "Nft",
+  ConfigUpdate: "ConfigUpdate",
+  Reward: "Reward",
+  EncryptedReward: "EncryptedReward",
+  TokenCreate: "TokenCreate",
+  BridgeLock: "BridgeLock",
+  BridgeMint: "BridgeMint",
+  Freeze: "Freeze",
+  Unfreeze: "Unfreeze",
+  Seize: "Seize",
+  Reverse: "Reverse",
+  ContractRegister: "ContractRegister",
+  ContractUpdate: "ContractUpdate",
+  LedgerOwnershipTransfer: "LedgerOwnershipTransfer",
+  CoordinatorKeyRotate: "CoordinatorKeyRotate"
+};
+var EMPTY_COMMITMENT = "0000000000000000000000000000000000000000000000000000000000000000";
+function computeBlockId(parents, payload, nonce) {
+  let payload_type;
+  let commitment;
+  let len_hint;
+  let key_version;
+  if (payload === void 0 || payload === null) {
+    payload_type = "None";
+    commitment = EMPTY_COMMITMENT;
+    len_hint = 0;
+    key_version = 0;
+  } else if ("Plain" in payload) {
+    const plain = payload.Plain;
+    const variant = typeof plain === "string" ? plain : Object.keys(plain)[0];
+    payload_type = PLAIN_VARIANT_TO_PAYLOAD_TYPE[variant] ?? variant;
+    const plainBytes = encodeUtf8(JSON.stringify(plain));
+    commitment = toHex(sha256Hash(plainBytes));
+    len_hint = plainBytes.length;
+    key_version = 0;
+  } else {
+    const enc = payload.Encrypted;
+    payload_type = "Encrypted";
+    commitment = enc.commitment;
+    len_hint = enc.ciphertext_b64.length;
+    key_version = enc.key_version;
+  }
+  const head = {
+    parents,
+    nonce,
+    envelope: { payload_type, commitment, len_hint, key_version }
+  };
+  return toHex(sha256Hash(encodeUtf8(JSON.stringify(head))));
+}
+function x25519FromAddress(address) {
+  try {
+    const decoded = bech32m.decode(address, false);
+    const bytes = bech32m.fromWords(decoded.words);
+    if (bytes.length !== 52) return void 0;
+    return toHex(bytes.slice(20));
+  } catch {
+    return void 0;
+  }
 }
 function parseAmount(amount) {
   const [whole, frac = ""] = amount.split(".");
@@ -39,6 +131,47 @@ function formatAmount(sats) {
   const fracStr = frac.toString().padStart(8, "0");
   return `${whole}.${fracStr}`;
 }
+var DAY_MS = 864e5;
+function multisigAddress(m, pubkeys) {
+  const normalized = pubkeys.map((pk) => {
+    const t = pk.trim();
+    return (t.startsWith("0x") ? t.slice(2) : t).toLowerCase();
+  }).sort();
+  const parts = [
+    encodeUtf8("pms-multisig-v1"),
+    new Uint8Array([m, normalized.length]),
+    ...normalized.map((pk) => encodeUtf8(pk))
+  ];
+  const total = parts.reduce((n, p) => n + p.length, 0);
+  const buf = new Uint8Array(total);
+  let off = 0;
+  for (const p of parts) {
+    buf.set(p, off);
+    off += p.length;
+  }
+  return `msig1${toHex(sha256Hash(buf).slice(0, 20))}`;
+}
+function hashlockHash(preimage) {
+  const bytes = typeof preimage === "string" ? encodeUtf8(preimage) : preimage;
+  return toHex(sha256Hash(bytes));
+}
+function effectiveValue(amount, createdAtMs, nowMs, bpsPerDay) {
+  if (createdAtMs === void 0 || createdAtMs === null || !bpsPerDay) {
+    return amount;
+  }
+  const elapsed = nowMs - createdAtMs;
+  const days = elapsed > 0 ? BigInt(Math.floor(elapsed / DAY_MS)) : 0n;
+  if (days === 0n) return amount;
+  const sats = parseAmount(amount);
+  const scaled = sats * 10000n - sats * BigInt(bpsPerDay) * days;
+  if (scaled <= 0n) return "0.00000000";
+  return formatAmount(scaled / 10000n);
+}
+function spendableUtxos(utxos, nowMs = Date.now()) {
+  return utxos.filter(
+    (u) => u.locked_until === void 0 || u.locked_until === null || u.locked_until <= nowMs
+  );
+}
 
 // src/wallet.ts
 var PmsWallet = class _PmsWallet {
@@ -213,17 +346,57 @@ var PmsWallet = class _PmsWallet {
 function isValidMnemonic(mnemonic) {
   return validateMnemonic(mnemonic.trim().toLowerCase(), wordlist);
 }
+function makeUnlock(signers, txHashHex, opts) {
+  if (signers.length === 0) {
+    throw new Error("makeUnlock: at least one signer is required");
+  }
+  const msg = encodeUtf8(txHashHex);
+  const sign = (w) => toBase64(fromHex(w.sign(msg)));
+  const [primary, ...rest] = signers;
+  const unlock = {
+    pubkey_hex: primary.publicKeyHex,
+    signature_b64: sign(primary)
+  };
+  if (rest.length > 0) {
+    unlock.cosigners = rest.map((w) => ({
+      pubkey_hex: w.publicKeyHex,
+      signature_b64: sign(w)
+    }));
+  }
+  if (opts?.preimageHex !== void 0) {
+    unlock.preimage_hex = opts.preimageHex;
+  }
+  return unlock;
+}
 
 // src/types.ts
 var DEFAULT_CONFIG = {
   networkId: "pms-mainnet",
-  protocolVersion: 1,
+  protocolVersion: 3,
   timeout: 3e4,
   seedNodes: [],
   enableRacing: true,
   retries: 2,
   perAttemptTimeoutMs: 4e3,
-  retryBaseDelayMs: 100
+  retryBaseDelayMs: 100,
+  // Vide par défaut : les méthodes admin lèvent une erreur explicite si
+  // appelées sans jeton (voir PmsClient.requireAdminToken).
+  adminToken: ""
+};
+var ErrorCode = {
+  /** En-tête d'authentification manquant (admin requis). */
+  MissingAuth: 1001,
+  /** Jeton d'authentification invalide. */
+  InvalidAuth: 1002,
+  /**
+   * Proposition de gouvernance rejetée (timelock non écoulé, proposition
+   * non en attente, ou identifiant inconnu). HTTP 409.
+   */
+  GovernanceRejected: 3071,
+  /** Émission native (mint) désactivée. HTTP 503. */
+  MintDisabled: 5031,
+  /** Erreur interne générique (dette : handler non encore migré). */
+  Internal: 9999
 };
 
 // src/crypto.ts
@@ -232,13 +405,13 @@ import { gcm } from "@noble/ciphers/aes.js";
 import { hkdf as hkdf2 } from "@noble/hashes/hkdf";
 import { sha256 as sha2563 } from "@noble/hashes/sha2";
 import { randomBytes, bytesToHex as bytesToHex2, hexToBytes as hexToBytes2 } from "@noble/hashes/utils";
-import { base64 } from "@scure/base";
+import { base64 as base642 } from "@scure/base";
 var SCHEME = "x25519+aes256gcm";
 var HKDF_SALT = new TextEncoder().encode("pms-dek-wrap");
 var HKDF_INFO_KEK = new TextEncoder().encode("kek-v1");
 var HKDF_INFO_KID = new TextEncoder().encode("kid-v1");
 function fromBase64(str) {
-  return base64.decode(str);
+  return base642.decode(str);
 }
 function sha256Hex(data) {
   return bytesToHex2(sha2563(data));
@@ -403,11 +576,222 @@ var PmsClient = class {
   }
   /**
    * Récupère les UTXOs d'une adresse.
+   *
+   * Depuis dag-pms v0.10.0, chaque UTXO expose aussi ses contraintes de
+   * dépense : `locked_until` (time-lock), `spend_condition`
+   * (MultiSig/HashLock) et `created_at` (base du demurrage). Utiliser
+   * [`spendableUtxos`] pour exclure les UTXOs encore verrouillés avant
+   * toute sélection de coins côté client.
    */
   async getUtxos(address) {
     const res = await this.fetch(`/v1/wallet/${address}/utxos`, void 0, { idempotent: true });
     return res.utxos ?? [];
   }
+  /**
+   * Dernier snapshot de preuve de réserves ancré (protocole 2.6,
+   * `GET /v1/reserves/latest`). 404 si aucun snapshot n'a encore été ancré.
+   */
+  async getLatestReserves() {
+    return this.fetch("/v1/reserves/latest", void 0, { idempotent: true });
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Gouvernance — lectures publiques (GET, sans authentification)
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Liste les propositions de gouvernance EN ATTENTE (statut `pending`).
+   *
+   * Lecture publique — aucun `adminToken` requis.
+   *
+   * @returns Le tableau des propositions en attente (vide si aucune).
+   *
+   * @example
+   * ```typescript
+   * const pending = await client.getGovernancePending();
+   * for (const p of pending) {
+   *     console.log(`${p.proposal_id} enacts after ${new Date(p.enact_after_ms)}`);
+   * }
+   * ```
+   */
+  async getGovernancePending() {
+    const res = await this.fetch(
+      "/v1/governance/pending",
+      void 0,
+      { idempotent: true }
+    );
+    return res.pending ?? [];
+  }
+  /**
+   * Liste les propositions de gouvernance TERMINÉES (enactées ou annulées).
+   *
+   * Lecture publique — aucun `adminToken` requis.
+   *
+   * @returns Le tableau de l'historique des propositions (vide si aucune).
+   */
+  async getGovernanceHistory() {
+    const res = await this.fetch(
+      "/v1/governance/history",
+      void 0,
+      { idempotent: true }
+    );
+    return res.history ?? [];
+  }
+  /**
+   * Liste les blocs de gouvernance ancrés dans le DAG (un par proposition,
+   * enactment, ou annulation).
+   *
+   * Lecture publique — aucun `adminToken` requis.
+   *
+   * @returns `{ count, blocks }` — le nombre et la liste des blocs.
+   */
+  async getGovernanceBlocks() {
+    return this.fetch(
+      "/v1/governance/blocks",
+      void 0,
+      { idempotent: true }
+    );
+  }
+  // ═══════════════════════════════════════════════════════════════════════
+  // Gouvernance — actions ADMIN (POST, requièrent adminToken)
+  // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * Soumet une proposition de gouvernance ancrée dans le DAG.
+   *
+   * Méthode ADMIN — requiert `adminToken` dans la config du client
+   * (envoyé en `Authorization: Bearer <adminToken>`). Lève une erreur
+   * explicite avant tout appel réseau si le jeton est absent.
+   *
+   * @param req.update - Mise à jour de config à proposer.
+   * @param req.tier - Palier de gouvernance (minuscules, voir
+   *   [`GovernanceTier`]).
+   * @param req.reason - Raison libre (optionnelle).
+   * @returns `{ status, proposal_id, block_id, tier, announced_at_ms,
+   *   enact_after_ms }`.
+   *
+   * @example
+   * ```typescript
+   * const res = await client.proposeGovernance({
+   *     update: { SetEmissionCorridor: { ceiling_bps: 1500, floor_bps: 0, target_bps: 1000, epoch_duration_sec: 86400 } },
+   *     tier: "constitution",
+   *     reason: "raise emission ceiling for Q3",
+   * });
+   * console.log(res.proposal_id, "enacts after", new Date(res.enact_after_ms));
+   * ```
+   */
+  async proposeGovernance(req) {
+    return this.fetchAdmin("proposeGovernance", "/admin/governance/propose", {
+      method: "POST",
+      body: JSON.stringify({
+        update: req.update,
+        tier: req.tier,
+        reason: req.reason ?? ""
+      })
+    });
+  }
+  /**
+   * Enacte une proposition de gouvernance dont le timelock est écoulé.
+   *
+   * Méthode ADMIN — requiert `adminToken`. Le moteur rejette (HTTP 409,
+   * code [`ErrorCode.GovernanceRejected`] = 3071) si le timelock n'est pas
+   * écoulé, si la proposition n'est pas en attente, ou si l'identifiant est
+   * inconnu.
+   *
+   * @param proposalId - Identifiant de la proposition à enacter.
+   * @param reason - Raison libre (optionnelle).
+   * @returns `{ status, proposal_id, block_id }`.
+   */
+  async enactProposal(proposalId, reason) {
+    return this.fetchAdmin(
+      "enactProposal",
+      `/admin/governance/enact/${encodeURIComponent(proposalId)}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ reason: reason ?? "" })
+      }
+    );
+  }
+  /**
+   * Annule une proposition de gouvernance en attente.
+   *
+   * Méthode ADMIN — requiert `adminToken`. Rejet HTTP 409 / code 3071 si la
+   * proposition n'est pas en attente ou si l'identifiant est inconnu.
+   *
+   * @param proposalId - Identifiant de la proposition à annuler.
+   * @param reason - Raison libre (optionnelle).
+   * @returns `{ status, proposal_id, block_id }`.
+   */
+  async cancelProposal(proposalId, reason) {
+    return this.fetchAdmin(
+      "cancelProposal",
+      `/admin/governance/cancel/${encodeURIComponent(proposalId)}`,
+      {
+        method: "POST",
+        body: JSON.stringify({ reason: reason ?? "" })
+      }
+    );
+  }
+  /**
+   * Applique (ou propose) une mise à jour de configuration.
+   *
+   * Méthode ADMIN — requiert `adminToken`. Le moteur distingue DEUX issues
+   * selon le sens du changement, et le SDK les EXPOSE explicitement via une
+   * union discriminée sur `applied` — un 202 n'est JAMAIS traité comme un
+   * succès appliqué :
+   * - **HTTP 200** (durcissement) → `{ applied: true, ... }` : la mise à
+   *   jour est instantanément en vigueur.
+   * - **HTTP 202** (assouplissement) → `{ applied: false, proposalId,
+   *   enactAfterMs, ... }` : la mise à jour est placée sous timelock de
+   *   gouvernance, PAS encore appliquée. Elle s'auto-enacte à l'expiration
+   *   du timelock, ou via [`enactProposal`].
+   *
+   * @param update - Mise à jour de config (envoyée brute, sans wrapper).
+   * @returns Une [`ConfigChangeResult`] discriminée sur `applied`.
+   *
+   * @example
+   * ```typescript
+   * const r = await client.setConfig({ SetMintEnabled: { enabled: false } });
+   * if (r.applied) {
+   *     console.log("appliqué instantanément:", r.updateApplied);
+   * } else {
+   *     console.log("timelocké, enact après", new Date(r.enactAfterMs));
+   * }
+   * ```
+   */
+  async setConfig(update) {
+    const { status, body } = await this.fetchAdminWithStatus(
+      "setConfig",
+      "/admin/config",
+      {
+        method: "POST",
+        body: JSON.stringify(update)
+      }
+    );
+    const isApplied = status === 200 && body.status !== "proposed";
+    if (isApplied) {
+      return {
+        applied: true,
+        status: "applied",
+        mode: body.mode ?? "",
+        updateApplied: body.update_applied ?? "",
+        tier: body.tier ?? "",
+        proposalId: body.proposal_id ?? "",
+        proposalBlockId: body.proposal_block_id ?? "",
+        enactBlockId: body.enact_block_id ?? "",
+        config: body.config ?? null
+      };
+    }
+    return {
+      applied: false,
+      status: "proposed",
+      mode: body.mode ?? "",
+      update: body.update ?? "",
+      tier: body.tier ?? "",
+      proposalId: body.proposal_id ?? "",
+      proposalBlockId: body.proposal_block_id ?? "",
+      announcedAtMs: body.announced_at_ms ?? 0,
+      enactAfterMs: body.enact_after_ms ?? 0,
+      message: body.message ?? ""
+    };
+  }
   // ═══════════════════════════════════════════════════════════════════════
   // Wallet API (Custodial — Server-Side)
   // ═══════════════════════════════════════════════════════════════════════
@@ -864,101 +1248,83 @@ var PmsClient = class {
   }
   /**
    * Envoie des tokens à une adresse.
-   * Construit automatiquement la transaction, la signe et la soumet.
+   *
+   * Flux aligné sur dag-pms v0.9.0 (single-writer + vérification des
+   * signatures de transaction par l'engine) :
+   * 1. `POST /v1/tx/prepare` — le serveur sélectionne les UTXOs et calcule
+   *    les frais.
+   * 2. Vérification défensive côté client : l'output destinataire demandé
+   *    existe bien, et le `tx_hash` retourné correspond au message canonique
+   *    recalculé localement (`txSigningMessage`). On ne signe JAMAIS un hash
+   *    opaque non vérifié.
+   * 3. Le wallet signe la TRANSACTION (unlocks) — pas le bloc. C'est le
+   *    serveur qui forge et signe le bloc (single-writer enforcement).
+   * 4. `POST /v1/wallet/tx/send` avec la TX signée + les clés X25519 des
+   *    destinataires pour le chiffrement du payload.
+   *
+   * @param params.to - Adresse destinataire (Bech32m de préférence)
+   * @param params.amount - Montant décimal (ex: "10.0")
+   * @param params.wallet - Wallet signataire (propriétaire des UTXOs)
+   * @param params.assetId - Asset ID optionnel (undefined = PMS natif)
+   * @returns `{id, status, block_id}` — id du bloc forgé par le serveur
    */
   async send(params) {
-    const { to, amount, wallet, memo: _memo } = params;
-    const utxos = await this.getUtxos(wallet.address);
-    if (utxos.length === 0) {
-      throw new Error("No UTXOs available");
-    }
-    const netConfig = await this.getNetworkConfig();
-    const baseFeeSats = parseAmount(netConfig.base_fee || "0");
-    const feeRateBps = BigInt(netConfig.fee_rate_bps || 0);
-    const amountSats = parseAmount(amount);
-    const variableFee = amountSats * feeRateBps / 10000n;
-    const fee = baseFeeSats + variableFee;
-    const totalNeeded = amountSats + fee;
-    let selectedSats = 0n;
-    const selectedUtxos = [];
-    for (const utxo of utxos) {
-      selectedUtxos.push(utxo);
-      selectedSats += parseAmount(utxo.amount || "0");
-      if (selectedSats >= totalNeeded) break;
+    const { to, amount, wallet, assetId } = params;
+    const prepareBody = {
+      from: wallet.address,
+      to,
+      amount
+    };
+    if (assetId !== void 0) {
+      prepareBody.asset_id = assetId;
     }
-    if (selectedSats < totalNeeded) {
+    const prepared = await this.prepareTx(prepareBody);
+    const { unsigned_tx, tx_hash } = prepared;
+    const requestedSats = parseAmount(amount);
+    const recipientOutput = unsigned_tx.outputs.find(
+      (o) => o.address === to && (o.asset_id ?? void 0) === (assetId ?? void 0) && parseAmount(o.amount) >= requestedSats
+    );
+    if (!recipientOutput) {
       throw new Error(
-        `Insufficient balance: have ${formatAmount(selectedSats)}, need ${formatAmount(totalNeeded)} (incl. fee ${formatAmount(fee)})`
+        `Prepared transaction does not contain the requested output (to=${to}, amount=${amount}, asset=${assetId ?? "PMS"}). Refusing to sign a transaction that does not pay the intended recipient.`
       );
     }
-    const outputs = [
-      { address: to, amount: formatAmount(amountSats) }
-    ];
-    if (fee > 0n) {
-      outputs.push({
-        address: netConfig.fee_recipient,
-        amount: formatAmount(fee)
-      });
-    }
-    const change = selectedSats - amountSats - fee;
-    if (change > 0n) {
-      outputs.push({ address: wallet.address, amount: formatAmount(change) });
+    const localHash = txSigningMessage(
+      this.config.networkId,
+      unsigned_tx.inputs,
+      unsigned_tx.outputs,
+      unsigned_tx.fee
+    );
+    if (localHash !== tx_hash) {
+      throw new Error(
+        `tx_hash mismatch: server returned ${tx_hash}, locally computed ${localHash}. Either the client networkId ("${this.config.networkId}") does not match the node's network, or the server response was tampered with. Refusing to sign.`
+      );
     }
-    const inputs = selectedUtxos.map((utxo) => ({
-      out: {
-        txid: utxo.outpoint.txid,
-        index: utxo.outpoint.index
-      }
-    }));
-    const txCanonical = {
-      inputs,
-      outputs,
-      fee: formatAmount(fee)
-    };
-    const txMessage = JSON.stringify(txCanonical);
-    const txSignatureHex = wallet.sign(encodeUtf8(txMessage));
-    const txSigBytes = fromHex(txSignatureHex);
-    const txSigB64 = btoa(String.fromCharCode(...txSigBytes));
-    const unlocks = inputs.map(() => ({
+    const sigHex = wallet.sign(encodeUtf8(tx_hash));
+    const sigB64 = toBase64(fromHex(sigHex));
+    const unlocks = unsigned_tx.inputs.map(() => ({
       pubkey_hex: wallet.publicKeyHex,
-      signature_b64: txSigB64
+      signature_b64: sigB64
     }));
     const tx = {
-      inputs,
-      outputs,
-      fee: formatAmount(fee),
+      inputs: unsigned_tx.inputs,
+      outputs: unsigned_tx.outputs,
+      fee: unsigned_tx.fee,
       unlocks
     };
-    const tips = await this.getTips();
-    const parents = tips.slice(0, 2);
-    const payload = { Plain: { TxUtxo: tx } };
-    const payloadJson = JSON.stringify(payload);
-    let nonce = 0;
-    let blockId = computeBlockId(parents, payloadJson, nonce);
-    const canonicalView = {
-      id: blockId,
-      parents,
-      payload_json: payloadJson,
-      nonce,
-      network_id: this.config.networkId,
-      protocol_version: this.config.protocolVersion,
-      signer_pk_hex: wallet.publicKeyHex
-    };
-    const messageToSign = JSON.stringify(canonicalView);
-    const signatureHex = wallet.sign(encodeUtf8(messageToSign));
-    const signatureBytes = fromHex(signatureHex);
-    const signatureB64 = btoa(String.fromCharCode(...signatureBytes));
-    const wireBlock = {
-      id: blockId,
-      parents,
-      payload_json: payloadJson,
-      nonce,
-      network_id: this.config.networkId,
-      protocol_version: this.config.protocolVersion,
-      signer_pk_hex: wallet.publicKeyHex,
-      signature_hex: signatureB64
-    };
-    return this.submitBlock(wireBlock);
+    const recipientsXpk = [wallet.x25519PublicKeyHex];
+    const toXpk = x25519FromAddress(to);
+    if (toXpk && !recipientsXpk.includes(toXpk)) {
+      recipientsXpk.push(toXpk);
+    }
+    const resp = await this.fetch(
+      "/v1/wallet/tx/send",
+      {
+        method: "POST",
+        body: JSON.stringify({ tx, recipients_xpk: recipientsXpk })
+      }
+    );
+    return { ...resp, block_id: resp.id };
   }
   // ═══════════════════════════════════════════════════════════════════════
   // Méthodes NFT Cube (Burn et Mint spécialisé)
@@ -966,7 +1332,15 @@ var PmsClient = class {
   /**
    * Transférer un NFT à un autre propriétaire.
    * Prend en charge le re-chiffrement des métadonnées via le coordinateur.
-   * 
+   *
+   * @deprecated Cette méthode soumet un WireBlock signé par la clé
+   * utilisateur via `/submit/block`. Depuis dag-pms v0.9.0, l'engine tourne
+   * en mode **single-writer** : tout bloc signé par une clé non-coordinateur
+   * est rejeté. Cette méthode ne fonctionne que sur un réseau SANS
+   * single-writer enforcement. Utilisez les flux server-side
+   * (`/v1/nft/transfer/prepare` + endpoints serveur) qui forgent et signent
+   * le bloc côté coordinateur.
+   *
    * @param params - Paramètres du transfert
    * @param params.tokenId - Identifiant du NFT
    * @param params.to - Adresse du nouveau propriétaire
@@ -1002,7 +1376,7 @@ var PmsClient = class {
     const payload = { Plain: { Nft: action } };
     const payloadJson = JSON.stringify(payload);
     const nonce = 0;
-    const blockId = computeBlockId(parents, payloadJson, nonce);
+    const blockId = computeBlockId(parents, payload, nonce);
     const canonicalView = {
       id: blockId,
       parents,
@@ -1034,10 +1408,17 @@ var PmsClient = class {
    * Seul le propriétaire du NFT peut le brûler.
    * Une fois brûlé, le NFT est supprimé définitivement.
    * 
-   * Pour les Cubes authentiques (avec signature Authority valide), 
+   * Pour les Cubes authentiques (avec signature Authority valide),
    * un remboursement est calculé selon la formule:
    * `(weight * size * density) / 10000` PMS
-   * 
+   *
+   * @deprecated Cette méthode poste un WireBlock signé par la clé
+   * utilisateur. Depuis dag-pms v0.9.0, l'engine tourne en mode
+   * **single-writer** : tout bloc signé par une clé non-coordinateur est
+   * rejeté. Cette méthode ne fonctionne que sur un réseau SANS single-writer
+   * enforcement. Le flux supporté est le burn server-side
+   * (`/v1/nft/burn-simple`), où le serveur forge et signe le bloc.
+   *
    * @param params - Paramètres du burn
    * @param params.tokenId - Identifiant du NFT à brûler
    * @param params.wallet - Wallet PMS du propriétaire (doit être l'owner actuel)
@@ -1071,7 +1452,7 @@ var PmsClient = class {
     };
     const payloadJson = JSON.stringify(payload);
     const nonce = 0;
-    const blockId = computeBlockId(parents, payloadJson, nonce);
+    const blockId = computeBlockId(parents, payload, nonce);
     const canonicalView = {
       id: blockId,
       parents,
@@ -1103,7 +1484,14 @@ var PmsClient = class {
   }
   /**
    * Brûle (détruit) plusieurs NFTs en une seule transaction.
-   * 
+   *
+   * @deprecated Cette méthode poste un WireBlock signé par la clé
+   * utilisateur. Depuis dag-pms v0.9.0, l'engine tourne en mode
+   * **single-writer** : tout bloc signé par une clé non-coordinateur est
+   * rejeté. Cette méthode ne fonctionne que sur un réseau SANS single-writer
+   * enforcement. Le flux supporté est le burn server-side
+   * (`/v1/nft/burn-simple`), où le serveur forge et signe le bloc.
+   *
    * @param params - Paramètres du batch burn
    * @param params.tokenIds - Liste des Identifiants des NFTs à brûler
    * @param params.wallet - Wallet PMS du propriétaire
@@ -1128,7 +1516,7 @@ var PmsClient = class {
     };
     const payloadJson = JSON.stringify(payload);
     const nonce = 0;
-    const blockId = computeBlockId(parents, payloadJson, nonce);
+    const blockId = computeBlockId(parents, payload, nonce);
     const canonicalView = {
       id: blockId,
       parents,
@@ -1227,6 +1615,62 @@ var PmsClient = class {
   // ═══════════════════════════════════════════════════════════════════════
   // Helper HTTP
   // ═══════════════════════════════════════════════════════════════════════
+  /**
+   * @internal
+   * Garantit qu'un `adminToken` est configuré avant un appel admin.
+   * Lève une erreur claire (sans appel réseau) sinon.
+   */
+  requireAdminToken(method) {
+    const token = this.config.adminToken;
+    if (!token || token.trim() === "") {
+      throw new Error(
+        `PmsClient.${method}() requires an admin token. Set it via new PmsClient({ ..., adminToken: '<token>' }). Admin methods send it as 'Authorization: Bearer <adminToken>'. Public reads (getGovernancePending/History/Blocks) do NOT need it.`
+      );
+    }
+    return token;
+  }
+  /**
+   * @internal
+   * Effectue un appel admin authentifié (en-tête `Authorization: Bearer`).
+   *
+   * Les écritures admin ne sont PAS idempotentes — pas de retry automatique
+   * (single-attempt via la branche non-idempotente de `fetchUrl`). L'auth est
+   * injectée par appel (pas dans le bloc d'en-têtes partagé de `fetchOnce`)
+   * pour éviter de fuiter le jeton admin vers des nœuds découverts/seeds lors
+   * du racing — cf. `submitBlockRacing`. `method` ne sert qu'au libellé de
+   * l'erreur "jeton manquant".
+   */
+  async fetchAdmin(method, path, init) {
+    return this.fetchUrl(this.config.nodeUrl, path, this.withAdminAuth(method, init));
+  }
+  /**
+   * @internal
+   * Variante d'appel admin qui expose le STATUT HTTP en plus du corps parsé.
+   * Nécessaire pour [`setConfig`], qui doit distinguer 200 (applied) de 202
+   * (proposed) — deux corps de réponse différents pour deux issues. Délègue à
+   * la même primitive `fetchOnceWithStatus` que tous les autres appels, donc
+   * hérite du merge de signal et du tagging d'abort sans duplication.
+   */
+  async fetchAdminWithStatus(method, path, init) {
+    const url = `${this.config.nodeUrl.replace(/\/$/, "")}/${path.replace(/^\//, "")}`;
+    const auth = this.withAdminAuth(method, init);
+    return this.fetchOnceWithStatus(url, auth, this.config.timeout, auth.signal ?? void 0);
+  }
+  /**
+   * @internal
+   * Vérifie la présence du jeton admin (sinon erreur claire, sans réseau) et
+   * injecte l'en-tête `Authorization: Bearer <token>` dans un RequestInit.
+   */
+  withAdminAuth(method, init) {
+    const token = this.requireAdminToken(method);
+    return {
+      ...init,
+      headers: {
+        ...init?.headers,
+        "Authorization": `Bearer ${token}`
+      }
+    };
+  }
   async fetch(path, init, opts) {
     return this.fetchUrl(this.config.nodeUrl, path, init, opts);
   }
@@ -1234,8 +1678,26 @@ var PmsClient = class {
    * Single-attempt HTTP request. Throws a tagged error on transient conditions
    * (network failure, per-attempt abort, 5xx) so the retry loop can decide
    * whether to retry. 4xx and other non-2xx are thrown as fatal HttpError.
+   *
+   * Thin wrapper over `fetchOnceWithStatus` that discards the HTTP status —
+   * every caller that only needs the parsed body goes through here.
    */
   async fetchOnce(url, init, attemptTimeoutMs, outerSignal) {
+    return (await this.fetchOnceWithStatus(url, init, attemptTimeoutMs, outerSignal)).body;
+  }
+  /**
+   * Single-attempt HTTP request returning BOTH the numeric HTTP status and the
+   * parsed body. The shared fetch primitive: applies the default headers
+   * (`Content-Type`, public `X-API-Key`), merges the caller's signal with the
+   * per-attempt timeout, tags per-attempt aborts as `PerAttemptTimeoutError`
+   * (so the retry loop can act on them), and constructs `HttpError` on non-2xx.
+   *
+   * NOTE: admin `Authorization: Bearer` is NOT injected here — it is added
+   * per-admin-call by `withAdminAuth` so the admin token never leaks to
+   * discovered/seed nodes during `submitBlockRacing`. Only the public,
+   * scoped `X-API-Key` is broadcast.
+   */
+  async fetchOnceWithStatus(url, init, attemptTimeoutMs, outerSignal) {
     const attemptController = new AbortController();
     const attemptTimer = setTimeout(() => attemptController.abort(), attemptTimeoutMs);
     const signal = mergeSignalsAny(attemptController.signal, outerSignal);
@@ -1254,14 +1716,14 @@ var PmsClient = class {
       if (!res.ok) {
         const text2 = await res.text().catch(() => "");
         const retryAfter = res.headers?.get?.("Retry-After") ?? null;
-        throw new HttpError(res.status, `HTTP ${res.status} (${url}): ${text2}`, retryAfter);
+        throw new HttpError(res.status, `HTTP ${res.status} (${url}): ${text2}`, retryAfter, text2);
       }
       const text = await res.text();
       if (!text) {
-        return {};
+        return { status: res.status, body: {} };
       }
       try {
-        return JSON.parse(text);
+        return { status: res.status, body: JSON.parse(text) };
       } catch {
         throw new Error(`Invalid JSON response: ${text.substring(0, 50)}...`);
       }
@@ -1324,11 +1786,30 @@ var PmsClient = class {
 var HttpError = class extends Error {
   status;
   retryAfter;
-  constructor(status, message, retryAfter) {
+  /** Raw response body text (may be empty). */
+  body;
+  /** Stable numeric error code parsed from `{code,message}`, if present. */
+  code;
+  /** Engine-provided message from `{code,message}`, if present. */
+  engineMessage;
+  constructor(status, message, retryAfter, body = "") {
     super(message);
     this.name = "HttpError";
     this.status = status;
     this.retryAfter = retryAfter;
+    this.body = body;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        if (parsed && typeof parsed === "object" && typeof parsed.code === "number") {
+          this.code = parsed.code;
+          if (typeof parsed.message === "string") {
+            this.engineMessage = parsed.message;
+          }
+        }
+      } catch {
+      }
+    }
   }
 };
 var PerAttemptTimeoutError = class extends Error {
@@ -1396,12 +1877,21 @@ function mergeAbortSignals(a, b) {
   return controller.signal;
 }
 export {
+  DAY_MS,
+  ErrorCode,
+  HttpError,
   PmsClient,
   PmsWallet,
   decryptPayload,
+  effectiveValue,
   formatAmount,
   fromHex,
+  hashlockHash,
   isValidMnemonic,
+  makeUnlock,
+  multisigAddress,
   parseAmount,
-  toHex
+  spendableUtxos,
+  toHex,
+  txSigningMessage
 };