@kingdomchain/wallet-client 0.5.0 → 0.6.1

package/dist/index.d.ts

@@ -497,6 +497,8 @@ interface EmbeddedWalletScopeOptions {
 }
 interface CreateEmbeddedWalletOptions extends EmbeddedWalletScopeOptions {
     passcode: string;
+    /** When true, replaces an existing vault on this account (e.g. an intentional reset). */
+    replaceExisting?: boolean;
 }
 interface UnlockEmbeddedWalletOptions extends EmbeddedWalletScopeOptions {
     passcode?: string;
@@ -698,7 +700,9 @@ declare function fetchFeeGrantGranter(restUrl: string, grantee: string): Promise
 
 declare class CitizenTxError extends Error {
     readonly code: CitizenTxErrorCode;
-    constructor(message: string, code: CitizenTxErrorCode, cause?: unknown);
+    /** Raw on-chain log from a failed DeliverTx/indexed tx, when available. */
+    readonly rawLog?: string;
+    constructor(message: string, code: CitizenTxErrorCode, cause?: unknown, rawLog?: string);
 }
 type CitizenTxErrorCode = "INSUFFICIENT_FEE" | "INSUFFICIENT_BALANCE" | "SEQUENCE_MISMATCH" | "TX_FAILED" | "TIMEOUT" | "INVALID_INPUT";
 interface BroadcastConfirmOptions {

package/dist/index.js

@@ -2953,10 +2953,16 @@ async function migrateLegacyEmbeddedWallet(options) {
   return session;
 }
 async function createEmbeddedWallet(options) {
+  const scopeId = scopeFromOptions(options);
+  const existing = await loadVaultForScope(scopeId);
+  if (existing && !options.replaceExisting) {
+    throw new EmbeddedWalletVaultError(
+      "An embedded wallet already exists on this account; pass replaceExisting to create over it"
+    );
+  }
   const createdAt = (/* @__PURE__ */ new Date()).toISOString();
   const plaintext = await createHdDerivedPlaintext(createdAt);
   const { address, vault } = await encryptPlaintextWithPasscode(plaintext, options.passcode);
-  const scopeId = scopeFromOptions(options);
   await saveVaultToIndexedDb(vault, { scopeId });
   lockEmbeddedWallet();
   activeScopeId = scopeId;
@@ -3267,12 +3273,15 @@ async function fetchFeeGrantGranter(restUrl, grantee) {
   }
 }
 var CitizenTxError = class extends Error {
-  constructor(message, code, cause) {
+  constructor(message, code, cause, rawLog) {
     super(message, { cause });
     this.code = code;
     this.name = "CitizenTxError";
+    this.rawLog = rawLog;
   }
   code;
+  /** Raw on-chain log from a failed DeliverTx/indexed tx, when available. */
+  rawLog;
 };
 var DEFAULT_GAS = "200000";
 var DEFAULT_FEE_UKDR = "5000";
@@ -3350,6 +3359,7 @@ async function broadcastAndConfirmTx(client, signerAddress, messages, fee, memo
   try {
     deliverTx = await client.signAndBroadcast(signerAddress, messages, fee, memo);
   } catch (err) {
+    console.error("[citizenTx] broadcast threw before inclusion:", err);
     const message = err instanceof Error ? err.message : String(err);
     if (message.toLowerCase().includes("insufficient")) {
       throw new CitizenTxError(citizenTxErrorMessage("INSUFFICIENT_FEE"), "INSUFFICIENT_FEE", err);
@@ -3357,8 +3367,12 @@ async function broadcastAndConfirmTx(client, signerAddress, messages, fee, memo
     throw new CitizenTxError(citizenTxErrorMessage("TX_FAILED"), "TX_FAILED", err);
   }
   if (deliverTx.code !== 0) {
+    console.error("[citizenTx] deliverTx failed:", {
+      code: deliverTx.code,
+      rawLog: deliverTx.rawLog
+    });
     const code = classifyBroadcastFailure(deliverTx.rawLog ?? "", deliverTx.code);
-    throw new CitizenTxError(citizenTxErrorMessage(code), code);
+    throw new CitizenTxError(citizenTxErrorMessage(code), code, void 0, deliverTx.rawLog ?? "");
   }
   const hash = deliverTx.transactionHash;
   const deadline = Date.now() + timeoutMs;
@@ -3366,8 +3380,12 @@ async function broadcastAndConfirmTx(client, signerAddress, messages, fee, memo
     const indexed = await client.getTx(hash);
     if (indexed) {
       if (indexed.code !== 0) {
+        console.error("[citizenTx] indexed tx failed:", {
+          code: indexed.code,
+          rawLog: indexed.rawLog
+        });
         const code = classifyBroadcastFailure(indexed.rawLog ?? "", indexed.code);
-        throw new CitizenTxError(citizenTxErrorMessage(code), code);
+        throw new CitizenTxError(citizenTxErrorMessage(code), code, void 0, indexed.rawLog ?? "");
       }
       return {
         hash,