@empereur-rouge/pms-sdk 0.3.8 → 0.7.1

package/dist/index.d.cts

@@ -1,118 +1,3 @@
-/**
- * PmsWallet - Wallet pour le réseau PMS.
- *
- * Supporte:
- * - Génération de wallet avec mnémonique 24 mots (BIP39)
- * - Import depuis clé privée
- * - Signature de messages
- * - Export de la phrase mnémonique
- *
- * @example
- * ```typescript
- * // Générer un nouveau wallet
- * const wallet = PmsWallet.generate();
- * console.log(wallet.mnemonic); // 24 mots
- *
- * // Restaurer depuis mnemonic
- * const wallet2 = PmsWallet.fromMnemonic("word1 word2 ...");
- *
- * // Signer un message
- * const sig = await wallet.sign(messageBytes);
- * ```
- */
-/**
- * Wallet PMS avec gestion des clés cryptographiques.
- */
-declare class PmsWallet {
-    /** Clé privée secp256k1 (32 bytes) - pour signatures */
-    private readonly _privateKey;
-    /** Clé publique secp256k1 non compressée (65 bytes: 04 + x + y) */
-    private readonly _publicKey;
-    /** Clé privée X25519 (32 bytes) - pour chiffrement */
-    private readonly _x25519PrivateKey;
-    /** Clé publique X25519 (32 bytes) */
-    private readonly _x25519PublicKey;
-    /** Phrase mnémonique (24 mots) si générée/importée */
-    private readonly _mnemonic?;
-    /**
-     * Constructeur privé - utiliser les méthodes statiques.
-     */
-    private constructor();
-    /**
-     * Génère un nouveau wallet avec une phrase de 24 mots.
-     */
-    static generate(): PmsWallet;
-    /**
-     * Crée un wallet à partir d'une phrase mnémonique (12, 15, 18, 21 ou 24 mots).
-     * @throws Error si la phrase est invalide
-     */
-    static fromMnemonic(mnemonic: string): PmsWallet;
-    /**
-     * Crée un wallet à partir d'une clé privée hexadécimale.
-     */
-    static fromPrivateKey(privateKeyHex: string): PmsWallet;
-    /**
-     * Crée un wallet à partir d'une seed (32 bytes).
-     */
-    static fromSeed(seed: Uint8Array): PmsWallet;
-    /**
-     * Adresse du wallet (clé publique hex).
-     * Format: "04" + 64 bytes hex = 130 caractères
-     */
-    get address(): string;
-    /**
-     * Clé publique en bytes.
-     */
-    get publicKey(): Uint8Array;
-    /**
-     * Clé publique en hex.
-     */
-    get publicKeyHex(): string;
-    /**
-     * Phrase mnémonique (si disponible).
-     * @returns undefined si le wallet a été créé depuis une clé privée
-     */
-    get mnemonic(): string | undefined;
-    /**
-     * Clé publique X25519 en hex (pour chiffrement).
-     * Utiliser cette clé comme destinataire pour encryptPayload().
-     */
-    get x25519PublicKeyHex(): string;
-    /**
-     * Clé privée X25519 en hex (pour déchiffrement).
-     * ⚠️ Ne pas exposer cette clé publiquement !
-     */
-    get x25519PrivateKeyHex(): string;
-    /**
-     * Signe un message avec la clé privée.
-     * @param message - Message à signer (sera hashé avec SHA256)
-     * @returns Signature DER encodée en hex
-     */
-    sign(message: Uint8Array): string;
-    /**
-     * Signe un message déjà hashé.
-     * @param hash - Hash 32 bytes du message
-     * @returns Signature DER encodée en hex
-     */
-    signHash(hash: Uint8Array): string;
-    /**
-     * Exporte la clé privée en hex.
-     * ⚠️ À utiliser avec précaution !
-     */
-    exportPrivateKey(): string;
-    /**
-     * Vérifie une signature.
-     * @param message - Message original
-     * @param signature - Signature DER hex
-     * @param publicKeyHex - Clé publique hex du signataire
-     */
-    static verify(message: Uint8Array, signature: string, publicKeyHex: string): boolean;
-}
-/**
- * Vérifie si une phrase mnémonique est valide.
- */
-declare function isValidMnemonic(mnemonic: string): boolean;
-
 /**
  * Types TypeScript pour le SDK PMS.
  *
@@ -125,6 +10,27 @@ interface OutputRef {
     /** Index de l'output dans la transaction */
     index: number;
 }
