verus-rpc 0.1.0

package/dist/methods/wallet.d.ts

@@ -0,0 +1,206 @@
+import type { RpcTransport } from "../transport.js";
+import type { GetWalletInfoResult, GroupedAddress, ImportAddressOptions, ImportPrivKeyOptions, ListReceivedOptions, ListTransactionsOptions, ListUnspentOptions, ListedTransaction, ReceivedByAddressEntry, SendManyOptions, SignMessageOptions, SignMessageResult, UnspentOutput, VerifyMessageOptions } from "./wallet-types.js";
+export interface GetBalanceOptions {
+    /** Only count transactions with at least this many confirmations. */
+    minConf?: number;
+    includeWatchOnly?: boolean;
+}
+export interface GetCurrencyBalanceOptions {
+    /** Transparent address, identity (`name@`), or wildcard. */
+    address: string;
+    minConf?: number;
+    /** Return currency names instead of i-addresses as keys. */
+    friendlyNames?: boolean;
+    includeShared?: boolean;
+}
+export interface GetTransactionOptions {
+    txid: string;
+    includeWatchOnly?: boolean;
+}
+export interface TransactionDetail {
+    address?: string | undefined;
+    /** "send" | "receive" | "generate" | "immature" | "orphan" */
+    category: string;
+    /** Signed value — negative for sends. Bigint sats. */
+    amount: bigint;
+    vout?: number | undefined;
+    /** Signed value — negative. Bigint sats. */
+    fee?: bigint | undefined;
+    size?: number | undefined;
+    [key: string]: unknown;
+}
+export interface GetTransactionResult {
+    /** Signed net wallet effect — bigint sats. */
+    amount: bigint;
+    /** Signed fee (negative) — bigint sats. Present for sends. */
+    fee?: bigint | undefined;
+    confirmations: number;
+    blockhash?: string | undefined;
+    blockindex?: number | undefined;
+    blocktime?: number | undefined;
+    expiryheight?: number | undefined;
+    txid: string;
+    time: number;
+    timereceived: number;
+    details: TransactionDetail[];
+    hex?: string | undefined;
+    [key: string]: unknown;
+}
+export interface SendCurrencyOutput {
+    /** Destination: transparent/z address or identity (`name@`). */
+    address: string;
+    /** Bigint sats — serialized as an exact JSON number for the daemon. */
+    amount: bigint;
+    /** Source currency; defaults to the chain's native currency. */
+    currency?: string | undefined;
+    /** Convert to this currency on the way (typed first-class in Etappe 4). */
+    convertto?: string | undefined;
+    /** Conversion routing via this (fractional) currency. */
+    via?: string | undefined;
+    exportto?: string | undefined;
+    feecurrency?: string | undefined;
+    /** Hex or text memo (z-address outputs only). */
+    memo?: string | undefined;
+    refundto?: string | undefined;
+    preconvert?: boolean | undefined;
+    burn?: boolean | undefined;
+    mintnew?: boolean | undefined;
+}
+export interface SendCurrencyOptions {
+    /** Source address, identity, or `"*"` for any wallet funds. */
+    fromAddress: string;
+    outputs: SendCurrencyOutput[];
+    minConf?: number;
+    /** Explicit fee — bigint sats. */
+    feeAmount?: bigint;
+}
+export interface OperationError {
+    code: number;
+    message: string;
+    [key: string]: unknown;
+}
+export interface OperationResult {
+    txid?: string | undefined;
+    [key: string]: unknown;
+}
+/** One entry of `z_getoperationstatus` — async wallet operation state. */
+export interface OperationStatus {
+    id: string;
+    /** "queued" | "executing" | "success" | "failed" | "cancelled" */
+    status: string;
+    creation_time?: number | undefined;
+    method?: string | undefined;
+    /** Original call params, safe-number converted (amounts arrive as exact decimal strings). */
+    params?: unknown;
+    result?: OperationResult | undefined;
+    error?: OperationError | undefined;
+    [key: string]: unknown;
+}
+export interface GetOperationStatusOptions {
+    /** Restrict to these opids; all known operations when omitted. */
+    operationIds?: string[];
+}
+export interface SendCurrencyAndWaitOptions extends SendCurrencyOptions {
+    /** Poll interval for z_getoperationstatus. Default 1s. */
+    pollIntervalMs?: number;
+    /** Deadline for the operation to reach a final state. Default 120s. */
+    waitTimeoutMs?: number;
+}
+export interface SendCurrencyAndWaitResult {
+    opid: string;
+    txid: string;
+}
+export declare function mapGetTransaction(raw: unknown): GetTransactionResult;
+export declare function mapCurrencyBalance(raw: unknown): Record<string, bigint>;
+export declare function mapOperationStatus(raw: unknown, index: number): OperationStatus;
+export declare function mapUnspentOutput(raw: unknown, index: number): UnspentOutput;
+export declare function mapListedTransaction(raw: unknown, index: number): ListedTransaction;
+export declare function mapGetWalletInfo(raw: unknown): GetWalletInfoResult;
+export declare function mapAddressGroupings(raw: unknown): GroupedAddress[][];
+export declare function mapSignMessage(raw: unknown): SignMessageResult;
+/** Wallet family — balances, transactions, sends, async operations. */
+export declare class WalletApi {
+    private readonly transport;
+    constructor(transport: RpcTransport);
+    /** Confirmed native-currency wallet balance — bigint sats. */
+    getBalance(options?: GetBalanceOptions): Promise<bigint>;
+    /** Per-currency balances of one address/identity — bigint sats per currency. */
+    getCurrencyBalance(options: GetCurrencyBalanceOptions): Promise<Record<string, bigint>>;
+    /** Detailed wallet view of one transaction. */
+    getTransaction(options: GetTransactionOptions): Promise<GetTransactionResult>;
+    /**
+     * Send currency (async daemon operation). Returns the operation id —
+     * use `getOperationStatus` or `sendCurrencyAndWait` for the txid.
+     */
+    sendCurrency(options: SendCurrencyOptions): Promise<string>;
+    /** `z_getoperationstatus` — state of async wallet operations. */
+    getOperationStatus(options?: GetOperationStatusOptions): Promise<OperationStatus[]>;
+    /**
+     * `sendcurrency` + poll `z_getoperationstatus` until the operation reaches
+     * a final state. Resolves with the txid on success; throws
+     * `OperationFailedError` / `OperationTimeoutError` otherwise.
+     */
+    sendCurrencyAndWait(options: SendCurrencyAndWaitOptions): Promise<SendCurrencyAndWaitResult>;
+    /** Unspent transparent outputs — amounts as bigint sats. */
+    listUnspent(options?: ListUnspentOptions): Promise<UnspentOutput[]>;
+    /** Most recent wallet transactions — amounts as bigint sats. */
+    listTransactions(options?: ListTransactionsOptions): Promise<ListedTransaction[]>;
+    /** Send to multiple transparent recipients in one transaction. Returns the txid. */
+    sendMany(options: SendManyOptions): Promise<string>;
+    /** New transparent receiving address. */
+    getNewAddress(): Promise<string>;
+    /** New transparent change address. */
+    getRawChangeAddress(): Promise<string>;
+    /** Wallet state — balances as bigint sats. */
+    getWalletInfo(): Promise<GetWalletInfoResult>;
+    /** Unconfirmed native-currency balance — bigint sats. */
+    getUnconfirmedBalance(): Promise<bigint>;
+    /** Address clusters with common ownership — amounts as bigint sats. */
+    listAddressGroupings(): Promise<GroupedAddress[][]>;
+    /** Sign a message with an address key or identity. */
+    signMessage(options: SignMessageOptions): Promise<SignMessageResult>;
+    /**
+     * Verify a message signature. For identity signers, set
+     * `checkLatest: true` unless you specifically need historical validity —
+     * see `VerifyMessageOptions`.
+     */
+    verifyMessage(options: VerifyMessageOptions): Promise<boolean>;
+    /** T2 helper: request + safe-number conversion + typed cast. */
+    private t2;
+    /** Received totals per address. T2 — amounts as exact decimal strings. */
+    listReceivedByAddress(options?: ListReceivedOptions): Promise<ReceivedByAddressEntry[]>;
+    /** Total received by one address. T2 — exact decimal string. */
+    getReceivedByAddress(options: {
+        address: string;
+        minConf?: number;
+    }): Promise<string>;
+    /**
+     * LEGACY (accounts era, deprecated upstream): balances per account label.
+     * T2 — amounts as exact decimal strings. Prefer identities/addresses.
+     */
+    listAccounts(options?: {
+        minConf?: number;
+        includeWatchOnly?: boolean;
+    }): Promise<Record<string, string>>;
+    /** Import a WIF private key into the wallet. Slow when rescanning. */
+    importPrivKey(options: ImportPrivKeyOptions): Promise<void>;
+    /** Watch an address or script without its key. */
+    importAddress(options: ImportAddressOptions): Promise<void>;
+    /** Import keys from a `dumpwallet` file (server-side path). */
+    importWallet(options: {
+        filename: string;
+    }): Promise<void>;
+    /** SECRET: WIF private key for an address. Do not log the result. */
+    dumpPrivKey(options: {
+        address: string;
+    }): Promise<string>;
+    /** Dump all wallet keys to a server-side file. Returns the full path. */
+    dumpWallet(options: {
+        filename: string;
+    }): Promise<string>;
+    /** Copy wallet.dat to a server-side destination. Returns the full path. */
+    backupWallet(options: {
+        destination: string;
+    }): Promise<string>;
+}
+//# sourceMappingURL=wallet.d.ts.map

