@empereur-rouge/pms-sdk 0.5.0 → 0.7.1

package/dist/index.d.ts

@@ -269,8 +269,29 @@ interface TokenMetadata {
      * 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;
@@ -291,6 +312,24 @@ 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).
@@ -309,6 +348,120 @@ interface ReservesLatest {
     /** 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) */
@@ -503,6 +656,19 @@ 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") */
@@ -639,6 +805,96 @@ 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.
@@ -881,6 +1137,119 @@ declare class PmsClient {
      * `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.
@@ -1228,15 +1597,97 @@ 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.
@@ -1376,4 +1827,4 @@ declare function spendableUtxos<T extends Utxo>(utxos: T[], nowMs?: number): T[]
  */
 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 Cosigner, type CubeAttributes, DAY_MS, type HistoryItem, type LedgerInfo, type ListLedgersOptions, type MintCubeResponse, type NftMetadata, type NftResponse, PmsClient, type PmsClientConfig, PmsWallet, type PrepareTxRequest, type PrepareTxResponse, 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 };
+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 };