+/**
+ * Condition de déverrouillage d'un output (protocole 2.2, dag-pms v0.10.0).
+ *
+ * Sérialisation serde externally-tagged :
+ * - variant unit → string JSON `"PubKey"` ;
+ * - variants à données → `{ "MultiSig": {...} }` / `{ "HashLock": {...} }`.
+ *
+ * La condition est figée À LA CRÉATION de l'output. Au spend, le validateur
+ * lit la condition depuis l'UTXO STOCKÉ (jamais depuis les données du
+ * dépensier).
+ */
+type SpendCondition = "PubKey" | {
+    MultiSig: {
+        m: number;
+        pubkeys: string[];
+    };
+} | {
+    HashLock: {
+        hash_hex: string;
+    };
+};
 /** Output de transaction (UTXO) */
 interface TxOutput {
     /** Adresse du destinataire */
@@ -133,6 +39,26 @@ interface TxOutput {
     amount: string;
     /** Asset ID (undefined/null = PMS natif, "edenite" = token custom) */
     asset_id?: string;
+    /**
+     * Time-lock natif (protocole 2.1) : timestamp UNIX **millisecondes**
+     * avant lequel l'output est indépensable. Absent = dépensable
+     * immédiatement. Entre dans le message signé quand présent.
+     */
+    locked_until?: number;
+    /**
+     * Condition de déverrouillage (protocole 2.2). Absent = PubKey simple
+     * (binding pubkey↔adresse classique). Pour MultiSig, `address` DOIT être
+     * l'adresse canonique de la policy — voir [`multisigAddress`].
+     */
+    spend_condition?: SpendCondition;
+    /**
+     * Timestamp de création de l'UTXO (UNIX ms), **assigné par le moteur**
+     * au persist — base du calcul de demurrage (protocole 2.5).
+     * NE JAMAIS poser ce champ côté client : toute valeur fournie est
+     * écrasée par le serveur, et le poser modifie inutilement le message
+     * signé. Présent en LECTURE seulement (GET /v1/wallet/{addr}/utxos).
+     */
+    created_at?: number;
 }
 /** UTXO complet avec sa référence */
 interface Utxo extends TxOutput {
@@ -144,12 +70,31 @@ interface TxInput {
     /** Référence à l'UTXO dépensé */
     out: OutputRef;
 }
+/** Signature additionnelle d'un cosignataire MultiSig (protocole 2.2). */
+interface Cosigner {
+    /** Clé publique hex (membre du set MultiSig) */
+    pubkey_hex: string;
+    /** Signature DER base64 du MÊME message canonique que l'unlock principal */
+    signature_b64: string;
+}
 /** Unlock (signature pour un input) */
 interface Unlock {
     /** Clé publique hex */
     pubkey_hex: string;
     /** Signature base64 */
     signature_b64: string;
+    /**
+     * Cosignatures pour un input sous condition MultiSig : la paire
+     * principale compte comme première signature, les cosigners complètent
+     * jusqu'à M. Chaque signature porte sur le même message canonique.
+     * Les unlocks n'entrent PAS dans le message signé.
+     */
+    cosigners?: Cosigner[];
+    /**
+     * Préimage hex pour un input sous condition HashLock :
+     * `sha256(bytes(preimage_hex)) == hash_hex` de la condition.
+     */
+    preimage_hex?: string;
 }
 /** Transaction UTXO */
 interface TxUtxo {
@@ -168,8 +113,14 @@ type PayloadEnvelope = {
 } | {
     Encrypted: EncryptedPayload;
 };
-/** Payload en clair */
-type PlainPayload = {
+/**
+ * Payload en clair.
+ *
+ * Sérialisation serde externally-tagged : variant unit → string JSON
+ * (`"Genesis"`), variant avec données → objet à clé unique
+ * (`{"TxUtxo": {...}}`).
+ */
+type PlainPayload = "Genesis" | {
     Mint: MintPayload;
 } | {
     TxUtxo: TxUtxo;
@@ -312,8 +263,35 @@ interface TokenMetadata {
     creator: string;
     /** Clé publique autorisée à mint ce token */
     mint_authority: string;
+    /**
+     * Demurrage opt-in (protocole 2.5) : décote en basis points par JOUR
+     * PLEIN écoulé depuis `created_at` de chaque UTXO. Absent/0 = pas de
+     * demurrage. Voir [`effectiveValue`] pour le calcul côté client.
+     */
+    demurrage_bps_per_day?: number;
+    /**
+     * Mint collatéralisé (protocole 2.3 v2, dag-pms v0.11.0) : adresse de
+     * réserve sur le même ledger. Chaque mint exige
+     * `(circulation + minté) × collateral_ratio_bps / 10000` couvert par
+     * les UTXOs de réserve ENCORE time-lockés à cette adresse.
+     */
+    collateral_address?: string;
+    /** Asset du collatéral (absent = natif du ledger). */
+    collateral_asset_id?: string;
+    /** Ratio de couverture en bps (10000 = 1:1). Présent ssi collateral_address. */
+    collateral_ratio_bps?: number;
 }
-/** Mise à jour de configuration */
+/**
+ * Mise à jour de configuration.
+ *
+ * Sérialisation serde externally-tagged côté moteur : chaque variant est un
+ * objet à clé unique (`{ "SetFeeRate": { "bps": 300 } }`). Les noms de
+ * variants sont en PascalCase, les champs en snake_case.
+ *
+ * Selon le sens du changement (durcissement vs assouplissement), le moteur
+ * applique la mise à jour instantanément (200) ou la place sous timelock de
+ * gouvernance (202) — voir [`PmsClient.setConfig`] / [`ConfigChangeResult`].
+ */
 type ConfigUpdate = {
     SetFeeRate: {
         bps: number;
@@ -334,7 +312,156 @@ type ConfigUpdate = {
     SetMintEnabled: {
         enabled: boolean;
     };
+} | {
+    /**
+     * Couloir d'émission (plan §3, dag-pms v0.18.0). Tous les champs
+     * sont REQUIS et en basis points (sauf la durée d'epoch en
+     * secondes). Élargir le couloir (hausser le plafond / la cible) est
+     * un assouplissement → timelocké ; le resserrer est un durcissement
+     * → instantané.
+     */
+    SetEmissionCorridor: {
+        /** Plafond d'émission par epoch (bps). */
+        ceiling_bps: number;
+        /** Plancher d'émission par epoch (bps). */
+        floor_bps: number;
+        /** Cible d'émission par epoch (bps). */
+        target_bps: number;
+        /** Durée d'une epoch d'émission (secondes). */
+        epoch_duration_sec: number;
+    };
 };
+/**
+ * Dernier snapshot de preuve de réserves ancré (protocole 2.6).
+ * `GET /v1/reserves/latest` — le bloc DAG `block_id` est la preuve signée
+ * Coordinator ; `state_root` = SHA-256 de l'état UTXO complet.
+ */
+interface ReservesLatest {
+    /** ID du bloc ReserveSnapshot ancré dans le DAG */
+    block_id: string;
+    /** Racine d'état SHA-256 (64 hex chars) du set UTXO */
+    state_root: string;
+    /** Supply totale par asset : [asset_id | null (natif), montant] */
+    total_supply: Array<[string | null, string]>;
+    /** Nombre d'UTXOs couverts par le root */
+    utxo_count: number;
+    /** Horodatage du calcul (UNIX ms) */
+    computed_at_ms: number;
+}
+/**
+ * Palier de gouvernance d'une proposition.
+ *
+ * Casse en **minuscules** (`"operator" | "policy" | "constitution"`), cohérente
+ * entre requêtes et réponses depuis dag-pms v0.18.1 : le moteur accepte le
+ * `tier` en minuscules dans la REQUÊTE `propose` (en plus du PascalCase
+ * historique) et le renvoie toujours en minuscules dans les RÉPONSES (propose
+ * result, pending, history, blocks) via `GovernanceTier::as_str()`. Un `tier`
+ * reçu peut donc être comparé directement (`proposal.tier === "operator"`) sans
+ * normalisation de casse.
+ */
+type GovernanceTier = "operator" | "policy" | "constitution";
+/**
+ * Statut d'une proposition de gouvernance (forme renvoyée par les lectures
+ * publiques, en minuscules).
+ */
+type GovernanceStatus = "pending" | "enacted" | "cancelled";
+/**
+ * Proposition de gouvernance ancrée dans le DAG.
+ *
+ * Retournée par [`PmsClient.getGovernancePending`] et
+ * [`PmsClient.getGovernanceHistory`]. Le champ `update` est le `ConfigUpdate`
+ * brut (externally-tagged) que la proposition appliquera à son enactment.
+ */
+interface GovernanceProposal {
+    /** Identifiant de la proposition (SHA-256 hex). */
+    proposal_id: string;
+    /** Palier de gouvernance. */
+    tier: GovernanceTier;
+    /** Statut courant. */
+    status: GovernanceStatus;
+    /** Raison libre fournie par le proposant (peut être vide). */
+    reason: string;
+    /** Horodatage de l'annonce (UNIX ms). */
+    announced_at_ms: number;
+    /** Horodatage à partir duquel l'enactment est autorisé (UNIX ms). */
+    enact_after_ms: number;
+    /** Mise à jour de config à appliquer. */
+    update: ConfigUpdate;
+    /** ID du bloc DAG de la proposition. */
+    proposal_block_id: string;
+    /** ID du bloc d'enactment (null tant que non-enacté). */
+    enact_block_id: string | null;
+    /** ID du bloc d'annulation (null tant que non-annulé). */
+    cancel_block_id: string | null;
+}
+/**
+ * Un bloc de gouvernance individuel du DAG (proposition, enactment, ou
+ * annulation), tel que retourné par [`PmsClient.getGovernanceBlocks`].
+ */
+interface GovernanceBlock {
+    /** ID du bloc DAG. */
+    block_id: string;
+    /** Nature du bloc. */
+    kind: "proposal" | "enact" | "cancel";
+    /** Identifiant de la proposition à laquelle ce bloc se rattache. */
+    proposal_id: string;
+    /** Palier de gouvernance. */
+    tier: GovernanceTier;
+    /** Statut de la proposition au moment du snapshot. */
+    status: GovernanceStatus;
+    /** Mise à jour de config portée par la proposition. */
+    update: ConfigUpdate;
+    /** Raison libre. */
+    reason: string;
+    /** Horodatage de l'annonce (UNIX ms). */
+    announced_at_ms: number;
+    /** Horodatage d'enactment autorisé (UNIX ms). */
+    enact_after_ms: number;
+}
+/**
+ * Requête de proposition de gouvernance
+ * ([`PmsClient.proposeGovernance`]).
+ */
+interface ProposeGovernanceRequest {
+    /** Mise à jour de config à proposer. */
+    update: ConfigUpdate;
+    /** Palier (minuscules — voir [`GovernanceTier`]). */
+    tier: GovernanceTier;
+    /** Raison libre (optionnelle, défaut côté moteur = chaîne vide). */
+    reason?: string;
+}
+/**
+ * Résultat de POST /admin/governance/propose.
+ *
+ * Le `tier` est renvoyé par le moteur en minuscules (voir [`GovernanceTier`]).
+ * La même casse est utilisée pour l'envoi de la requête.
+ */
+interface ProposeResult {
+    /** Statut de l'appel (ex: "ok"). */
+    status: string;
+    /** Identifiant de la proposition créée (SHA-256 hex). */
+    proposal_id: string;
+    /** ID du bloc DAG de la proposition. */
+    block_id: string;
+    /** Palier assigné. */
+    tier: GovernanceTier;
+    /** Horodatage de l'annonce (UNIX ms). */
+    announced_at_ms: number;
+    /** Horodatage à partir duquel l'enactment est autorisé (UNIX ms). */
+    enact_after_ms: number;
+}
+/**
+ * Résultat d'un enactment ou d'une annulation de proposition
+ * (POST /admin/governance/enact/{id} et /cancel/{id}).
+ */
+interface GovernanceActionResult {
+    /** Statut de l'appel (ex: "ok"). */
+    status: string;
+    /** Identifiant de la proposition concernée. */
+    proposal_id: string;
+    /** ID du bloc DAG d'enactment/annulation. */
+    block_id: string;
+}
 /** Bloc du DAG */
 interface Block {
     /** ID unique du bloc (hash) */
@@ -440,13 +567,24 @@ interface UtxoDetail {
 interface PrepareTxResponse {
     /** Transaction non-signée (unlocks vide) */
     unsigned_tx: TxUtxo;
-    /** Hash SHA256 du message à signer (hex) */
+    /** Hash SHA256 du message canonique à signer (hex) */
     tx_hash: string;
-    /** Frais calculés */
+    /** Frais de gas PMS calculés */
     fee: string;
+    /** Frais de transfert smart contract ("0" si aucun contrat actif) */
+    transfer_fee: string;
     /** Détail des UTXOs sélectionnés */
     inputs_detail: UtxoDetail[];
 }
+/** Réponse de POST /v1/wallet/tx/send */
+interface SendTxResponse {
+    /** ID du bloc forgé et signé par le serveur (single-writer) */
+    id: string;
+    /** Statut: "inserted" (201) ou "duplicate" (409) */
+    status: string;
+    /** Alias de `id` pour compatibilité avec l'ancien SubmitResponse */
+    block_id: string;
+}
 /** Réponse de getNft - informations complètes d'un NFT */
 interface NftResponse {
     /** Token ID du NFT */
@@ -518,11 +656,24 @@ interface PmsClientConfig {
      * Exemple: "pk_live_abc123..." ou "pk_test_xyz789..."
      */
     apiKey: string;
+    /**
+     * Jeton d'administration (optionnel).
+     *
+     * Requis UNIQUEMENT pour les méthodes admin (gouvernance propose/enact/
+     * cancel, [`PmsClient.setConfig`]). Envoyé dans l'en-tête
+     * `Authorization: Bearer <adminToken>`. Les lectures publiques (y compris
+     * de gouvernance) n'en ont PAS besoin. Si une méthode admin est appelée
+     * sans `adminToken`, le client lève une erreur explicite avant tout appel
+     * réseau.
+     *
+     * NE JAMAIS committer ce jeton ni l'exposer côté navigateur.
+     */
+    adminToken?: string;
     /** URLs des noeuds seeds (optionnel, pour racing et fallback) */
     seedNodes?: string[];
     /** ID du réseau (défaut: "pms-mainnet") */
     networkId?: string;
-    /** Version du protocole (défaut: 1) */
+    /** Version du protocole P2P (défaut: 3 — dag-pms v0.10.0) */
     protocolVersion?: number;
     /** Timeout en ms (défaut: 30000) */
     timeout?: number;
@@ -654,6 +805,238 @@ interface RuntimeConfig {
 interface NodePublicConfig extends RuntimeConfig {
     fee_recipient: string;
 }
+/**
+ * Résultat de POST /admin/config — union discriminée sur `applied`.
+ *
+ * Le moteur distingue deux issues selon le SENS de la mise à jour :
+ * - **durcissement** (tighten, ex: réduire un plafond, désactiver le mint) :
+ *   appliqué INSTANTANÉMENT — HTTP 200, `status: "applied"`. → `applied: true`.
+ * - **assouplissement** (loosen, ex: hausser un plafond, réactiver le mint) :
+ *   placé sous TIMELOCK de gouvernance, PAS encore appliqué — HTTP 202,
+ *   `status: "proposed"`. → `applied: false`. Le changement s'auto-enacte
+ *   quand le timelock expire, ou via [`PmsClient.enactProposal`].
+ *
+ * Le SDK NE traite JAMAIS un 202 comme un succès appliqué : inspectez
+ * `result.applied` avant de supposer que le changement est en vigueur.
+ */
+type ConfigChangeResult = ConfigChangeApplied | ConfigChangeProposed;
+/** Variante "appliqué instantanément" (HTTP 200). */
+interface ConfigChangeApplied {
+    /** Discriminant : le changement est en vigueur. */
+    applied: true;
+    /** Statut moteur (toujours "applied" pour cette variante). */
+    status: "applied";
+    /** Mode lisible (ex: "instant (tighten)"). */
+    mode: string;
+    /** Description lisible de la mise à jour appliquée. */
+    updateApplied: string;
+    /** Palier de gouvernance déduit (minuscules côté moteur). */
+    tier: string;
+    /** Identifiant de la proposition implicite. */
+    proposalId: string;
+    /** ID du bloc DAG de proposition. */
+    proposalBlockId: string;
+    /** ID du bloc DAG d'enactment (immédiat). */
+    enactBlockId: string;
+    /** Config runtime résultante (null si lecture impossible côté moteur). */
+    config: RuntimeConfig | null;
+}
+/** Variante "proposé, timelocké" (HTTP 202). */
+interface ConfigChangeProposed {
+    /** Discriminant : le changement n'est PAS encore en vigueur. */
+    applied: false;
+    /** Statut moteur (toujours "proposed" pour cette variante). */
+    status: "proposed";
+    /** Mode lisible (ex: "timelocked (loosen)"). */
+    mode: string;
+    /** Description lisible de la mise à jour proposée. */
+    update: string;
+    /** Palier de gouvernance déduit (minuscules côté moteur). */
+    tier: string;
+    /** Identifiant de la proposition créée. */
+    proposalId: string;
+    /** ID du bloc DAG de proposition. */
+    proposalBlockId: string;
+    /** Horodatage de l'annonce (UNIX ms). */
+    announcedAtMs: number;
+    /** Horodatage à partir duquel l'enactment est autorisé (UNIX ms). */
+    enactAfterMs: number;
+    /** Message explicatif du moteur. */
+    message: string;
+}
+/**
+ * Codes d'erreur numériques stables renvoyés par le moteur PMS.
+ *
+ * Le moteur renvoie ses erreurs au format JSON `{"code": NNNN, "message":
+ * "..."}`. Les clients DOIVENT brancher sur le `code` numérique (stable) et
+ * non sur le `message` (susceptible de changer de formulation).
+ *
+ * Tranches : `1xxx` auth/authz, `2xxx` validation requête, `3xxx`
+ * état/business, `4xxx` crypto/sécurité, `5xxx` ressource/quota, `9xxx`
+ * interne.
+ *
+ * Le code est exposé sur l'erreur levée via la propriété `code` (voir
+ * [`PmsError`]).
+ */
+declare const ErrorCode: {
+    /** En-tête d'authentification manquant (admin requis). */
+    readonly MissingAuth: 1001;
+    /** Jeton d'authentification invalide. */
+    readonly InvalidAuth: 1002;
+    /**
+     * Proposition de gouvernance rejetée (timelock non écoulé, proposition
+     * non en attente, ou identifiant inconnu). HTTP 409.
+     */
+    readonly GovernanceRejected: 3071;
+    /** Émission native (mint) désactivée. HTTP 503. */
+    readonly MintDisabled: 5031;
+    /** Erreur interne générique (dette : handler non encore migré). */
+    readonly Internal: 9999;
+};
+/** Valeur numérique d'un code d'erreur ([`ErrorCode`]). */
+type ErrorCodeValue = (typeof ErrorCode)[keyof typeof ErrorCode];
+
+/**
+ * PmsWallet - Wallet pour le réseau PMS.
+ *
+ * Supporte:
+ * - Génération de wallet avec mnémonique 24 mots (BIP39)
+ * - Import depuis clé privée
+ * - Signature de messages
+ * - Export de la phrase mnémonique
+ *
+ * @example
+ * ```typescript
+ * // Générer un nouveau wallet
+ * const wallet = PmsWallet.generate();
+ * console.log(wallet.mnemonic); // 24 mots
+ *
+ * // Restaurer depuis mnemonic
+ * const wallet2 = PmsWallet.fromMnemonic("word1 word2 ...");
+ *
+ * // Signer un message
+ * const sig = await wallet.sign(messageBytes);
+ * ```
+ */
+
+/**
+ * Wallet PMS avec gestion des clés cryptographiques.
+ */
+declare class PmsWallet {
+    /** Clé privée secp256k1 (32 bytes) - pour signatures */
+    private readonly _privateKey;
+    /** Clé publique secp256k1 non compressée (65 bytes: 04 + x + y) */
+    private readonly _publicKey;
+    /** Clé privée X25519 (32 bytes) - pour chiffrement */
+    private readonly _x25519PrivateKey;
+    /** Clé publique X25519 (32 bytes) */
+    private readonly _x25519PublicKey;
+    /** Phrase mnémonique (24 mots) si générée/importée */
+    private readonly _mnemonic?;
+    /**
+     * Constructeur privé - utiliser les méthodes statiques.
+     */
+    private constructor();
+    /**
+     * Génère un nouveau wallet avec une phrase de 24 mots.
+     */
+    static generate(): PmsWallet;
+    /**
+     * Crée un wallet à partir d'une phrase mnémonique (12, 15, 18, 21 ou 24 mots).
+     * @throws Error si la phrase est invalide
+     */
+    static fromMnemonic(mnemonic: string): PmsWallet;
+    /**
+     * Crée un wallet à partir d'une clé privée hexadécimale.
+     */
+    static fromPrivateKey(privateKeyHex: string): PmsWallet;
+    /**
+     * Crée un wallet à partir d'une seed (32 bytes).
+     */
+    static fromSeed(seed: Uint8Array): PmsWallet;
+    /**
+     * Adresse du wallet (clé publique hex).
+     * Format: "04" + 64 bytes hex = 130 caractères
+     */
+    get address(): string;
+    /**
+     * Clé publique en bytes.
+     */
+    get publicKey(): Uint8Array;
+    /**
+     * Clé publique en hex.
+     */
+    get publicKeyHex(): string;
+    /**
+     * Phrase mnémonique (si disponible).
+     * @returns undefined si le wallet a été créé depuis une clé privée
+     */
+    get mnemonic(): string | undefined;
+    /**
+     * Clé publique X25519 en hex (pour chiffrement).
+     * Utiliser cette clé comme destinataire pour encryptPayload().
+     */
+    get x25519PublicKeyHex(): string;
+    /**
+     * Clé privée X25519 en hex (pour déchiffrement).
+     * ⚠️ Ne pas exposer cette clé publiquement !
+     */
+    get x25519PrivateKeyHex(): string;
+    /**
+     * Signe un message avec la clé privée.
+     * @param message - Message à signer (sera hashé avec SHA256)
+     * @returns Signature DER encodée en hex
+     */
+    sign(message: Uint8Array): string;
+    /**
+     * Signe un message déjà hashé.
+     * @param hash - Hash 32 bytes du message
+     * @returns Signature DER encodée en hex
+     */
+    signHash(hash: Uint8Array): string;
+    /**
+     * Exporte la clé privée en hex.
+     * ⚠️ À utiliser avec précaution !
+     */
+    exportPrivateKey(): string;
+    /**
+     * Vérifie une signature.
+     * @param message - Message original
+     * @param signature - Signature DER hex
+     * @param publicKeyHex - Clé publique hex du signataire
+     */
+    static verify(message: Uint8Array, signature: string, publicKeyHex: string): boolean;
+}
+/**
+ * Vérifie si une phrase mnémonique est valide.
+ */
+declare function isValidMnemonic(mnemonic: string): boolean;
+/**
+ * Construit l'`Unlock` d'un input pour les conditions de dépense du
+ * protocole v0.10.0 (MultiSig / HashLock).
+ *
+ * - 1 signataire, pas d'options → unlock classique (PubKey / binding C-1).
+ * - Plusieurs signataires (MultiSig M-of-N) : le premier devient la paire
+ *   principale, les suivants des `cosigners` — chacun signe le MÊME message
+ *   canonique (`txSigningMessage`). Le quorum compte les clés DISTINCTES
+ *   membres du set de la condition.
+ * - `preimageHex` (HashLock) : révèle le secret tel que
+ *   `sha256(bytes(preimage)) == hash_hex` de la condition.
+ *
+ * @param signers - Wallets signataires (>= 1 ; ordre indifférent pour le quorum)
+ * @param txHashHex - Hash hex retourné par `txSigningMessage(...)`
+ * @param opts - `preimageHex` pour un input HashLock
+ *
+ * @example
+ * ```typescript
+ * const txHash = txSigningMessage(networkId, tx.inputs, tx.outputs, tx.fee);
+ * // dépense d'un UTXO MultiSig 2-of-3 :
+ * tx.unlocks = tx.inputs.map(() => makeUnlock([alice, carol], txHash));
+ * ```
+ */
+declare function makeUnlock(signers: PmsWallet[], txHashHex: string, opts?: {
+    preimageHex?: string;
+}): Unlock;
 
 /**
  * PmsClient - Client HTTP pour interagir avec un nœud PMS.
@@ -741,8 +1124,132 @@ declare class PmsClient {
     getToken(assetId: string): Promise<TokenMetadata>;
     /**
      * 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.
      */
     getUtxos(address: string): Promise<Utxo[]>;
+    /**
+     * Dernier snapshot de preuve de réserves ancré (protocole 2.6,
+     * `GET /v1/reserves/latest`). 404 si aucun snapshot n'a encore été ancré.
+     */
+    getLatestReserves(): Promise<ReservesLatest>;
+    /**
+     * 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)}`);
+     * }
+     * ```
+     */
+    getGovernancePending(): Promise<GovernanceProposal[]>;
+    /**
+     * 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).
+     */
+    getGovernanceHistory(): Promise<GovernanceProposal[]>;
+    /**
+     * 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.
+     */
+    getGovernanceBlocks(): Promise<{
+        count: number;
+        blocks: GovernanceBlock[];
+    }>;
+    /**
+     * 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));
+     * ```
+     */
+    proposeGovernance(req: ProposeGovernanceRequest): Promise<ProposeResult>;
+    /**
+     * 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 }`.
+     */
+    enactProposal(proposalId: string, reason?: string): Promise<GovernanceActionResult>;
+    /**
+     * 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 }`.
+     */
+    cancelProposal(proposalId: string, reason?: string): Promise<GovernanceActionResult>;
+    /**
+     * 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));
+     * }
+     * ```
+     */
+    setConfig(update: ConfigUpdate): Promise<ConfigChangeResult>;
     /**
      * Crée un nouveau wallet côté serveur (custodial).
      * Le serveur génère le wallet et retourne toutes les clés + adresse Bech32.
@@ -957,18 +1464,45 @@ declare class PmsClient {
     private refreshNodeList;
     /**
      * 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
      */
     send(params: {
         to: string;
         amount: string;
         wallet: PmsWallet;
+        assetId?: string;
         memo?: string;
-    }): Promise<SubmitResponse>;
+    }): Promise<SendTxResponse>;
     /**
      * 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
@@ -991,6 +1525,13 @@ declare class PmsClient {
      * 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)
@@ -1015,6 +1556,13 @@ declare class PmsClient {
     /**
      * 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
@@ -1049,15 +1597,101 @@ declare class PmsClient {
      * Utilise crypto.getRandomValues pour la sécurité cryptographique.
      */
     private generateRandomHex;
+    /**
+     * @internal
+     * Garantit qu'un `adminToken` est configuré avant un appel admin.
+     * Lève une erreur claire (sans appel réseau) sinon.
+     */
+    private requireAdminToken;
+    /**
+     * @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".
+     */
+    private fetchAdmin;
+    /**
+     * @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.
+     */
+    private fetchAdminWithStatus;
+    /**
+     * @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.
+     */
+    private withAdminAuth;
     private fetch;
     /**
      * 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.
      */
     private fetchOnce;
+    /**
+     * 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.
+     */
+    private fetchOnceWithStatus;
     private fetchUrl;
 }
+/**
+ * Error type for HTTP non-2xx responses.
+ *
+ * Carries the HTTP status + `Retry-After` header (for the retry loop) AND,
+ * when the engine returns its stable `{"code": NNNN, "message": "..."}` JSON
+ * body, the parsed numeric `code` and engine `message`. Consumers branch on
+ * the stable numeric `code` (see {@link ErrorCode}) rather than the message
+ * string:
+ *
+ * ```typescript
+ * import { ErrorCode } from "@empereur-rouge/pms-sdk";
+ * try {
+ *   await client.setConfig({ SetMintEnabled: { enabled: true } });
+ * } catch (e) {
+ *   if ((e as any).code === ErrorCode.GovernanceRejected) { ... }
+ * }
+ * ```
+ *
+ * Backward compatible: `.message` keeps the original `HTTP <status> (...)`
+ * format; `.code` is `undefined` when the body was not the `{code,message}`
+ * shape (e.g. plaintext, legacy `{"error":"..."}`).
+ */
+declare class HttpError extends Error {
+    readonly status: number;
+    readonly retryAfter: string | null;
+    /** Raw response body text (may be empty). */
+    readonly body: string;
+    /** Stable numeric error code parsed from `{code,message}`, if present. */
+    readonly code?: number;
+    /** Engine-provided message from `{code,message}`, if present. */
+    readonly engineMessage?: string;
+    constructor(status: number, message: string, retryAfter: string | null, body?: string);
+}
+
+/**
+ * Utilitaires cryptographiques pour le SDK PMS.
+ */
 
 /**
  * Convertit des bytes en hex.
@@ -1067,6 +1701,36 @@ declare function toHex(bytes: Uint8Array): string;
  * Convertit un hex en bytes.
  */
 declare function fromHex(hex: string): Uint8Array;
+/**
+ * Message canonique de signature de transaction — DOIT matcher
+ * `Transaction::signing_message` du Rust (dag-pms,
+ * crates/pms-types-transaction/src/transaction.rs) :
+ * `hex(SHA256(JSON({network_id, inputs, outputs, fee})))`
+ * Ordre des clés et compacité identiques à serde_json.
+ *
+ * Le `network_id` est inclus dans le message pour empêcher le replay
+ * cross-chain (une TX signée pour le testnet ne valide pas sur mainnet).
+ *
+ * Les inputs/outputs sont re-canonicalisés défensivement :
+ * - `TxInput` → `{out: {txid, index}}` (ordre de clés serde).
+ * - `TxOutput` → `{address, amount[, asset_id][, locked_until]
+ *   [, spend_condition][, created_at]}` — l'ORDRE des clés est celui de la
+ *   struct Rust et chaque clé optionnelle est OMISE quand undefined/null
+ *   (équivalent serde `skip_serializing_if`), jamais sérialisée à `null`.
+ *   `created_at` est système : ne le posez jamais côté client (géré ici
+ *   uniquement par fidélité de hash si un serveur l'echo).
+ *
+ * La signature côté wallet : `wallet.sign(encodeUtf8(msgHex))` —
+ * `wallet.sign` fait SHA256(message) puis ECDSA, ce qui correspond
+ * exactement au verify Rust (k256 hash la hex-string du message).
+ *
+ * @param networkId - Network ID de la chaîne cible (ex: "pms-testnet-v1")
+ * @param inputs - Inputs de la transaction
+ * @param outputs - Outputs de la transaction
+ * @param fee - Frais (string décimale, ex: "0.1")
+ * @returns Hash hex (64 chars) du message canonique
+ */
+declare function txSigningMessage(networkId: string, inputs: TxInput[], outputs: TxOutput[], fee: string): string;
 /**
  * Parse un montant décimal en satoshis (8 décimales).
  */
@@ -1075,6 +1739,64 @@ declare function parseAmount(amount: string): bigint;
  * Formate des satoshis en montant décimal.
  */
 declare function formatAmount(sats: bigint): string;
+/** Millisecondes par jour — base du demurrage (protocole 2.5). */
+declare const DAY_MS = 86400000;
+/**
+ * Dérive l'adresse multisig CANONIQUE d'une policy M-of-N (protocole 2.2).
+ *
+ * DOIT matcher `multisig_address` du Rust
+ * (crates/pms-core/src/validations/conditions.rs) :
+ * `"msig1" + hex(SHA256("pms-multisig-v1" || m || n || pk_1 || … || pk_n)[..20])`
+ * où les pubkeys sont normalisées (trim, sans `0x`, lowercase) puis TRIÉES —
+ * ordre et casse de déclaration indifférents.
+ *
+ * Tout output sous condition MultiSig DOIT porter cette adresse, sinon le
+ * moteur rejette la création (`InvalidSpendCondition`).
+ *
+ * @param m - Quorum requis (1..=N)
+ * @param pubkeys - Clés publiques secp256k1 hex des membres (N <= 16)
+ */
+declare function multisigAddress(m: number, pubkeys: string[]): string;
+/**
+ * Hash SHA-256 hex d'un préimage HashLock (protocole 2.2).
+ * À poser dans `SpendCondition.HashLock.hash_hex` à la création de l'output ;
+ * le dépensier fournira `hex(preimage)` dans `Unlock.preimage_hex`.
+ *
+ * @param preimage - Le secret, en bytes ou string UTF-8
+ */
+declare function hashlockHash(preimage: Uint8Array | string): string;
+/**
+ * Valeur effective d'un UTXO d'un asset à demurrage (protocole 2.5),
+ * **plancher au satoshi** (8 décimales).
+ *
+ * Formule moteur (Rust `effective_value`, Decimal exact) :
+ * `effective = amount − amount × bps × jours_pleins / 10_000` (plancher 0),
+ * `jours_pleins = floor((now − created_at) / 24h)`.
+ *
+ * La conservation moteur est `sum(outputs) <= sum(effective_inputs)` :
+ * arrondir VERS LE BAS au satoshi est donc toujours sûr (le résidu
+ * sub-satoshi est brûlé avec la décote). Retourne le montant maximal
+ * dépensable, en string décimale 8 dp.
+ *
+ * - `createdAtMs` undefined (UTXO pré-v0.10.0) → valeur nominale intacte.
+ * - `bpsPerDay` 0/undefined → valeur nominale intacte.
+ *
+ * @param amount - Montant nominal (string décimale)
+ * @param createdAtMs - `created_at` de l'UTXO (UNIX ms), tel que lu de l'API
+ * @param nowMs - Horloge courante (UNIX ms)
+ * @param bpsPerDay - `TokenMetadata.demurrage_bps_per_day` de l'asset
+ */
+declare function effectiveValue(amount: string, createdAtMs: number | undefined, nowMs: number, bpsPerDay: number | undefined): string;
+/**
+ * Filtre les UTXOs dépensables MAINTENANT : exclut ceux dont le time-lock
+ * (`locked_until`, protocole 2.1) est encore dans le futur. Le moteur
+ * rejetterait leur dépense (`OutputTimeLocked`) — à appliquer avant toute
+ * sélection de coins côté client.
+ *
+ * @param utxos - UTXOs tels que retournés par `GET /v1/wallet/{addr}/utxos`
+ * @param nowMs - Horloge courante (défaut: Date.now())
+ */
+declare function spendableUtxos<T extends Utxo>(utxos: T[], nowMs?: number): T[];
 
 /**
  * Fonctions de chiffrement pour le SDK PMS.
@@ -1105,4 +1827,4 @@ declare function formatAmount(sats: bigint): string;
  */
 declare function decryptPayload(encrypted: EncryptedPayload, recipientPrivateKeyHex: string): string;
 
-export { type ActivityDirection, type ActivityItem, type ActivityOptions, type ActivityResp, type ActivityType, type BalanceInfo, type Block, type BurnNftResponse, type CoordinatorInfoResponse, type CubeAttributes, type HistoryItem, type LedgerInfo, type ListLedgersOptions, 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 };
+export { type ActivityDirection, type ActivityItem, type ActivityOptions, type ActivityResp, type ActivityType, type BalanceInfo, type Block, type BurnNftResponse, type ConfigChangeApplied, type ConfigChangeProposed, type ConfigChangeResult, type ConfigUpdate, type CoordinatorInfoResponse, type Cosigner, type CubeAttributes, DAY_MS, ErrorCode, type ErrorCodeValue, type GovernanceActionResult, type GovernanceBlock, type GovernanceProposal, type GovernanceStatus, type GovernanceTier, type HistoryItem, HttpError, type LedgerInfo, type ListLedgersOptions, type MintCubeResponse, type NftMetadata, type NftResponse, PmsClient, type PmsClientConfig, PmsWallet, type PrepareTxRequest, type PrepareTxResponse, type ProposeGovernanceRequest, type ProposeResult, type ReservesLatest, type RuntimeConfig, type SendTxResponse, type SpendCondition, type StreamActivityOptions, type SubmitResponse, type SupplyInfo, type TokenMetadata, type TxInput, type TxOutput, type TxUtxo, type Unlock, type Utxo, type UtxoDetail, type WalletHistoryResp, type WalletResponse, decryptPayload, effectiveValue, formatAmount, fromHex, hashlockHash, isValidMnemonic, makeUnlock, multisigAddress, parseAmount, spendableUtxos, toHex, txSigningMessage };