package/dist/methods/wallet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/methods/wallet.ts"],"names":[],"mappings":"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"}

package/dist/methods/wallet.js

@@ -0,0 +1,455 @@
+import { formatAmount } from "../amount.js";
+import { OperationFailedError, OperationTimeoutError, ResponseMappingError } from "../errors.js";
+import { LosslessNumber, toSafeNumbers } from "../lossless.js";
+import { expectArray, expectObject, mapAmount, mapAmountOptional, mapBoolean, mapBooleanOptional, mapInt, mapIntOptional, mapString, mapStringOptional, withPassthrough, } from "../mapping.js";
+export function mapGetTransaction(raw) {
+    const method = "gettransaction";
+    const obj = expectObject(raw, method);
+    const ctx = (field) => ({ method, field });
+    const details = expectArray(obj["details"] ?? [], method, "details").map((item, i) => {
+        const d = expectObject(item, method);
+        const dctx = (field) => ({ method, field: `details[${i}].${field}` });
+        return withPassthrough(d, {
+            address: mapStringOptional(d["address"], dctx("address")),
+            category: mapString(d["category"], dctx("category")),
+            amount: mapAmount(d["amount"], dctx("amount"), { signed: true }),
+            vout: mapIntOptional(d["vout"], dctx("vout")),
+            fee: mapAmountOptional(d["fee"], dctx("fee"), { signed: true }),
+            size: mapIntOptional(d["size"], dctx("size")),
+        });
+    });
+    return withPassthrough(obj, {
+        amount: mapAmount(obj["amount"], ctx("amount"), { signed: true }),
+        fee: mapAmountOptional(obj["fee"], ctx("fee"), { signed: true }),
+        confirmations: mapInt(obj["confirmations"], ctx("confirmations")),
+        blockhash: mapStringOptional(obj["blockhash"], ctx("blockhash")),
+        blockindex: mapIntOptional(obj["blockindex"], ctx("blockindex")),
+        blocktime: mapIntOptional(obj["blocktime"], ctx("blocktime")),
+        expiryheight: mapIntOptional(obj["expiryheight"], ctx("expiryheight")),
+        txid: mapString(obj["txid"], ctx("txid")),
+        time: mapInt(obj["time"], ctx("time")),
+        timereceived: mapInt(obj["timereceived"], ctx("timereceived")),
+        details,
+        hex: mapStringOptional(obj["hex"], ctx("hex")),
+    });
+}
+export function mapCurrencyBalance(raw) {
+    const method = "getcurrencybalance";
+    const obj = expectObject(raw, method);
+    const balances = {};
+    for (const [currency, value] of Object.entries(obj)) {
+        balances[currency] = mapAmount(value, { method, field: currency });
+    }
+    return balances;
+}
+export function mapOperationStatus(raw, index) {
+    const method = "z_getoperationstatus";
+    const obj = expectObject(raw, method);
+    const ctx = (field) => ({ method, field: `[${index}].${field}` });
+    const rawResult = obj["result"];
+    const rawError = obj["error"];
+    return withPassthrough(obj, {
+        id: mapString(obj["id"], ctx("id")),
+        status: mapString(obj["status"], ctx("status")),
+        creation_time: mapIntOptional(obj["creation_time"], ctx("creation_time")),
+        method: mapStringOptional(obj["method"], ctx("method")),
+        params: obj["params"] === undefined ? undefined : toSafeNumbers(obj["params"]),
+        result: rawResult === undefined || rawResult === null
+            ? undefined
+            : toSafeNumbers(expectObject(rawResult, method)),
+        error: rawError === undefined || rawError === null
+            ? undefined
+            : mapOperationError(expectObject(rawError, method), ctx("error")),
+    });
+}
+function mapOperationError(obj, ctx) {
+    return withPassthrough(obj, {
+        code: mapInt(obj["code"], { method: ctx.method, field: `${ctx.field}.code` }),
+        message: mapString(obj["message"], { method: ctx.method, field: `${ctx.field}.message` }),
+    });
+}
+export function mapUnspentOutput(raw, index) {
+    const method = "listunspent";
+    const obj = expectObject(raw, method);
+    const ctx = (field) => ({ method, field: `[${index}].${field}` });
+    return withPassthrough(obj, {
+        txid: mapString(obj["txid"], ctx("txid")),
+        vout: mapInt(obj["vout"], ctx("vout")),
+        address: mapStringOptional(obj["address"], ctx("address")),
+        scriptPubKey: mapStringOptional(obj["scriptPubKey"], ctx("scriptPubKey")),
+        amount: mapAmount(obj["amount"], ctx("amount")),
+        confirmations: mapInt(obj["confirmations"], ctx("confirmations")),
+        generated: mapBooleanOptional(obj["generated"], ctx("generated")),
+        spendable: mapBooleanOptional(obj["spendable"], ctx("spendable")),
+        redeemScript: mapStringOptional(obj["redeemScript"], ctx("redeemScript")),
+    });
+}
+export function mapListedTransaction(raw, index) {
+    const method = "listtransactions";
+    const obj = expectObject(raw, method);
+    const ctx = (field) => ({ method, field: `[${index}].${field}` });
+    return withPassthrough(obj, {
+        address: mapStringOptional(obj["address"], ctx("address")),
+        category: mapString(obj["category"], ctx("category")),
+        amount: mapAmount(obj["amount"], ctx("amount"), { signed: true }),
+        vout: mapIntOptional(obj["vout"], ctx("vout")),
+        fee: mapAmountOptional(obj["fee"], ctx("fee"), { signed: true }),
+        confirmations: mapIntOptional(obj["confirmations"], ctx("confirmations")),
+        blockhash: mapStringOptional(obj["blockhash"], ctx("blockhash")),
+        blockindex: mapIntOptional(obj["blockindex"], ctx("blockindex")),
+        blocktime: mapIntOptional(obj["blocktime"], ctx("blocktime")),
+        txid: mapStringOptional(obj["txid"], ctx("txid")),
+        time: mapInt(obj["time"], ctx("time")),
+        timereceived: mapIntOptional(obj["timereceived"], ctx("timereceived")),
+        comment: mapStringOptional(obj["comment"], ctx("comment")),
+        size: mapIntOptional(obj["size"], ctx("size")),
+    });
+}
+export function mapGetWalletInfo(raw) {
+    const method = "getwalletinfo";
+    const obj = expectObject(raw, method);
+    const ctx = (field) => ({ method, field });
+    return withPassthrough(obj, {
+        walletversion: mapInt(obj["walletversion"], ctx("walletversion")),
+        balance: mapAmount(obj["balance"], ctx("balance")),
+        unconfirmed_balance: mapAmount(obj["unconfirmed_balance"], ctx("unconfirmed_balance")),
+        immature_balance: mapAmount(obj["immature_balance"], ctx("immature_balance")),
+        txcount: mapInt(obj["txcount"], ctx("txcount")),
+        keypoololdest: mapIntOptional(obj["keypoololdest"], ctx("keypoololdest")),
+        keypoolsize: mapIntOptional(obj["keypoolsize"], ctx("keypoolsize")),
+        unlocked_until: mapIntOptional(obj["unlocked_until"], ctx("unlocked_until")),
+        paytxfee: mapAmountOptional(obj["paytxfee"], ctx("paytxfee")),
+        seedfp: mapStringOptional(obj["seedfp"], ctx("seedfp")),
+    });
+}
+export function mapAddressGroupings(raw) {
+    const method = "listaddressgroupings";
+    return expectArray(raw, method).map((group, g) => expectArray(group, method, `[${g}]`).map((entry, e) => {
+        const tuple = expectArray(entry, method, `[${g}][${e}]`);
+        const address = mapString(tuple[0], { method, field: `[${g}][${e}][0]` });
+        const amount = mapAmount(tuple[1], { method, field: `[${g}][${e}][1]` });
+        const account = mapStringOptional(tuple[2], { method, field: `[${g}][${e}][2]` });
+        return account === undefined ? { address, amount } : { address, amount, account };
+    }));
+}
+export function mapSignMessage(raw) {
+    const method = "signmessage";
+    const obj = expectObject(raw, method);
+    return withPassthrough(obj, {
+        hash: mapString(obj["hash"], { method, field: "hash" }),
+        signature: mapString(obj["signature"], { method, field: "signature" }),
+    });
+}
+function serializeOutput(output) {
+    const raw = {
+        address: output.address,
+        amount: new LosslessNumber(formatAmount(output.amount)),
+    };
+    if (output.currency !== undefined)
+        raw["currency"] = output.currency;
+    if (output.convertto !== undefined)
+        raw["convertto"] = output.convertto;
+    if (output.via !== undefined)
+        raw["via"] = output.via;
+    if (output.exportto !== undefined)
+        raw["exportto"] = output.exportto;
+    if (output.feecurrency !== undefined)
+        raw["feecurrency"] = output.feecurrency;
+    if (output.memo !== undefined)
+        raw["memo"] = output.memo;
+    if (output.refundto !== undefined)
+        raw["refundto"] = output.refundto;
+    if (output.preconvert !== undefined)
+        raw["preconvert"] = output.preconvert;
+    if (output.burn !== undefined)
+        raw["burn"] = output.burn;
+    if (output.mintnew !== undefined)
+        raw["mintnew"] = output.mintnew;
+    return raw;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Wallet family — balances, transactions, sends, async operations. */
+export class WalletApi {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    /** Confirmed native-currency wallet balance — bigint sats. */
+    async getBalance(options) {
+        const params = [];
+        if (options?.minConf !== undefined || options?.includeWatchOnly !== undefined) {
+            // Positional daemon params: the deprecated account slot must be "*".
+            params.push("*", options.minConf ?? 1);
+            if (options.includeWatchOnly !== undefined)
+                params.push(options.includeWatchOnly);
+        }
+        return mapAmount(await this.transport.request("getbalance", params), {
+            method: "getbalance",
+            field: "(result)",
+        });
+    }
+    /** Per-currency balances of one address/identity — bigint sats per currency. */
+    async getCurrencyBalance(options) {
+        const params = [options.address];
+        const needFriendly = options.friendlyNames !== undefined || options.includeShared !== undefined;
+        if (options.minConf !== undefined || needFriendly)
+            params.push(options.minConf ?? 1);
+        if (needFriendly)
+            params.push(options.friendlyNames ?? false);
+        if (options.includeShared !== undefined)
+            params.push(options.includeShared);
+        return mapCurrencyBalance(await this.transport.request("getcurrencybalance", params));
+    }
+    /** Detailed wallet view of one transaction. */
+    async getTransaction(options) {
+        const params = [options.txid];
+        if (options.includeWatchOnly !== undefined)
+            params.push(options.includeWatchOnly);
+        return mapGetTransaction(await this.transport.request("gettransaction", params));
+    }
+    /**
+     * Send currency (async daemon operation). Returns the operation id —
+     * use `getOperationStatus` or `sendCurrencyAndWait` for the txid.
+     */
+    async sendCurrency(options) {
+        const params = [options.fromAddress, options.outputs.map(serializeOutput)];
+        if (options.minConf !== undefined || options.feeAmount !== undefined) {
+            params.push(options.minConf ?? 1);
+        }
+        if (options.feeAmount !== undefined) {
+            params.push(new LosslessNumber(formatAmount(options.feeAmount)));
+        }
+        const result = await this.transport.request("sendcurrency", params);
+        return mapString(result, { method: "sendcurrency", field: "(result)" });
+    }
+    /** `z_getoperationstatus` — state of async wallet operations. */
+    async getOperationStatus(options) {
+        const params = options?.operationIds === undefined ? [] : [options.operationIds];
+        const result = expectArray(await this.transport.request("z_getoperationstatus", params), "z_getoperationstatus");
+        return result.map((item, i) => mapOperationStatus(item, i));
+    }
+    /**
+     * `sendcurrency` + poll `z_getoperationstatus` until the operation reaches
+     * a final state. Resolves with the txid on success; throws
+     * `OperationFailedError` / `OperationTimeoutError` otherwise.
+     */
+    async sendCurrencyAndWait(options) {
+        const { pollIntervalMs, waitTimeoutMs, ...sendOptions } = options;
+        const interval = pollIntervalMs ?? 1_000;
+        const timeout = waitTimeoutMs ?? 120_000;
+        const opid = await this.sendCurrency(sendOptions);
+        const deadline = Date.now() + timeout;
+        for (;;) {
+            const statuses = await this.getOperationStatus({ operationIds: [opid] });
+            const status = statuses.find((s) => s.id === opid);
+            if (status !== undefined) {
+                if (status.status === "success") {
+                    const txid = status.result?.txid;
+                    if (typeof txid !== "string") {
+                        throw new ResponseMappingError("z_getoperationstatus", "result.txid", "success without txid");
+                    }
+                    return { opid, txid };
+                }
+                if (status.status === "failed" || status.status === "cancelled") {
+                    throw new OperationFailedError(opid, status.status, status.error?.code, status.error?.message ?? "no error message");
+                }
+            }
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                throw new OperationTimeoutError(opid, timeout);
+            }
+            await sleep(Math.min(interval, remaining));
+        }
+    }
+    // -------------------------------------------------------------------------
+    // T1 — wallet family (Etappe 2)
+    /** Unspent transparent outputs — amounts as bigint sats. */
+    async listUnspent(options) {
+        const params = [];
+        const needMax = options?.maxConf !== undefined || options?.addresses !== undefined;
+        if (options?.minConf !== undefined || needMax)
+            params.push(options.minConf ?? 1);
+        if (needMax)
+            params.push(options.maxConf ?? 9_999_999);
+        if (options?.addresses !== undefined)
+            params.push(options.addresses);
+        const result = expectArray(await this.transport.request("listunspent", params), "listunspent");
+        return result.map((item, i) => mapUnspentOutput(item, i));
+    }
+    /** Most recent wallet transactions — amounts as bigint sats. */
+    async listTransactions(options) {
+        const params = [];
+        const needFrom = options?.from !== undefined || options?.includeWatchOnly !== undefined;
+        if (options?.count !== undefined || needFrom) {
+            // Positional daemon params: the deprecated account slot must be "*".
+            params.push("*", options.count ?? 10);
+        }
+        if (needFrom)
+            params.push(options.from ?? 0);
+        if (options?.includeWatchOnly !== undefined)
+            params.push(options.includeWatchOnly);
+        const result = expectArray(await this.transport.request("listtransactions", params), "listtransactions");
+        return result.map((item, i) => mapListedTransaction(item, i));
+    }
+    /** Send to multiple transparent recipients in one transaction. Returns the txid. */
+    async sendMany(options) {
+        const amounts = {};
+        for (const [address, sats] of Object.entries(options.amounts)) {
+            amounts[address] = new LosslessNumber(formatAmount(sats));
+        }
+        // Positional: the deprecated account slot must be "".
+        const params = ["", amounts];
+        const needComment = options.comment !== undefined || options.subtractFeeFrom !== undefined;
+        if (options.minConf !== undefined || needComment)
+            params.push(options.minConf ?? 1);
+        if (needComment)
+            params.push(options.comment ?? "");
+        if (options.subtractFeeFrom !== undefined)
+            params.push(options.subtractFeeFrom);
+        return mapString(await this.transport.request("sendmany", params), { method: "sendmany", field: "(result)" });
+    }
+    /** New transparent receiving address. */
+    async getNewAddress() {
+        return mapString(await this.transport.request("getnewaddress", []), {
+            method: "getnewaddress",
+            field: "(result)",
+        });
+    }
+    /** New transparent change address. */
+    async getRawChangeAddress() {
+        return mapString(await this.transport.request("getrawchangeaddress", []), {
+            method: "getrawchangeaddress",
+            field: "(result)",
+        });
+    }
+    /** Wallet state — balances as bigint sats. */
+    async getWalletInfo() {
+        return mapGetWalletInfo(await this.transport.request("getwalletinfo", []));
+    }
+    /** Unconfirmed native-currency balance — bigint sats. */
+    async getUnconfirmedBalance() {
+        return mapAmount(await this.transport.request("getunconfirmedbalance", []), {
+            method: "getunconfirmedbalance",
+            field: "(result)",
+        });
+    }
+    /** Address clusters with common ownership — amounts as bigint sats. */
+    async listAddressGroupings() {
+        return mapAddressGroupings(await this.transport.request("listaddressgroupings", []));
+    }
+    /** Sign a message with an address key or identity. */
+    async signMessage(options) {
+        const params = [options.signer, options.message];
+        if (options.currentSignature !== undefined)
+            params.push(options.currentSignature);
+        return mapSignMessage(await this.transport.request("signmessage", params));
+    }
+    /**
+     * Verify a message signature. For identity signers, set
+     * `checkLatest: true` unless you specifically need historical validity —
+     * see `VerifyMessageOptions`.
+     */
+    async verifyMessage(options) {
+        const params = [options.signer, options.signature, options.message];
+        if (options.checkLatest !== undefined)
+            params.push(options.checkLatest);
+        return mapBoolean(await this.transport.request("verifymessage", params), {
+            method: "verifymessage",
+            field: "(result)",
+        });
+    }
+    // -------------------------------------------------------------------------
+    // T2 — typed (value fields as exact decimal strings)
+    /** T2 helper: request + safe-number conversion + typed cast. */
+    async t2(method, params) {
+        return toSafeNumbers(await this.transport.request(method, params));
+    }
+    /** Received totals per address. T2 — amounts as exact decimal strings. */
+    async listReceivedByAddress(options) {
+        const params = [];
+        const needEmpty = options?.includeEmpty !== undefined || options?.includeWatchOnly !== undefined;
+        if (options?.minConf !== undefined || needEmpty)
+            params.push(options.minConf ?? 1);
+        if (needEmpty)
+            params.push(options.includeEmpty ?? false);
+        if (options?.includeWatchOnly !== undefined)
+            params.push(options.includeWatchOnly);
+        return this.t2("listreceivedbyaddress", params);
+    }
+    /** Total received by one address. T2 — exact decimal string. */
+    async getReceivedByAddress(options) {
+        const params = [options.address];
+        if (options.minConf !== undefined)
+            params.push(options.minConf);
+        const result = await this.t2("getreceivedbyaddress", params);
+        return typeof result === "number" ? String(result) : result;
+    }
+    /**
+     * LEGACY (accounts era, deprecated upstream): balances per account label.
+     * T2 — amounts as exact decimal strings. Prefer identities/addresses.
+     */
+    async listAccounts(options) {
+        const params = [];
+        if (options?.minConf !== undefined || options?.includeWatchOnly !== undefined) {
+            params.push(options.minConf ?? 1);
+        }
+        if (options?.includeWatchOnly !== undefined)
+            params.push(options.includeWatchOnly);
+        const raw = await this.t2("listaccounts", params);
+        const out = {};
+        for (const [account, amount] of Object.entries(raw))
+            out[account] = String(amount);
+        return out;
+    }
+    // -------------------------------------------------------------------------
+    // T2 — key material & backups. NEVER logged, never fixture-recorded with
+    // real key material (mock-only tests). Handle results as secrets.
+    /** Import a WIF private key into the wallet. Slow when rescanning. */
+    async importPrivKey(options) {
+        const params = [options.privateKey];
+        if (options.label !== undefined || options.rescan !== undefined)
+            params.push(options.label ?? "");
+        if (options.rescan !== undefined)
+            params.push(options.rescan);
+        await this.transport.request("importprivkey", params);
+    }
+    /** Watch an address or script without its key. */
+    async importAddress(options) {
+        const params = [options.address];
+        if (options.label !== undefined || options.rescan !== undefined)
+            params.push(options.label ?? "");
+        if (options.rescan !== undefined)
+            params.push(options.rescan);
+        await this.transport.request("importaddress", params);
+    }
+    /** Import keys from a `dumpwallet` file (server-side path). */
+    async importWallet(options) {
+        await this.transport.request("importwallet", [options.filename]);
+    }
+    /** SECRET: WIF private key for an address. Do not log the result. */
+    async dumpPrivKey(options) {
+        return mapString(await this.transport.request("dumpprivkey", [options.address]), {
+            method: "dumpprivkey",
+            field: "(result)",
+        });
+    }
+    /** Dump all wallet keys to a server-side file. Returns the full path. */
+    async dumpWallet(options) {
+        const result = await this.transport.request("dumpwallet", [options.filename]);
+        // Older daemons return the path as a plain string, newer as {filename}.
+        if (typeof result === "string")
+            return result;
+        const obj = expectObject(result, "dumpwallet");
+        return mapString(obj["filename"], { method: "dumpwallet", field: "filename" });
+    }
+    /** Copy wallet.dat to a server-side destination. Returns the full path. */
+    async backupWallet(options) {
+        return mapString(await this.transport.request("backupwallet", [options.destination]), {
+            method: "backupwallet",
+            field: "(result)",
+        });
+    }
+}
+//# sourceMappingURL=wallet.js.map