@hardkas/accounts 0.12.0-rc.2 → 0.12.0-rc.21

package/dist/{chunk-R5P3WIWR.js → chunk-GM2BY4VS.js}

@@ -1,17 +1,37 @@
 // src/internal/wasm-rpc-serialization.ts
-function parseWasmTxToRpc(wasmTxStr, signedTx, inputOverrides, plan) {
+function toRpcNumber(value, field) {
+  if (typeof value === "bigint") {
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new Error(`RPC_SERIALIZATION_UNSAFE_INTEGER: ${field} ${value} exceeds 2^53`);
+    }
+    return Number(value);
+  }
+  return typeof value === "number" ? value : Number(value || 0);
+}
+function storageMassOf(txInner) {
+  const value = txInner.storageMass ?? txInner.mass;
+  if (value === void 0 || value === null) {
+    throw new Error("RPC_STORAGE_MASS_MISSING: the serialized transaction carries no storageMass commitment");
+  }
+  return toRpcNumber(value, "storageMass");
+}
+function parseWasmTxToRpc(wasmTx, signedTx, inputOverrides, plan) {
   let parsed;
-  try {
-    parsed = JSON.parse(wasmTxStr);
-  } catch (e) {
-    throw new Error("Failed to parse WASM transaction JSON: " + String(e));
+  if (typeof wasmTx === "string") {
+    try {
+      parsed = JSON.parse(wasmTx);
+    } catch (e) {
+      throw new Error("Failed to parse WASM transaction JSON: " + String(e));
+    }
+  } else {
+    parsed = wasmTx;
   }
   while (typeof parsed === "string") {
     parsed = JSON.parse(parsed);
   }
   const txInner = parsed.outputs ? parsed : parsed.tx ? parsed.tx.inner : parsed.inner;
   if (!txInner) throw new Error("Could not find inner tx data");
-  const version = txInner.version || 0;
+  const version = toRpcNumber(txInner.version || 0, "version");
   const numInputs = txInner.inputs ? txInner.inputs.length : 0;
   if (inputOverrides) {
     for (const idxStr of Object.keys(inputOverrides)) {
@@ -38,19 +58,19 @@ function parseWasmTxToRpc(wasmTxStr, signedTx, inputOverrides, plan) {
       if (!finalSigScript || finalSigScript.length === 0 || !/^[0-9a-fA-F]+$/.test(finalSigScript)) {
         throw new Error(`INVALID_SIGNATURE_SCRIPT: Missing or invalid hex signature script at input ${idx}`);
       }
-      const sigOpCount = version === 1 ? 0 : originalSigOpCount !== void 0 ? originalSigOpCount : 1;
+      const sigOpCount = version === 1 ? 0 : originalSigOpCount !== void 0 ? toRpcNumber(originalSigOpCount, "sigOpCount") : 1;
       if (version === 1 && sigOpCount !== 0) {
         throw new Error("INVALID_V1_SIG_OP_COUNT: V1 transactions must have sigOpCount = 0.");
       }
       const overrideBudget = plan?.computeBudget;
-      const finalComputeBudget = overrideBudget !== void 0 ? Number(overrideBudget) : computeBudget !== void 0 && computeBudget !== 0 ? computeBudget : 0;
+      const finalComputeBudget = overrideBudget !== void 0 ? Number(overrideBudget) : toRpcNumber(computeBudget ?? 0, "computeBudget");
       return {
         previousOutpoint: {
-          transactionId: prevOut.transactionId || prevOut.transactionId,
-          index: prevOut.index || prevOut.index
+          transactionId: prevOut.transactionId,
+          index: toRpcNumber(prevOut.index ?? 0, "index")
         },
         signatureScript: finalSigScript,
-        sequence: isFlattened ? i.sequence || 0 : i.inner.sequence || 0,
+        sequence: toRpcNumber(isFlattened ? i.sequence || 0 : i.inner.sequence || 0, "sequence"),
         sigOpCount,
         computeBudget: finalComputeBudget
       };
@@ -89,11 +109,13 @@ function parseWasmTxToRpc(wasmTxStr, signedTx, inputOverrides, plan) {
       }
       return ret;
     }),
-    lockTime: txInner.lockTime || 0,
+    lockTime: toRpcNumber(txInner.lockTime || 0, "lockTime"),
     subnetworkId: txInner.subnetworkId || "0000000000000000000000000000000000000000",
-    gas: txInner.gas || 0,
-    mass: txInner.mass || 0,
-    storageMass: txInner.storageMass || 0,
+    gas: toRpcNumber(txInner.gas || 0, "gas"),
+    // The transaction's storage mass commitment, under its Toccata name only. The
+    // node refuses a `mass` that differs from `storageMass`, so the deprecated
+    // field is read (older serializations) but never written.
+    storageMass: storageMassOf(txInner),
     payload: txInner.payload && txInner.payload.length > 0 ? typeof txInner.payload === "string" ? txInner.payload : toHex(txInner.payload) : ""
   };
 }

package/dist/{dev-accounts-B6ZVTPCW.js → dev-accounts-BSWPKAAE.js}

@@ -4,10 +4,10 @@ import {
   ensureDevAccounts,
   getOrCreateDevAccount,
   listDevAccountsSync
-} from "./chunk-6Q4K4A24.js";
-import "./chunk-R5P3WIWR.js";
-import "./chunk-TRVIQTIO.js";
-import "./chunk-6DPO5V3N.js";
+} from "./chunk-CELVD4YG.js";
+import "./chunk-GM2BY4VS.js";
+import "./chunk-BNF566PS.js";
+import "./chunk-7KKJXU73.js";
 import "./chunk-YLG2NIAU.js";
 export {
   DEV_ACCOUNTS_PASSWORD,

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import { TxPlanArtifact, SignedTxArtifact, HardkasArtifactBase } from '@hardkas/artifacts';
-import { HardkasConfig } from '@hardkas/config';
 import * as _hardkas_core from '@hardkas/core';
-import { NetworkId } from '@hardkas/core';
+import { SilArtifactValue, SilAbiArtifact, NetworkId } from '@hardkas/core';
+import { HardkasConfig } from '@hardkas/config';
+export { parseWasmTxToRpc } from './internal/wasm-rpc-serialization.js';
 import { TxPlan } from '@hardkas/tx-builder';
 
 interface TxInputAuthorizationContext {
@@ -151,9 +152,11 @@ declare class SimulatedSigner implements HardkasSigner {
 interface ResolveAccountOptions {
     nameOrAddress: string;
     config?: HardkasConfig | undefined;
+    executionTarget?: _hardkas_core.HardkasExecutionTarget | undefined;
 }
 declare function resolveHardkasAccount(options: ResolveAccountOptions): HardkasAccount;
-declare function listHardkasAccounts(config?: HardkasConfig): HardkasAccount[];
+declare function assertAccountCompatible(account: HardkasAccount, target: _hardkas_core.HardkasExecutionTarget): void;
+declare function listHardkasAccounts(config?: HardkasConfig, executionTarget?: _hardkas_core.HardkasExecutionTarget): HardkasAccount[];
 declare function resolveHardkasAccountAddress(accountOrAddress: string, config?: HardkasConfig, context?: "L1" | "L2"): Promise<string>;
 declare function describeAccount(account: HardkasAccount): Record<string, unknown>;
 
@@ -207,16 +210,29 @@ interface KaspaSigningBackendStatus {
     };
 }
 interface WasmProviderConfig {
-    provider: "npm" | "local" | "release-asset";
+    /**
+     * - `managed` (default): the official rusty-kaspa release SDK installed by
+     *   `hardkas toolchain install kaspa-wasm`, verified against the pin in
+     *   @hardkas/core on every load. There is no fallback to any other SDK.
+     * - `local` / `release-asset`: an explicit path chosen by the user (unverified).
+     */
+    provider: "managed" | "local" | "release-asset";
     path?: string;
 }
 /**
- * Loads the official Kaspa WASM SDK dynamically.
- * This ensures the toolkit remains usable even if the SDK is not installed.
+ * Loads the pinned official SDK (see loadManagedKaspaWasmSync in @hardkas/core).
+ * Synchronous because some callers (AddressManager) expose synchronous APIs.
+ */
+declare function loadKaspaWasmSync(): any;
+/**
+ * Loads the official Kaspa WASM SDK. Every HardKAS component loads the SDK
+ * through here, so the pin and the integrity check apply everywhere.
  */
 declare function loadKaspaWasm(config?: WasmProviderConfig): Promise<any>;
 /**
- * Detects the specific capabilities supported by the installed kaspa-wasm SDK.
+ * Detects the specific capabilities supported by the loaded kaspa-wasm SDK.
+ * Transaction v1 (Toccata) is present when `Transaction` carries `storageMass`,
+ * as in the pinned 2.0.x SDK.
  */
 declare function detectCapabilities(sdk: any): {
     transactionV1Signing: boolean;
@@ -226,6 +242,339 @@ declare function detectCapabilities(sdk: any): {
  */
 declare function getKaspaSigningBackendStatus(config?: WasmProviderConfig): Promise<KaspaSigningBackendStatus>;
 
+/**
+ * Transaction construction against the pinned kaspa-wasm 2.0.x SDK.
+ *
+ * `createTransaction(utxos, outputs, priorityFee)` in 2.0.x spends exactly the
+ * given inputs into exactly the given outputs. Unlike 0.13.x it adds no change
+ * output, and it does not check `priorityFee` against inputs minus outputs. So
+ * change must be passed as an explicit output, and HardKAS checks conservation
+ * itself: an unbalanced plan must never silently turn the difference into fee.
+ */
+interface WasmUtxoEntrySource {
+    readonly utxoEntry: {
+        readonly amount: bigint;
+    };
+}
+interface BalancedOutput {
+    /** Value of the output, used for the conservation check. */
+    readonly amountSompi: bigint;
+    /** What is handed to the SDK: `{ address, amount }` or a `PaymentOutput`. */
+    readonly output: unknown;
+}
+declare function assertValueConservation(input: {
+    readonly inputAmounts: readonly bigint[];
+    readonly outputAmounts: readonly bigint[];
+    readonly feeSompi: bigint;
+}): void;
+/** Builds an unsigned transaction whose outputs (change included) and fee balance the inputs exactly. */
+declare function createBalancedTransaction(sdk: any, input: {
+    readonly utxos: readonly WasmUtxoEntrySource[];
+    readonly outputs: readonly BalancedOutput[];
+    readonly feeSompi: bigint;
+}): any;
+interface WasmUtxoInput {
+    readonly address?: string | undefined;
+    readonly outpoint: {
+        readonly transactionId: string;
+        readonly index: number;
+    };
+    readonly utxoEntry: {
+        readonly amount: bigint;
+        /** A WASM ScriptPublicKey (see toWasmScriptPublicKey). */
+        readonly scriptPublicKey: unknown;
+        readonly blockDaaScore: bigint;
+        readonly isCoinbase: boolean;
+    };
+}
+interface ScriptOutput {
+    readonly value: bigint;
+    /** A WASM ScriptPublicKey: outputs that pay a script rather than an address. */
+    readonly scriptPublicKey: unknown;
+}
+/**
+ * Builds an unsigned version-0 transaction whose outputs are arbitrary scripts
+ * (P2SH/covenant locks), balanced exactly against its inputs.
+ *
+ * Every output is fixed at construction: in 2.x `tx.outputs` returns a copy, so
+ * pushing to it afterwards silently drops the output. Each input carries its
+ * UTXO entry, which signTransaction() needs.
+ */
+declare function createScriptTransaction(sdk: any, input: {
+    readonly utxos: readonly WasmUtxoInput[];
+    readonly outputs: readonly ScriptOutput[];
+    readonly feeSompi: bigint;
+}): any;
+/**
+ * A plan's scriptPublicKey as a WASM ScriptPublicKey with an explicit version
+ * (ADJ-002 transport rule): `{ version, scriptPublicKey | script }` is used as
+ * is; a 72-hex string starting with `0000` is version 0 + a 34-byte script;
+ * any other string is a bare version-0 script. Handing the SDK a bare hex
+ * string would make it read the first two bytes as the version.
+ */
+declare function toWasmScriptPublicKey(sdk: any, spk: unknown): any;
+/**
+ * Plan outputs plus the plan's change, in order, as `{ address, amount }`.
+ * Change is part of the transaction in 2.0.x; nothing adds it later.
+ */
+declare function planOutputsWithChange(plan: {
+    readonly outputs: readonly {
+        readonly address?: string;
+        readonly amountSompi: string | bigint;
+    }[];
+    readonly change?: {
+        readonly address: string;
+        readonly amountSompi: string | bigint;
+    } | null | undefined;
+}): BalancedOutput[];
+
+/** A contract output as the node reports it. */
+interface SilverContractUtxo {
+    readonly outpoint: {
+        readonly transactionId: string;
+        readonly index: number;
+    };
+    readonly amountSompi: bigint;
+    readonly scriptPublicKey: {
+        readonly version: number;
+        readonly script: string;
+    };
+    readonly blockDaaScore: bigint;
+    readonly isCoinbase: boolean;
+}
+/** A `sig` argument: a Schnorr signature of this spend (SIGHASH_ALL) by the given key. */
+interface SilverSignatureArg {
+    readonly kind: "signature";
+    readonly privateKey: string;
+}
+type SilverSpendArg = SilArtifactValue | SilverSignatureArg;
+interface SilverSweepRequest {
+    readonly artifact: SilAbiArtifact;
+    readonly contractName?: string | undefined;
+    readonly entry: string;
+    readonly args: readonly SilverSpendArg[];
+    readonly utxo: SilverContractUtxo;
+    /** Receives the whole value minus the fee. */
+    readonly to: string;
+    readonly networkId: string;
+    /** Input sequence, for contracts with relative time locks. Default 0. */
+    readonly sequence?: bigint | undefined;
+    /** Declared signature operations of the input (script-execution budget). Default 1. */
+    readonly sigOpCount?: number | undefined;
+    /** Fee rate above the node minimum, sompi per gram. Default: the minimum. */
+    readonly feeRateSompiPerGram?: bigint | undefined;
+}
+interface SilverSpendResult {
+    /** The signed WASM transaction. */
+    readonly transaction: any;
+    /** The transaction in RPC shape, ready for submitTransaction. */
+    readonly rpcTransaction: any;
+    readonly txId: string;
+    readonly contractName: string;
+    readonly entry: string;
+    readonly outputSompi: bigint;
+    readonly feeSompi: bigint;
+    readonly mass: bigint;
+    readonly storageMass: bigint;
+    readonly signatureScriptHex: string;
+    readonly assumptions: readonly string[];
+}
+/**
+ * Builds and signs a transaction spending one SilverScript contract output
+ * entirely to `to`, through the named entry.
+ *
+ * Fails closed: the output must be locked to this contract's bytecode, the
+ * fee must meet the SDK's minimum for the final transaction, and the signed
+ * unlock must have the size the fee was computed for.
+ */
+declare function buildSilverSweep(request: SilverSweepRequest): SilverSpendResult;
+declare const SILVER_SPEND_DRAFT_SCHEMA = "hardkas.silver.spendDraft.v1";
+/** A `sig` argument to be filled by a named signer (see signSilverSpend). */
+interface SilverSignerSlot {
+    readonly kind: "signer";
+    readonly signer: string;
+}
+type SilverDraftArg = SilArtifactValue | SilverSignerSlot;
+/**
+ * An unsigned P2SH spend with fixed outputs, as plain JSON: it can be stored
+ * and handed to each signer. Every signer signs the same transaction; the
+ * signatures are placed into the entry's arguments only at finalization.
+ */
+interface SilverSpendDraft {
+    readonly schema: typeof SILVER_SPEND_DRAFT_SCHEMA;
+    readonly networkId: string;
+    readonly contractName: string;
+    readonly entry: string;
+    readonly signers: readonly string[];
+    readonly input: {
+        readonly outpoint: {
+            readonly transactionId: string;
+            readonly index: number;
+        };
+        readonly amountSompi: string;
+        readonly scriptPublicKey: {
+            readonly version: number;
+            readonly script: string;
+        };
+        readonly blockDaaScore: string;
+        readonly isCoinbase: boolean;
+        readonly sequence: string;
+        readonly sigOpCount: number;
+    };
+    readonly outputs: readonly {
+        readonly valueSompi: string;
+        readonly scriptPublicKey: {
+            readonly version: number;
+            readonly script: string;
+        };
+    }[];
+    readonly feeSompi: string;
+    readonly mass: string;
+    readonly storageMass: string;
+    /** Hex length of the final signature script the fee was checked against. */
+    readonly unlockHexLength: number;
+    readonly unsignedTxId: string;
+}
+interface SilverSpendDraftRequest {
+    readonly artifact: SilAbiArtifact;
+    readonly contractName?: string | undefined;
+    readonly entry: string;
+    /** Entry arguments; `sig` slots are named signers filled at finalization. */
+    readonly args: readonly SilverDraftArg[];
+    readonly utxo: SilverContractUtxo;
+    /** The outputs exactly as the contract requires; the rest of the input value is the fee. */
+    readonly outputs: readonly {
+        readonly amountSompi: bigint;
+        readonly address?: string;
+        readonly scriptPublicKey?: {
+            readonly version: number;
+            readonly script: string;
+        };
+    }[];
+    readonly networkId: string;
+    readonly sequence?: bigint | undefined;
+    /** Declared signature operations; defaults to the number of signer slots. */
+    readonly sigOpCount?: number | undefined;
+}
+/**
+ * Prepares a spend of one SilverScript output into fixed outputs. Fails
+ * closed if the output is not locked to the contract or if what the outputs
+ * leave as fee is below the SDK minimum for the final (signed) transaction.
+ */
+declare function prepareSilverSpend(request: SilverSpendDraftRequest): SilverSpendDraft;
+/** One signer's `sig` value (65-byte hex) for a draft, from the SDK's input signature. */
+declare function signSilverSpend(draft: SilverSpendDraft, privateKey: string): string;
+/**
+ * The signed spend: each signer slot takes that signer's signature, the entry
+ * arguments are encoded, and the unlock must have the size the fee was checked for.
+ */
+declare function finalizeSilverSpend(draft: SilverSpendDraft, artifact: SilAbiArtifact, args: readonly SilverDraftArg[], signatures: Readonly<Record<string, string>>): {
+    readonly rpcTransaction: any;
+    readonly txId: string;
+    readonly signatureScriptHex: string;
+};
+
+/** A P2PK (Schnorr) output funding a covenant genesis. */
+interface CovenantFundingInput extends SilverContractUtxo {
+    readonly privateKey: string;
+    /** Compute budget committed by this input. Explicit: there is no estimator. */
+    readonly computeBudget: number;
+}
+interface CovenantGenesisRequest {
+    readonly artifact: SilAbiArtifact;
+    readonly contractName?: string | undefined;
+    /** Value locked in the covenant output (output 0). */
+    readonly valueSompi: bigint;
+    readonly funding: readonly CovenantFundingInput[];
+    readonly changeAddress: string;
+    readonly networkId: string;
+    readonly feeRateSompiPerGram?: bigint | undefined;
+    /** Required when an input commits a compute budget > 0 (see COVENANT_V1_FEE_UNPRICED). */
+    readonly feeSompi?: bigint | undefined;
+}
+interface CovenantTransactionResult {
+    readonly transaction: any;
+    readonly rpcTransaction: any;
+    readonly txId: string;
+    readonly covenantId: string;
+    readonly lockingScript: {
+        readonly version: number;
+        readonly script: string;
+    };
+    readonly feeSompi: bigint;
+    readonly mass: bigint;
+    readonly storageMass: bigint;
+    readonly computeBudgets: readonly number[];
+    readonly assumptions: readonly string[];
+}
+/**
+ * A v1 transaction creating a new covenant: output 0 locks `valueSompi` to the
+ * contract's P2SH script and is bound, by the SDK, to the covenant id derived
+ * from input 0's outpoint; output 1 returns the change.
+ */
+declare function buildCovenantGenesis(request: CovenantGenesisRequest): CovenantTransactionResult & {
+    readonly changeSompi: bigint;
+};
+interface CovenantUtxo extends SilverContractUtxo {
+    /** The covenant id the node reports for this UTXO. */
+    readonly covenantId: string;
+}
+interface CovenantTransitionRequest {
+    /** Artifact of the state the covenant output holds now. */
+    readonly current: SilAbiArtifact;
+    /** Artifact of the successor state (compileSilverSuccessor). */
+    readonly successor: SilAbiArtifact;
+    readonly contractName?: string | undefined;
+    /** The covenant declaration's policy name (its key in cov_decl_to_abi). */
+    readonly policy: string;
+    /** Arguments of the generated entry (the policy's extra call args). */
+    readonly args: readonly SilArtifactValue[];
+    readonly utxo: CovenantUtxo;
+    readonly networkId: string;
+    /** Compute budget committed by the covenant input. Explicit: there is no estimator. */
+    readonly computeBudget: number;
+    readonly feeRateSompiPerGram?: bigint | undefined;
+    /** Required when computeBudget > 0 (see COVENANT_V1_FEE_UNPRICED). */
+    readonly feeSompi?: bigint | undefined;
+}
+/**
+ * A v1 transaction advancing a singleton covenant by one transition: the
+ * covenant output is spent through the compiler-generated entry and its whole
+ * value, minus the fee, moves to one successor output locked to the successor
+ * state and bound to the same covenant id.
+ *
+ * Only single-successor, auth-bound declarations are built. The ABI does not
+ * record a declaration's binding or cardinality, so the node enforces them;
+ * leader contracts (cov binding, with a delegate entry) are NOT_IMPLEMENTED.
+ */
+declare function buildCovenantTransition(request: CovenantTransitionRequest): CovenantTransactionResult & {
+    readonly successorSompi: bigint;
+};
+
+interface ScriptFundingRequest {
+    /** Candidate P2PK outputs of the key, in spending order. */
+    readonly utxos: readonly SilverContractUtxo[];
+    readonly privateKey: string;
+    readonly lockingScript: {
+        readonly version: number;
+        readonly script: string;
+    };
+    readonly valueSompi: bigint;
+    readonly networkId: string;
+}
+interface ScriptFundingResult {
+    readonly rpcTransaction: any;
+    readonly txId: string;
+    readonly outputIndex: 0;
+    readonly feeSompi: bigint;
+    readonly changeSompi: bigint;
+    readonly spent: readonly {
+        readonly transactionId: string;
+        readonly index: number;
+    }[];
+}
+declare function buildScriptFunding(request: ScriptFundingRequest): ScriptFundingResult;
+
 interface GeneratedKaspaDevAccount {
     readonly address: string;
     readonly publicKey?: string;
@@ -260,8 +609,7 @@ interface KaspaWasmSignerOptions {
     wasmConfig?: WasmProviderConfig;
 }
 /**
- * Real Kaspa signer using the official WASM SDK.
- * Only works if the 'kaspa' package is installed.
+ * Real Kaspa signer using the official WASM SDK (the pinned managed toolchain).
  */
 declare class KaspaWasmPrivateKeySigner implements HardkasTxPlanSigner {
     private options;
@@ -565,4 +913,4 @@ declare class WalletStateStoreJson {
     nextChangeIndex(walletId: string): number;
 }
 
-export { AddressManager, type ChainType, type CreateKaspaWalletOptions, DEV_ACCOUNTS_PASSWORD, type DeriveRequest, type DerivedAddress, type EncryptedKeystoreV2, type EvmExportResult, type GeneratedKaspaDevAccount, type HardkasAccount, type HardkasAccountKind, type HardkasBaseAccount, type HardkasEvmPrivateKeyAccount, type HardkasExternalWalletAccount, type HardkasKaspaAccount, type HardkasSigner, type HardkasSignerKind, type HardkasSyntheticAccount, type HardkasTxPlanSigner, type HelperDeriveRequest, type InputAuthorization, type KaspaKeyGenerator, KaspaSdkKeyGenerator, type KaspaSdkKeyGeneratorOptions, KaspaSdkRealTxSigner, type KaspaSdkRealTxSignerOptions, type KaspaSigningBackendStatus, KaspaWasmPrivateKeySigner, type KaspaWasmSignerOptions, type KeystoreCipherParams, type KeystoreKdfParams, KeystoreManager, type KeystorePayload, type KeystoreUnlockResult, LazyAccountAuthorizer, type NetworkType, type PathRequest, PrivateKeyAuthorizer, type RealAccountStore, type RealDevAccount, type RealTxSigner, type RealTxSigningInput, type RealTxSigningResult, type ResolveAccountOptions, type SignTxPlanInput, type SignTxPlanResult, SimulatedSigner, StaticSignatureScriptAuthorizer, type TxInputAuthorizationContext, type TxInputAuthorizer, UnsupportedKaspaKeyGenerator, UnsupportedRealKaspaSigner, UnsupportedRealTxSigner, type WalletArtifact, type WalletClaims, type WalletCreateRequest, type WalletImportRequest, WalletManager, WalletManagerImpl, type WalletMetadata, type WalletState, WalletStateStoreJson, type WalletStateStoreOptions, type WasmInputSigner, type WasmProviderConfig, appendToKeystoreJson, assertSigningNetworkAllowed, createDevSigner, createEmptyRealAccountStore, createLocalKaspaWallet, describeAccount, detectCapabilities, ensureDevAccounts, getDefaultRealAccountsPath, getKaspaSigningBackendStatus, getOrCreateDevAccount, getRealDevAccount, getRequiredEnv, importRealDevAccount, listDevAccountsSync, listHardkasAccounts, listRealDevAccounts, loadKaspaWasm, loadOrCreateRealAccountStore, loadRealAccountStore, loadRealAccountStoreSync, prepareEvmAccountExport, removeRealDevAccount, resolveHardkasAccount, resolveHardkasAccountAddress, resolveRealAccountOrAddress, saveRealAccountStore, signTxPlanArtifact, validateAccountName, validateAddressNetwork, validateAddressPrefix, withKeystoreLock };
+export { AddressManager, type BalancedOutput, type ChainType, type CovenantFundingInput, type CovenantGenesisRequest, type CovenantTransactionResult, type CovenantTransitionRequest, type CovenantUtxo, type CreateKaspaWalletOptions, DEV_ACCOUNTS_PASSWORD, type DeriveRequest, type DerivedAddress, type EncryptedKeystoreV2, type EvmExportResult, type GeneratedKaspaDevAccount, type HardkasAccount, type HardkasAccountKind, type HardkasBaseAccount, type HardkasEvmPrivateKeyAccount, type HardkasExternalWalletAccount, type HardkasKaspaAccount, type HardkasSigner, type HardkasSignerKind, type HardkasSyntheticAccount, type HardkasTxPlanSigner, type HelperDeriveRequest, type InputAuthorization, type KaspaKeyGenerator, KaspaSdkKeyGenerator, type KaspaSdkKeyGeneratorOptions, KaspaSdkRealTxSigner, type KaspaSdkRealTxSignerOptions, type KaspaSigningBackendStatus, KaspaWasmPrivateKeySigner, type KaspaWasmSignerOptions, type KeystoreCipherParams, type KeystoreKdfParams, KeystoreManager, type KeystorePayload, type KeystoreUnlockResult, LazyAccountAuthorizer, type NetworkType, type PathRequest, PrivateKeyAuthorizer, type RealAccountStore, type RealDevAccount, type RealTxSigner, type RealTxSigningInput, type RealTxSigningResult, SILVER_SPEND_DRAFT_SCHEMA, type ScriptFundingRequest, type ScriptFundingResult, type ScriptOutput, type SignTxPlanInput, type SignTxPlanResult, type SilverContractUtxo, type SilverDraftArg, type SilverSignatureArg, type SilverSignerSlot, type SilverSpendArg, type SilverSpendDraft, type SilverSpendDraftRequest, type SilverSpendResult, type SilverSweepRequest, SimulatedSigner, StaticSignatureScriptAuthorizer, type TxInputAuthorizationContext, type TxInputAuthorizer, UnsupportedKaspaKeyGenerator, UnsupportedRealKaspaSigner, UnsupportedRealTxSigner, type WalletArtifact, type WalletClaims, type WalletCreateRequest, type WalletImportRequest, WalletManager, WalletManagerImpl, type WalletMetadata, type WalletState, WalletStateStoreJson, type WalletStateStoreOptions, type WasmInputSigner, type WasmProviderConfig, type WasmUtxoEntrySource, type WasmUtxoInput, appendToKeystoreJson, assertAccountCompatible, assertSigningNetworkAllowed, assertValueConservation, buildCovenantGenesis, buildCovenantTransition, buildScriptFunding, buildSilverSweep, createBalancedTransaction, createDevSigner, createEmptyRealAccountStore, createLocalKaspaWallet, createScriptTransaction, describeAccount, detectCapabilities, ensureDevAccounts, finalizeSilverSpend, getDefaultRealAccountsPath, getKaspaSigningBackendStatus, getOrCreateDevAccount, getRealDevAccount, getRequiredEnv, importRealDevAccount, listDevAccountsSync, listHardkasAccounts, listRealDevAccounts, loadKaspaWasm, loadKaspaWasmSync, loadOrCreateRealAccountStore, loadRealAccountStore, loadRealAccountStoreSync, planOutputsWithChange, prepareEvmAccountExport, prepareSilverSpend, removeRealDevAccount, resolveHardkasAccount, resolveHardkasAccountAddress, resolveRealAccountOrAddress, saveRealAccountStore, signSilverSpend, signTxPlanArtifact, toWasmScriptPublicKey, validateAccountName, validateAddressNetwork, validateAddressPrefix, withKeystoreLock };