@unicitylabs/sphere-sdk 0.13.2 → 0.13.3-dev.1

package/dist/index.js

@@ -10351,17 +10351,9 @@ function decryptDeliveryBundle(key, envelope) {
 }
 
 // types/txf.ts
-var ARCHIVED_PREFIX = "archived-";
-var FORKED_PREFIX = "_forked_";
 var RESERVED_KEYS = ["_meta", "_nametag", "_nametags", "_tombstones", "_invalidatedNametags", "_outbox", "_mintOutbox", "_sent", "_invalid", "_integrity", "_history"];
 function isTokenKey(key) {
-  return key.startsWith("_") && !key.startsWith(ARCHIVED_PREFIX) && !key.startsWith(FORKED_PREFIX) && !RESERVED_KEYS.includes(key);
-}
-function isArchivedKey(key) {
-  return key.startsWith(ARCHIVED_PREFIX);
-}
-function isForkedKey(key) {
-  return key.startsWith(FORKED_PREFIX);
+  return key.startsWith("_") && !RESERVED_KEYS.includes(key);
 }
 function tokenIdFromKey(key) {
   return key.startsWith("_") ? key.substring(1) : key;
@@ -10369,27 +10361,112 @@ function tokenIdFromKey(key) {
 function keyFromTokenId(tokenId) {
   return `_${tokenId}`;
 }
-function tokenIdFromArchivedKey(key) {
-  return key.startsWith(ARCHIVED_PREFIX) ? key.substring(ARCHIVED_PREFIX.length) : key;
+function isValidTokenId(tokenId) {
+  return /^[0-9a-fA-F]{64}$/.test(tokenId);
 }
-function archivedKeyFromTokenId(tokenId) {
-  return `${ARCHIVED_PREFIX}${tokenId}`;
+
+// serialization/txf-serializer.ts
+function isV2TokenBlob(sdkData) {
+  return typeof sdkData === "string" && sdkData.length >= 2 && sdkData.length % 2 === 0 && sdkData[0] !== "{" && /^[0-9a-f]+$/i.test(sdkData);
 }
-function forkedKeyFromTokenIdAndState(tokenId, stateHash) {
-  return `${FORKED_PREFIX}${tokenId}_${stateHash}`;
+function v2TokenId(token) {
+  return token.id.startsWith("v2_") ? token.id.slice(3) : token.id;
 }
-function parseForkedKey(key) {
-  if (!key.startsWith(FORKED_PREFIX)) return null;
-  const remainder = key.substring(FORKED_PREFIX.length);
-  const underscoreIndex = remainder.indexOf("_");
-  if (underscoreIndex === -1 || underscoreIndex < 64) return null;
-  return {
-    tokenId: remainder.substring(0, underscoreIndex),
-    stateHash: remainder.substring(underscoreIndex + 1)
+function isV2TokenEntry(entry) {
+  return typeof entry === "object" && entry !== null && !("genesis" in entry) && isV2TokenBlob(entry.sdkData);
+}
+async function buildTxfStorageData(tokens, meta, options) {
+  const storageData = {
+    _meta: {
+      ...meta,
+      formatVersion: "2.0"
+    }
   };
+  if (options?.nametags && options.nametags.length > 0) {
+    storageData._nametags = options.nametags;
+  }
+  if (options?.tombstones && options.tombstones.length > 0) {
+    storageData._tombstones = options.tombstones;
+  }
+  if (options?.historyEntries && options.historyEntries.length > 0) {
+    storageData._history = options.historyEntries;
+  }
+  for (const token of tokens) {
+    if (isV2TokenBlob(token.sdkData)) {
+      storageData[keyFromTokenId(v2TokenId(token))] = token;
+    } else {
+      logger.warn(
+        "TXF",
+        `Refusing to persist token ${token.id.slice(0, 16)}...: sdkData is not a v2 token blob \u2014 entry skipped`
+      );
+    }
+  }
+  return storageData;
 }
-function isValidTokenId(tokenId) {
-  return /^[0-9a-fA-F]{64}$/.test(tokenId);
+function parseTxfStorageData(data) {
+  const result = {
+    tokens: [],
+    meta: null,
+    nametags: [],
+    tombstones: [],
+    historyEntries: [],
+    validationErrors: []
+  };
+  if (!data || typeof data !== "object") {
+    result.validationErrors.push("Storage data is not an object");
+    return result;
+  }
+  const storageData = data;
+  if (storageData._meta && typeof storageData._meta === "object") {
+    result.meta = storageData._meta;
+  }
+  const seenNames = /* @__PURE__ */ new Set();
+  if (Array.isArray(storageData._nametags)) {
+    for (const entry of storageData._nametags) {
+      if (entry && typeof entry === "object" && typeof entry.name === "string") {
+        result.nametags.push(entry);
+        seenNames.add(entry.name);
+      }
+    }
+  }
+  if (storageData._nametag && typeof storageData._nametag === "object") {
+    const legacy = storageData._nametag;
+    if (typeof legacy.name === "string" && !seenNames.has(legacy.name)) {
+      result.nametags.push(legacy);
+    }
+  }
+  if (storageData._tombstones && Array.isArray(storageData._tombstones)) {
+    for (const entry of storageData._tombstones) {
+      if (typeof entry === "object" && entry !== null && typeof entry.tokenId === "string" && typeof entry.stateHash === "string" && typeof entry.timestamp === "number") {
+        result.tombstones.push(entry);
+      }
+    }
+  }
+  if (Array.isArray(storageData._history)) {
+    for (const entry of storageData._history) {
+      if (typeof entry === "object" && entry !== null && typeof entry.dedupKey === "string" && typeof entry.type === "string") {
+        result.historyEntries.push(entry);
+      }
+    }
+  }
+  for (const key of Object.keys(storageData)) {
+    if (isTokenKey(key)) {
+      const tokenId = tokenIdFromKey(key);
+      const entry = storageData[key];
+      if (isV2TokenEntry(entry)) {
+        result.tokens.push(entry);
+      } else {
+        const msg = `Token ${tokenId}: unrecognized storage entry (not a v2 token blob) \u2014 entry skipped`;
+        logger.warn("TXF", msg);
+        result.validationErrors.push(msg);
+      }
+    } else if (key.startsWith("token-")) {
+      const msg = `Token ${key}: sdkData is not a v2 token blob \u2014 entry skipped`;
+      logger.warn("TXF", msg);
+      result.validationErrors.push(msg);
+    }
+  }
+  return result;
 }
 
 // registry/TokenRegistry.ts
@@ -10830,403 +10907,14 @@ function getCoinIdByName(name) {
 }
 function normalizeCoinId(coinId) {
   if (coinId.length <= 20 && /^[A-Za-z0-9]+$/.test(coinId)) {
-    const resolved = getCoinIdBySymbol(coinId);
-    if (resolved) return resolved;
-  }
-  return coinId;
-}
-function coinIdsMatch(a, b) {
-  if (a === b) return true;
-  return normalizeCoinId(a) === normalizeCoinId(b);
-}
-
-// serialization/txf-serializer.ts
-function bytesToHex5(bytes) {
-  const arr = Array.isArray(bytes) ? bytes : Array.from(bytes);
-  return arr.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
-function normalizeToHex(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  if (value && typeof value === "object") {
-    const obj = value;
-    if ("bytes" in obj && (Array.isArray(obj.bytes) || obj.bytes instanceof Uint8Array)) {
-      return bytesToHex5(obj.bytes);
-    }
-    if (obj.type === "Buffer" && Array.isArray(obj.data)) {
-      return bytesToHex5(obj.data);
-    }
-  }
-  return String(value);
-}
-function normalizeSdkTokenToStorage(sdkTokenJson) {
-  const txf = structuredClone(sdkTokenJson);
-  if (txf.genesis?.data) {
-    const data = txf.genesis.data;
-    if (data.tokenId !== void 0) {
-      data.tokenId = normalizeToHex(data.tokenId);
-    }
-    if (data.tokenType !== void 0) {
-      data.tokenType = normalizeToHex(data.tokenType);
-    }
-    if (data.salt !== void 0) {
-      data.salt = normalizeToHex(data.salt);
-    }
-  }
-  if (txf.genesis?.inclusionProof?.authenticator) {
-    const auth = txf.genesis.inclusionProof.authenticator;
-    if (auth.publicKey !== void 0) {
-      auth.publicKey = normalizeToHex(auth.publicKey);
-    }
-    if (auth.signature !== void 0) {
-      auth.signature = normalizeToHex(auth.signature);
-    }
-  }
-  if (Array.isArray(txf.transactions)) {
-    for (const tx of txf.transactions) {
-      if (tx.inclusionProof?.authenticator) {
-        const auth = tx.inclusionProof.authenticator;
-        if (auth.publicKey !== void 0) {
-          auth.publicKey = normalizeToHex(auth.publicKey);
-        }
-        if (auth.signature !== void 0) {
-          auth.signature = normalizeToHex(auth.signature);
-        }
-      }
-    }
-  }
-  return txf;
-}
-function tokenToTxf(token) {
-  const jsonData = token.sdkData;
-  if (!jsonData) {
-    return null;
-  }
-  try {
-    const txfData = normalizeSdkTokenToStorage(JSON.parse(jsonData));
-    if (!txfData.genesis || !txfData.state) {
-      return null;
-    }
-    if (!txfData.version) {
-      txfData.version = "2.0";
-    }
-    if (!txfData.transactions) {
-      txfData.transactions = [];
-    }
-    if (!txfData.nametags) {
-      txfData.nametags = [];
-    }
-    if (!txfData._integrity) {
-      txfData._integrity = {
-        genesisDataJSONHash: "0000" + "0".repeat(60)
-      };
-    }
-    return txfData;
-  } catch {
-    return null;
-  }
-}
-function objectToTxf(obj) {
-  if (!obj.sdkData) return null;
-  try {
-    const txfData = normalizeSdkTokenToStorage(JSON.parse(obj.sdkData));
-    if (!txfData.genesis || !txfData.state) return null;
-    return txfData;
-  } catch {
-    return null;
-  }
-}
-function determineTokenStatus(txf) {
-  if (txf.transactions.length > 0) {
-    const lastTx = txf.transactions[txf.transactions.length - 1];
-    if (lastTx.inclusionProof === null) {
-      return "pending";
-    }
-  }
-  return "confirmed";
-}
-function txfToToken(tokenId, txf) {
-  const coinData = txf.genesis.data.coinData;
-  const totalAmount = coinData.reduce((sum, [, amt]) => {
-    return sum + BigInt(amt || "0");
-  }, BigInt(0));
-  let coinId = coinData[0]?.[0] || "";
-  for (const [cid, amt] of coinData) {
-    if (BigInt(amt || "0") > 0) {
-      coinId = cid;
-      break;
-    }
-  }
-  const tokenType = txf.genesis.data.tokenType;
-  const isNft = tokenType === "455ad8720656b08e8dbd5bac1f3c73eeea5431565f6c1c3af742b1aa12d41d89";
-  const now = Date.now();
-  const registry = TokenRegistry.getInstance();
-  const def = registry.getDefinition(coinId);
-  return {
-    id: tokenId,
-    coinId,
-    symbol: isNft ? "NFT" : def?.symbol || coinId.slice(0, 8),
-    name: isNft ? "NFT" : def?.name ? def.name.charAt(0).toUpperCase() + def.name.slice(1) : "Token",
-    decimals: isNft ? 0 : def?.decimals ?? 8,
-    amount: totalAmount.toString(),
-    status: determineTokenStatus(txf),
-    createdAt: now,
-    updatedAt: now,
-    sdkData: JSON.stringify(txf)
-  };
-}
-function isV2TokenBlob(sdkData) {
-  return typeof sdkData === "string" && sdkData.length >= 2 && sdkData.length % 2 === 0 && sdkData[0] !== "{" && /^[0-9a-f]+$/i.test(sdkData);
-}
-function v2TokenId(token) {
-  return token.id.startsWith("v2_") ? token.id.slice(3) : token.id;
-}
-function isV2TokenEntry(entry) {
-  return typeof entry === "object" && entry !== null && !("genesis" in entry) && isV2TokenBlob(entry.sdkData);
-}
-async function buildTxfStorageData(tokens, meta, options) {
-  const storageData = {
-    _meta: {
-      ...meta,
-      formatVersion: "2.0"
-    }
-  };
-  if (options?.nametags && options.nametags.length > 0) {
-    storageData._nametags = options.nametags;
-  }
-  if (options?.tombstones && options.tombstones.length > 0) {
-    storageData._tombstones = options.tombstones;
-  }
-  if (options?.outboxEntries && options.outboxEntries.length > 0) {
-    storageData._outbox = options.outboxEntries;
-  }
-  if (options?.mintOutboxEntries && options.mintOutboxEntries.length > 0) {
-    storageData._mintOutbox = options.mintOutboxEntries;
-  }
-  if (options?.invalidatedNametags && options.invalidatedNametags.length > 0) {
-    storageData._invalidatedNametags = options.invalidatedNametags;
-  }
-  if (options?.historyEntries && options.historyEntries.length > 0) {
-    storageData._history = options.historyEntries;
-  }
-  for (const token of tokens) {
-    const txf = tokenToTxf(token);
-    if (txf) {
-      const actualTokenId = txf.genesis.data.tokenId;
-      storageData[keyFromTokenId(actualTokenId)] = txf;
-    } else if (isV2TokenBlob(token.sdkData)) {
-      storageData[keyFromTokenId(v2TokenId(token))] = token;
-    }
-  }
-  if (options?.archivedTokens && options.archivedTokens.size > 0) {
-    for (const [tokenId, txf] of options.archivedTokens) {
-      storageData[archivedKeyFromTokenId(tokenId)] = txf;
-    }
-  }
-  if (options?.forkedTokens && options.forkedTokens.size > 0) {
-    for (const [key, txf] of options.forkedTokens) {
-      const [tokenId, stateHash] = key.split("_");
-      if (tokenId && stateHash) {
-        storageData[forkedKeyFromTokenIdAndState(tokenId, stateHash)] = txf;
-      }
-    }
-  }
-  return storageData;
-}
-function parseTxfStorageData(data) {
-  const result = {
-    tokens: [],
-    meta: null,
-    nametags: [],
-    tombstones: [],
-    archivedTokens: /* @__PURE__ */ new Map(),
-    forkedTokens: /* @__PURE__ */ new Map(),
-    outboxEntries: [],
-    mintOutboxEntries: [],
-    invalidatedNametags: [],
-    historyEntries: [],
-    validationErrors: []
-  };
-  if (!data || typeof data !== "object") {
-    result.validationErrors.push("Storage data is not an object");
-    return result;
-  }
-  const storageData = data;
-  if (storageData._meta && typeof storageData._meta === "object") {
-    result.meta = storageData._meta;
-  }
-  const seenNames = /* @__PURE__ */ new Set();
-  if (Array.isArray(storageData._nametags)) {
-    for (const entry of storageData._nametags) {
-      if (entry && typeof entry === "object" && typeof entry.name === "string") {
-        result.nametags.push(entry);
-        seenNames.add(entry.name);
-      }
-    }
-  }
-  if (storageData._nametag && typeof storageData._nametag === "object") {
-    const legacy = storageData._nametag;
-    if (typeof legacy.name === "string" && !seenNames.has(legacy.name)) {
-      result.nametags.push(legacy);
-    }
-  }
-  if (storageData._tombstones && Array.isArray(storageData._tombstones)) {
-    for (const entry of storageData._tombstones) {
-      if (typeof entry === "object" && entry !== null && typeof entry.tokenId === "string" && typeof entry.stateHash === "string" && typeof entry.timestamp === "number") {
-        result.tombstones.push(entry);
-      }
-    }
-  }
-  if (storageData._outbox && Array.isArray(storageData._outbox)) {
-    for (const entry of storageData._outbox) {
-      if (typeof entry === "object" && entry !== null && typeof entry.id === "string" && typeof entry.status === "string") {
-        result.outboxEntries.push(entry);
-      }
-    }
-  }
-  if (storageData._mintOutbox && Array.isArray(storageData._mintOutbox)) {
-    for (const entry of storageData._mintOutbox) {
-      if (typeof entry === "object" && entry !== null && typeof entry.id === "string" && typeof entry.status === "string") {
-        result.mintOutboxEntries.push(entry);
-      }
-    }
-  }
-  if (storageData._invalidatedNametags && Array.isArray(storageData._invalidatedNametags)) {
-    for (const entry of storageData._invalidatedNametags) {
-      if (typeof entry === "object" && entry !== null && typeof entry.name === "string") {
-        result.invalidatedNametags.push(entry);
-      }
-    }
-  }
-  if (Array.isArray(storageData._history)) {
-    for (const entry of storageData._history) {
-      if (typeof entry === "object" && entry !== null && typeof entry.dedupKey === "string" && typeof entry.type === "string") {
-        result.historyEntries.push(entry);
-      }
-    }
-  }
-  for (const key of Object.keys(storageData)) {
-    if (isTokenKey(key)) {
-      const tokenId = tokenIdFromKey(key);
-      try {
-        const txfToken = storageData[key];
-        if (txfToken?.genesis?.data?.tokenId) {
-          const token = txfToToken(tokenId, txfToken);
-          result.tokens.push(token);
-        } else if (isV2TokenEntry(storageData[key])) {
-          result.tokens.push(storageData[key]);
-        }
-      } catch (err) {
-        result.validationErrors.push(`Token ${tokenId}: ${err}`);
-      }
-    } else if (isArchivedKey(key)) {
-      const tokenId = tokenIdFromArchivedKey(key);
-      try {
-        const txfToken = storageData[key];
-        if (txfToken?.genesis?.data?.tokenId) {
-          result.archivedTokens.set(tokenId, txfToken);
-        }
-      } catch {
-        result.validationErrors.push(`Archived token ${tokenId}: invalid structure`);
-      }
-    } else if (isForkedKey(key)) {
-      const parsed = parseForkedKey(key);
-      if (parsed) {
-        try {
-          const txfToken = storageData[key];
-          if (txfToken?.genesis?.data?.tokenId) {
-            const mapKey = `${parsed.tokenId}_${parsed.stateHash}`;
-            result.forkedTokens.set(mapKey, txfToken);
-          }
-        } catch {
-          result.validationErrors.push(`Forked token ${parsed.tokenId}: invalid structure`);
-        }
-      }
-    } else if (key.startsWith("token-")) {
-      try {
-        const entry = storageData[key];
-        const txfToken = entry?.token;
-        if (txfToken?.genesis?.data?.tokenId) {
-          const tokenId = txfToken.genesis.data.tokenId;
-          const token = txfToToken(tokenId, txfToken);
-          result.tokens.push(token);
-        }
-      } catch (err) {
-        result.validationErrors.push(`Token ${key}: ${err}`);
-      }
-    }
-  }
-  return result;
-}
-function getTokenId(token) {
-  if (token.sdkData) {
-    try {
-      const txf = JSON.parse(token.sdkData);
-      if (txf.genesis?.data?.tokenId) {
-        return txf.genesis.data.tokenId;
-      }
-    } catch {
-    }
-  }
-  return token.id;
-}
-function getCurrentStateHash(txf) {
-  if (txf.transactions && txf.transactions.length > 0) {
-    const lastTx = txf.transactions[txf.transactions.length - 1];
-    if (lastTx?.newStateHash) {
-      return lastTx.newStateHash;
-    }
-    if (lastTx?.inclusionProof?.authenticator?.stateHash) {
-      return lastTx.inclusionProof.authenticator.stateHash;
-    }
-  }
-  if (txf._integrity?.currentStateHash) {
-    return txf._integrity.currentStateHash;
-  }
-  if (txf.genesis?.inclusionProof?.authenticator?.stateHash) {
-    return txf.genesis.inclusionProof.authenticator.stateHash;
-  }
-  return void 0;
-}
-function hasValidTxfData(token) {
-  if (!token.sdkData) return false;
-  try {
-    const txf = JSON.parse(token.sdkData);
-    return !!(txf.genesis && txf.genesis.data && txf.genesis.data.tokenId && txf.state && txf.genesis.inclusionProof);
-  } catch {
-    return false;
-  }
-}
-function hasUncommittedTransactions(token) {
-  if (!token.sdkData) return false;
-  try {
-    const txf = JSON.parse(token.sdkData);
-    if (!txf.transactions || txf.transactions.length === 0) return false;
-    return txf.transactions.some(
-      (tx) => tx.inclusionProof === null
-    );
-  } catch {
-    return false;
-  }
-}
-function hasMissingNewStateHash(txf) {
-  if (!txf.transactions || txf.transactions.length === 0) {
-    return false;
+    const resolved = getCoinIdBySymbol(coinId);
+    if (resolved) return resolved;
   }
-  return txf.transactions.some((tx) => !tx.newStateHash);
+  return coinId;
 }
-function countCommittedTransactions(token) {
-  if (!token.sdkData) return 0;
-  try {
-    const txf = JSON.parse(token.sdkData);
-    if (!txf.transactions) return 0;
-    return txf.transactions.filter(
-      (tx) => tx.inclusionProof !== null
-    ).length;
-  } catch {
-    return 0;
-  }
+function coinIdsMatch(a, b) {
+  if (a === b) return true;
+  return normalizeCoinId(a) === normalizeCoinId(b);
 }
 
 // core/utils.ts
@@ -11394,6 +11082,10 @@ function surfacedSendFailure(summary) {
   }
   return primaryError;
 }
+function currentStateHashOfTxf(txf) {
+  const last = txf.transactions?.[txf.transactions.length - 1];
+  return last?.newStateHash ?? last?.inclusionProof?.authenticator?.stateHash ?? txf._integrity?.currentStateHash ?? txf.genesis?.inclusionProof?.authenticator?.stateHash ?? "";
+}
 function genesisIdOf(token) {
   return extractTokenIdFromSdkData(token.sdkData) ?? token.id.replace(/^v2_/, "");
 }
@@ -11505,7 +11197,7 @@ function parseSdkDataCached(sdkData) {
     try {
       const txf = JSON.parse(sdkData);
       tokenId = txf.genesis?.data?.tokenId || null;
-      stateHash = getCurrentStateHash(txf) || "";
+      stateHash = currentStateHashOfTxf(txf);
       if (!stateHash) {
         if (txf.state?.hash) {
           stateHash = txf.state.hash;
@@ -12251,7 +11943,6 @@ var PaymentsModule = class _PaymentsModule {
       if (op.kind === "direct") {
         finished = await ctx.engine.transfer({ token: op.sdkToken, recipientPubkey: ctx.recipientChainPubkey }, opts);
       } else {
-        const checkpointStore = this.getCheckpointStore();
         const { outputs } = await ctx.engine.split(
           {
             token: op.sdkToken,
@@ -12260,7 +11951,7 @@ var PaymentsModule = class _PaymentsModule {
               { recipientPubkey: ctx.selfChainPubkey, coinId: ctx.coinId, amount: op.remainderAmount }
             ]
           },
-          { ...opts, ...checkpointStore ? { checkpointStore } : {} }
+          { ...opts, ...ctx.checkpointStore ? { checkpointStore: ctx.checkpointStore } : {} }
         );
         finished = outputs[0];
         changeOutput = outputs[1];
@@ -12447,7 +12138,8 @@ var PaymentsModule = class _PaymentsModule {
         recipientChainPubkeyHex,
         selfChainPubkey: hexToBytes4(this.deps.identity.chainPubkey),
         coinId: request.coinId,
-        ...request.memo !== void 0 ? { memo: request.memo } : {}
+        ...request.memo !== void 0 ? { memo: request.memo } : {},
+        ...this.getCheckpointStore() ? { checkpointStore: this.getCheckpointStore() } : {}
       })
     );
     attempt.summary = summary;
@@ -14964,8 +14656,11 @@ var PaymentsModule = class _PaymentsModule {
       try {
         const plain = decryptField(this.getFieldEncryptionKey(), intent.payload);
         payload = JSON.parse(plain);
-        if (payload.v !== 1 && payload.v !== 2 || !Array.isArray(payload.direct)) {
-          throw new SphereError("Unknown intent payload shape", "VALIDATION_ERROR");
+        if (payload.v !== 2 || !Array.isArray(payload.direct)) {
+          throw new SphereError(
+            `Unsupported intent payload shape (v=${String(payload.v)}) \u2014 not resumable by this wallet version`,
+            "VALIDATION_ERROR"
+          );
         }
       } catch (err) {
         logger.warn("Payments", `Intent ${intent.transferId.slice(0, 8)}\u2026 payload undecodable \u2014 skipped:`, err);
@@ -15104,31 +14799,22 @@ var PaymentsModule = class _PaymentsModule {
   async resumeIntent(transferId, payload) {
     const engine = this.deps.tokenEngine;
     const walletApi = this.deps.walletApi;
-    const delivery = this.delivery;
     const provider = this.getActiveTokenStorageProvider();
     if (!provider) throw new SphereError("No token storage provider for intent resume", "STORAGE_ERROR");
-    const serverApply = delivery.custody === "inventory";
-    const recipientChainPubkey = hexToBytes4(payload.recipient);
-    const deliverBlob = async (tokenBlobHex, opIndex) => {
-      await this.savePendingV2Delivery({
-        transferId,
-        recipientPubkey: payload.recipient,
-        tokenBlob: tokenBlobHex,
-        memo: payload.memo,
-        opIndex,
-        createdAt: Date.now()
-      });
-      const nm = this.currentNametagName();
-      await this.tryDeliver(
-        () => delivery.deliver(payload.recipient, hexToBytes4(tokenBlobHex), {
-          transferId,
-          memo: payload.memo,
-          ...nm !== void 0 ? { senderNametag: nm } : {}
-        }),
-        tokenBlobHex
-      );
+    const serverApply = this.delivery.custody === "inventory";
+    const checkpointStore = this.getCheckpointStore();
+    const ctx = {
+      engine,
+      transferId,
+      recipientChainPubkey: hexToBytes4(payload.recipient),
+      recipientChainPubkeyHex: payload.recipient,
+      selfChainPubkey: hexToBytes4(this.deps.identity.chainPubkey),
+      coinId: payload.coinId,
+      ...payload.memo !== void 0 ? { memo: payload.memo } : {},
+      ...checkpointStore ? { checkpointStore } : {}
     };
     const journaled = await this.journaledByOp(transferId);
+    const blobs = [];
     const spent = [];
     let conflicted = false;
     let firstConflict;
@@ -15136,91 +14822,71 @@ var PaymentsModule = class _PaymentsModule {
     for (const [opIndex, genesisId] of payload.direct.entries()) {
       const existing = journaled.get(opIndex);
       if (existing) {
-        await deliverBlob(existing.tokenBlob, opIndex);
+        blobs.push(existing.tokenBlob);
         spent.push(genesisId);
-      } else {
-        const source = await engine.decodeToken(await provider.getToken(genesisId));
-        try {
-          const finished = await engine.transfer(
-            { token: source, recipientPubkey: recipientChainPubkey },
-            // (transferId, opIndex) pairing replayed from the intent's persisted order (§8.1)
-            { signal: timeoutSignal(SEND_ENGINE_OP_TIMEOUT_MS), transferId, opIndex }
-          );
-          await deliverBlob(bytesToHex4(encodeTokenBlob(engine.encodeToken(finished))), opIndex);
-          spent.push(genesisId);
-        } catch (err) {
-          if (!(err instanceof TransferConflictError)) throw err;
-          conflicted = true;
-          firstConflict ??= err;
-          undeliveredAmount += engine.balanceOf(source, payload.coinId);
-          logger.warn("Payments", `Resume op ${opIndex} lost its source to a concurrent transfer \u2014 not delivered (\xA78.1/#4):`, err);
-        }
+        continue;
+      }
+      const source = await engine.decodeToken(await provider.getToken(genesisId));
+      const outcome = await this.certifyOperation(
+        {
+          kind: "direct",
+          opIndex,
+          uiTokenId: `v2_${genesisId}`,
+          genesisId,
+          sourceSdkData: "",
+          sdkToken: source,
+          deliveredAmount: engine.balanceOf(source, payload.coinId)
+        },
+        ctx
+      );
+      if (outcome.error !== void 0) {
+        if (!(outcome.error instanceof TransferConflictError)) throw outcome.error;
+        conflicted = true;
+        firstConflict ??= outcome.error;
+        undeliveredAmount += engine.balanceOf(source, payload.coinId);
+        logger.warn("Payments", `Resume op ${opIndex} lost its source to a concurrent transfer \u2014 not delivered (\xA78.1/#4):`, outcome.error);
+        continue;
       }
+      blobs.push(outcome.tokenBlob);
+      spent.push(genesisId);
     }
     let changeOutput = null;
     if (payload.split) {
       const splitOpIndex = payload.direct.length;
-      const existingSplit = journaled.get(splitOpIndex);
-      const checkpointStore = payload.v === 2 ? this.getCheckpointStore() : void 0;
       let splitDelivered = false;
-      if (checkpointStore === void 0 && existingSplit) {
-        await deliverBlob(existingSplit.tokenBlob, splitOpIndex);
-        splitDelivered = true;
-      } else {
-        try {
-          const blob = await provider.getToken(payload.split.tokenId);
-          const source = await engine.decodeToken(blob);
-          const selfChainPubkey = hexToBytes4(this.deps.identity.chainPubkey);
-          const { outputs } = await engine.split(
-            {
-              token: source,
-              outputs: [
-                {
-                  recipientPubkey: recipientChainPubkey,
-                  coinId: payload.coinId,
-                  amount: BigInt(payload.split.splitAmount)
-                },
-                {
-                  recipientPubkey: selfChainPubkey,
-                  coinId: payload.coinId,
-                  amount: BigInt(payload.split.remainderAmount)
-                }
-              ]
-            },
-            {
-              signal: timeoutSignal(SEND_ENGINE_OP_TIMEOUT_MS),
-              transferId,
-              opIndex: splitOpIndex,
-              ...checkpointStore ? { checkpointStore } : {}
-            }
-          );
-          changeOutput = outputs[1];
-          if (!serverApply) await this.storeEngineToken(engine, changeOutput, { criticalSave: true });
-          await deliverBlob(bytesToHex4(encodeTokenBlob(engine.encodeToken(outputs[0]))), splitOpIndex);
-          splitDelivered = true;
-        } catch (err) {
-          if (err instanceof ProofUnconfirmedError) throw err;
-          if (checkpointStore !== void 0 && (err instanceof CheckpointPersistFailedError || err instanceof SplitCheckpointLostError || err instanceof CheckpointTrustbaseMismatchError)) {
-            throw err;
+      {
+        const source = await engine.decodeToken(await provider.getToken(payload.split.tokenId));
+        const outcome = await this.certifyOperation(
+          {
+            kind: "split",
+            opIndex: splitOpIndex,
+            uiTokenId: `v2_${payload.split.tokenId}`,
+            genesisId: payload.split.tokenId,
+            sourceSdkData: "",
+            sdkToken: source,
+            deliveredAmount: BigInt(payload.split.splitAmount),
+            remainderAmount: BigInt(payload.split.remainderAmount)
+          },
+          ctx
+        );
+        if (outcome.error === void 0) {
+          changeOutput = outcome.changeOutput ?? null;
+          if (!serverApply && changeOutput) {
+            await this.storeEngineToken(engine, changeOutput, { criticalSave: true });
           }
-          if (err instanceof TransferConflictError) {
+          blobs.push(outcome.tokenBlob);
+          splitDelivered = true;
+        } else {
+          splitDelivered = this.classifyResumeSplitFailure(outcome.error, (err) => {
             conflicted = true;
             firstConflict ??= err;
             undeliveredAmount += BigInt(payload.split.splitAmount);
-            logger.warn("Payments", `Resume split: source lost to a concurrent transfer \u2014 not delivered (\xA78.1/#4):`, err);
-          } else if (err instanceof SplitCheckpointLostError) {
-            logger.warn("Payments", `Resume split (legacy no-checkpoint): recording the spend; change recovers on the next inventory resync (\xA73.1):`, err);
-            this.deps.emitEvent("inventory:conflict", { transferId, coinId: payload.coinId, error: err.message });
-            splitDelivered = true;
-          } else {
-            throw err;
-          }
+          });
         }
       }
-      if (splitDelivered) {
-        spent.push(payload.split.tokenId);
-      }
+      if (splitDelivered) spent.push(payload.split.tokenId);
     }
+    await this.deliverCommittedBlobs(blobs, payload.recipient, transferId, payload.memo);
     if (conflicted && spent.length === 0) throw firstConflict;
     if (serverApply) {
       await this.applyInventoryDelta(
@@ -15232,6 +14898,55 @@ var PaymentsModule = class _PaymentsModule {
         // the one the sources were read from, captured for the whole resume
       );
     }
+    await this.dropResumedSources(spent, transferId, payload);
+    if (conflicted) {
+      const remaining = undeliveredAmount > 0n ? undeliveredAmount : 0n;
+      const delivered = BigInt(payload.amount) - remaining;
+      await walletApi.completeIntent(transferId);
+      await this.recordResumedSentHistory(payload, transferId, delivered > 0n ? delivered.toString() : "0", spent[0]);
+      this.deps.emitEvent("send:partial-remainder", {
+        transferId,
+        remainingAmount: remaining.toString(),
+        coinId: payload.coinId,
+        recipientPubkey: payload.recipient
+      });
+      throw new PartialSendConflictError(
+        "Resume: part of the payment was delivered before a source was consumed by a concurrent transfer \u2014 the delivered legs are final; re-plan ONLY the remainder.",
+        transferId,
+        spent,
+        // the DELIVERED genesisIds — never the conflicted leg
+        remaining.toString(),
+        firstConflict
+      );
+    }
+    await walletApi.completeIntent(transferId);
+    await this.recordResumedSentHistory(payload, transferId, payload.amount, payload.direct[0]);
+  }
+  /**
+   * A resumed split that produced no output: a lost source means the leg delivered
+   * nothing (returns false), and every checkpoint failure keeps the intent open by
+   * throwing. There is no path here that records the spend.
+   */
+  classifyResumeSplitFailure(error, onConflict) {
+    if (error instanceof ProofUnconfirmedError) throw error;
+    if (error instanceof CheckpointPersistFailedError || error instanceof SplitCheckpointLostError || error instanceof CheckpointTrustbaseMismatchError) {
+      throw error;
+    }
+    if (error instanceof TransferConflictError) {
+      onConflict(error);
+      logger.warn("Payments", "Resume split: source lost to a concurrent transfer \u2014 not delivered (\xA78.1/#4):", error);
+      return false;
+    }
+    throw error;
+  }
+  /**
+   * Drop the local records of the sources a resume consumed (present when
+   * resuming on the originating device). M7: each removal carries the LOCAL state
+   * we spent, so a source a concurrent claim reactivated to a NEW state (a
+   * self-send round-trip) is KEPT, not destroyed.
+   */
+  async dropResumedSources(spent, transferId, payload) {
+    const engine = this.deps.tokenEngine;
     for (const genesisId of spent) {
       const local = this.tokens.get(`v2_${genesisId}`);
       if (!local) continue;
@@ -15243,8 +14958,7 @@ var PaymentsModule = class _PaymentsModule {
       let spentOnChain = false;
       try {
         if (local.sdkData) {
-          const decoded = await engine.decodeToken(decodeTokenBlob(hexToBytes4(local.sdkData)));
-          spentOnChain = await engine.isSpent(decoded);
+          spentOnChain = await engine.isSpent(await engine.decodeToken(decodeTokenBlob(hexToBytes4(local.sdkData))));
         }
       } catch {
         spentOnChain = false;
@@ -15258,47 +14972,19 @@ var PaymentsModule = class _PaymentsModule {
         );
       }
     }
-    if (conflicted) {
-      const remaining = undeliveredAmount;
-      const delivered = BigInt(payload.amount) - remaining;
-      await walletApi.completeIntent(transferId);
-      await this.addToHistory({
-        type: "SENT",
-        amount: (delivered > 0n ? delivered : 0n).toString(),
-        coinId: payload.coinId,
-        symbol: this.getCoinSymbol(payload.coinId),
-        timestamp: Date.now(),
-        recipientPubkey: payload.recipient,
-        memo: payload.memo,
-        transferId,
-        tokenId: spent[0] ? `v2_${spent[0]}` : void 0
-      });
-      this.deps.emitEvent("send:partial-remainder", {
-        transferId,
-        remainingAmount: (remaining > 0n ? remaining : 0n).toString(),
-        coinId: payload.coinId,
-        recipientPubkey: payload.recipient
-      });
-      throw new PartialSendConflictError(
-        "Resume: part of the payment was delivered before a source was consumed by a concurrent transfer \u2014 the delivered legs are final; re-plan ONLY the remainder.",
-        transferId,
-        spent,
-        // the DELIVERED genesisIds — never the conflicted leg
-        (remaining > 0n ? remaining : 0n).toString(),
-        firstConflict
-      );
-    }
-    await walletApi.completeIntent(transferId);
+  }
+  /** §10: the SENT record — same dedupKey as the original attempt, so a resume after the history POST is a server-side no-op. */
+  async recordResumedSentHistory(payload, transferId, amount, tokenGenesisId) {
     await this.addToHistory({
       type: "SENT",
-      amount: payload.amount,
+      amount,
       coinId: payload.coinId,
       symbol: this.getCoinSymbol(payload.coinId),
       timestamp: Date.now(),
       recipientPubkey: payload.recipient,
       memo: payload.memo,
       transferId,
-      tokenId: payload.direct[0] ? `v2_${payload.direct[0]}` : void 0
+      tokenId: tokenGenesisId ? `v2_${tokenGenesisId}` : void 0
     });
   }
   // ===========================================================================
@@ -15320,11 +15006,7 @@ var PaymentsModule = class _PaymentsModule {
    */
   async save(opts = {}) {
     const providers = this.getTokenStorageProviders();
-    const tokenStats = Array.from(this.tokens.values()).map((t) => {
-      const txf = tokenToTxf(t);
-      return `${t.id.slice(0, 12)}(${t.status},txf=${!!txf})`;
-    });
-    logger.debug("Payments", `save(): providers=${providers.size}, tokens=[${tokenStats.join(", ")}]`);
+    logger.debug("Payments", `save(): providers=${providers.size}, tokens=${this.tokens.size}`);
     if (providers.size === 0) {
       logger.debug("Payments", "save(): No token storage providers - TXF not persisted");
       return;
@@ -23998,7 +23680,6 @@ import canonicalize from "canonicalize";
 
 // core/address.ts
 var DIRECT_PREFIX = "DIRECT://";
-var PROXY_PREFIX = "PROXY://";
 var NAMETAG_PREFIX = "@";
 function parseAddress(address) {
   if (!address || typeof address !== "string") return null;
@@ -24010,9 +23691,6 @@ function parseAddress(address) {
     }
     return null;
   }
-  if (trimmed.startsWith(PROXY_PREFIX) && trimmed.length > PROXY_PREFIX.length) {
-    return { type: "PROXY", raw: trimmed, value: trimmed.slice(PROXY_PREFIX.length) };
-  }
   if (trimmed.startsWith(NAMETAG_PREFIX)) {
     const value = trimmed.slice(NAMETAG_PREFIX.length);
     if (value.length > 0) {
@@ -24035,8 +23713,6 @@ function normalizeAddress(address) {
   switch (parsed.type) {
     case "DIRECT":
       return `DIRECT://${parsed.value.toLowerCase()}`;
-    case "PROXY":
-      return `PROXY://${parsed.value.toLowerCase()}`;
     case "NAMETAG":
       return `@${parsed.value.toLowerCase()}`;
   }
@@ -27257,444 +26933,94 @@ function parseWalletText(content) {
         return {
           success: false,
           error: "Could not find encrypted master key in backup file"
-        };
-      }
-      return {
-        success: false,
-        needsPassword: true,
-        error: "Password required for encrypted wallet"
-      };
-    }
-    const masterKey = extractFromText(
-      content,
-      /MASTER PRIVATE KEY \(keep secret!\):\s*([^\n]+)/
-    );
-    if (!masterKey) {
-      return {
-        success: false,
-        error: "Could not find master private key in backup file"
-      };
-    }
-    const chainCode = extractFromText(
-      content,
-      /MASTER CHAIN CODE \(for (?:BIP32 HD|Alpha) wallet compatibility\):\s*([^\n]+)/
-    );
-    const descriptorPath = extractFromText(content, /DESCRIPTOR PATH:\s*([^\n]+)/);
-    const isBIP32 = content.includes("WALLET TYPE: BIP32 hierarchical deterministic wallet") || content.includes("WALLET TYPE: Alpha descriptor wallet") || !!chainCode;
-    const effectiveDescriptorPath = descriptorPath ?? (isBIP32 ? "84'/1'/0'" : void 0);
-    const data = {
-      masterKey,
-      chainCode: chainCode ?? void 0,
-      descriptorPath: effectiveDescriptorPath,
-      derivationMode: isBIP32 ? "bip32" : "wif_hmac"
-    };
-    return {
-      success: true,
-      data
-    };
-  } catch (e) {
-    return {
-      success: false,
-      error: `Failed to parse wallet text: ${e instanceof Error ? e.message : String(e)}`
-    };
-  }
-}
-function parseAndDecryptWalletText(content, password) {
-  try {
-    const isEncrypted = isTextWalletEncrypted(content);
-    if (!isEncrypted) {
-      return parseWalletText(content);
-    }
-    const encryptedKey = extractFromText(
-      content,
-      /ENCRYPTED MASTER KEY \(password protected\):\s*([^\n]+)/
-    );
-    if (!encryptedKey) {
-      return {
-        success: false,
-        error: "Could not find encrypted master key in backup file"
-      };
-    }
-    const masterKey = decryptTextFormatKey(encryptedKey, password);
-    if (!masterKey) {
-      return {
-        success: false,
-        error: "Failed to decrypt - incorrect password?"
-      };
-    }
-    const chainCode = extractFromText(
-      content,
-      /MASTER CHAIN CODE \(for (?:BIP32 HD|Alpha) wallet compatibility\):\s*([^\n]+)/
-    );
-    const descriptorPath = extractFromText(content, /DESCRIPTOR PATH:\s*([^\n]+)/);
-    const isBIP32 = content.includes("WALLET TYPE: BIP32 hierarchical deterministic wallet") || content.includes("WALLET TYPE: Alpha descriptor wallet") || !!chainCode;
-    const effectiveDescriptorPath = descriptorPath ?? (isBIP32 ? "84'/1'/0'" : void 0);
-    const data = {
-      masterKey,
-      chainCode: chainCode ?? void 0,
-      descriptorPath: effectiveDescriptorPath,
-      derivationMode: isBIP32 ? "bip32" : "wif_hmac"
-    };
-    return {
-      success: true,
-      data
-    };
-  } catch (e) {
-    return {
-      success: false,
-      error: `Failed to parse/decrypt wallet text: ${e instanceof Error ? e.message : String(e)}`
-    };
-  }
-}
-
-// serialization/wallet-dat.ts
-import CryptoJS4 from "crypto-js";
-function uint8ArrayToWordArray(u8arr) {
-  const hex = bytesToHex4(u8arr);
-  return CryptoJS4.enc.Hex.parse(hex);
-}
-function isSQLiteDatabase(data) {
-  if (data.length < 16) return false;
-  const header = new TextDecoder().decode(data.slice(0, 16));
-  return header.startsWith("SQLite format 3");
-}
-function isWalletDatEncrypted(data) {
-  const mkeyPattern = new TextEncoder().encode("mkey");
-  return findPattern(data, mkeyPattern, 0) !== -1;
-}
-function findAllCMasterKeys(data) {
-  const results = [];
-  for (let pos = 0; pos < data.length - 70; pos++) {
-    if (data[pos] === 48) {
-      const saltLenPos = pos + 1 + 48;
-      if (saltLenPos < data.length && data[saltLenPos] === 8) {
-        const iterPos = saltLenPos + 1 + 8 + 4;
-        if (iterPos + 4 <= data.length) {
-          const iterations = data[iterPos] | data[iterPos + 1] << 8 | data[iterPos + 2] << 16 | data[iterPos + 3] << 24;
-          if (iterations >= 1e3 && iterations <= 1e7) {
-            const encryptedKey = data.slice(pos + 1, pos + 1 + 48);
-            const salt = data.slice(saltLenPos + 1, saltLenPos + 1 + 8);
-            const derivationMethod = data[saltLenPos + 1 + 8] | data[saltLenPos + 1 + 8 + 1] << 8 | data[saltLenPos + 1 + 8 + 2] << 16 | data[saltLenPos + 1 + 8 + 3] << 24;
-            results.push({ encryptedKey, salt, derivationMethod, iterations, position: pos });
-          }
-        }
-      }
-    }
-  }
-  return results;
-}
-function findWpkhDescriptor(data) {
-  const descriptorPattern = new TextEncoder().encode("walletdescriptor");
-  let descriptorIndex = 0;
-  while ((descriptorIndex = findPattern(data, descriptorPattern, descriptorIndex)) !== -1) {
-    let scanPos = descriptorIndex + descriptorPattern.length + 32;
-    const descLen = data[scanPos];
-    scanPos++;
-    const descBytes = data.slice(scanPos, scanPos + Math.min(descLen, 200));
-    let descStr = "";
-    for (let i = 0; i < descBytes.length && descBytes[i] >= 32 && descBytes[i] <= 126; i++) {
-      descStr += String.fromCharCode(descBytes[i]);
-    }
-    if (descStr.startsWith("wpkh(xpub") && descStr.includes("/0/*)")) {
-      const xpubMatch = descStr.match(/xpub[1-9A-HJ-NP-Za-km-z]{100,}/);
-      if (xpubMatch) {
-        const descIdStart = descriptorIndex + descriptorPattern.length;
-        const descriptorId = data.slice(descIdStart, descIdStart + 32);
-        const pathMatch = descStr.match(/\[[\da-f]+\/(\d+'\/\d+'\/\d+')\]/);
-        const descriptorPath = pathMatch ? pathMatch[1] : "84'/1'/0'";
-        return {
-          descriptorId,
-          xpubString: xpubMatch[0],
-          descriptorPath
-        };
-      }
-    }
-    descriptorIndex++;
-  }
-  return { descriptorId: null, xpubString: null, descriptorPath: null };
-}
-function extractChainCodeFromXpub(xpubString) {
-  const decoded = base58Decode(xpubString);
-  return bytesToHex4(decoded.slice(13, 45));
-}
-function findMasterChainCode(data) {
-  const xpubPattern = new TextEncoder().encode("xpub");
-  const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-  let searchPos = 0;
-  while (searchPos < data.length) {
-    const xpubIndex = findPattern(data, xpubPattern, searchPos);
-    if (xpubIndex === -1) break;
-    let xpubStr = "xpub";
-    let pos = xpubIndex + 4;
-    while (pos < data.length && xpubStr.length < 120) {
-      const char = String.fromCharCode(data[pos]);
-      if (base58Chars.includes(char)) {
-        xpubStr += char;
-        pos++;
-      } else {
-        break;
-      }
-    }
-    if (xpubStr.length > 100) {
-      try {
-        const decoded = base58Decode(xpubStr);
-        const depth = decoded[4];
-        if (depth === 0) {
-          return bytesToHex4(decoded.slice(13, 45));
-        }
-      } catch {
-      }
-    }
-    searchPos = xpubIndex + 4;
-  }
-  return null;
-}
-function extractDescriptorKeys(data) {
-  const keys = [];
-  const descriptorKeyPattern = new TextEncoder().encode("walletdescriptorkey");
-  let index = 0;
-  while ((index = findPattern(data, descriptorKeyPattern, index)) !== -1) {
-    for (let checkPos = index + descriptorKeyPattern.length; checkPos < Math.min(index + descriptorKeyPattern.length + 200, data.length - 40); checkPos++) {
-      if (data[checkPos] === 211 && data[checkPos + 1] === 2 && data[checkPos + 2] === 1 && data[checkPos + 3] === 1 && data[checkPos + 4] === 4 && data[checkPos + 5] === 32) {
-        const privKey = data.slice(checkPos + 6, checkPos + 38);
-        const privKeyHex = bytesToHex4(privKey);
-        if (isValidPrivateKey(privKeyHex)) {
-          keys.push(privKeyHex);
-          break;
-        }
-      }
-    }
-    index++;
-  }
-  return keys;
-}
-function extractLegacyKeys(data) {
-  const keys = [];
-  const keyPattern = new TextEncoder().encode("key");
-  let index = 0;
-  while ((index = findPattern(data, keyPattern, index)) !== -1) {
-    const searchPattern = new Uint8Array([4, 32]);
-    for (let i = index; i < Math.min(index + 200, data.length - 34); i++) {
-      if (data[i] === searchPattern[0] && data[i + 1] === searchPattern[1]) {
-        const privKey = data.slice(i + 2, i + 34);
-        const privKeyHex = bytesToHex4(privKey);
-        if (isValidPrivateKey(privKeyHex)) {
-          keys.push(privKeyHex);
-          break;
-        }
-      }
-    }
-    index++;
-  }
-  return keys;
-}
-function findEncryptedKeyForDescriptor(data, descriptorId) {
-  const ckeyPattern = new TextEncoder().encode("walletdescriptorckey");
-  let ckeyIndex = findPattern(data, ckeyPattern, 0);
-  while (ckeyIndex !== -1) {
-    const recordDescId = data.slice(ckeyIndex + ckeyPattern.length, ckeyIndex + ckeyPattern.length + 32);
-    if (Array.from(recordDescId).every((b, i) => b === descriptorId[i])) {
-      let keyPos = ckeyIndex + ckeyPattern.length + 32;
-      const pubkeyLen = data[keyPos];
-      keyPos++;
-      const pubkey = data.slice(keyPos, keyPos + pubkeyLen);
-      for (let searchPos = keyPos + pubkeyLen; searchPos < Math.min(keyPos + pubkeyLen + 100, data.length - 50); searchPos++) {
-        const valueLen = data[searchPos];
-        if (valueLen >= 32 && valueLen <= 64) {
-          const encryptedKey = data.slice(searchPos + 1, searchPos + 1 + valueLen);
-          return { pubkey, encryptedKey };
-        }
-      }
-    }
-    ckeyIndex = findPattern(data, ckeyPattern, ckeyIndex + 1);
-  }
-  return null;
-}
-async function decryptCMasterKey(cmk, password, onProgress) {
-  const { encryptedKey, salt, iterations } = cmk;
-  const passwordHex = bytesToHex4(new TextEncoder().encode(password));
-  const saltHex = bytesToHex4(salt);
-  const inputHex = passwordHex + saltHex;
-  let hash = CryptoJS4.SHA512(CryptoJS4.enc.Hex.parse(inputHex));
-  const BATCH_SIZE = 1e3;
-  for (let i = 0; i < iterations - 1; i++) {
-    hash = CryptoJS4.SHA512(hash);
-    if (onProgress && i % BATCH_SIZE === 0) {
-      await onProgress(i, iterations);
-    }
-  }
-  const derivedKey = CryptoJS4.lib.WordArray.create(hash.words.slice(0, 8));
-  const derivedIv = CryptoJS4.lib.WordArray.create(hash.words.slice(8, 12));
-  const encryptedWords = uint8ArrayToWordArray(encryptedKey);
-  const decrypted = CryptoJS4.AES.decrypt(
-    { ciphertext: encryptedWords },
-    derivedKey,
-    { iv: derivedIv, padding: CryptoJS4.pad.Pkcs7, mode: CryptoJS4.mode.CBC }
-  );
-  const result = CryptoJS4.enc.Hex.stringify(decrypted);
-  if (!result || result.length !== 64) {
-    throw new SphereError("Master key decryption failed - incorrect password", "DECRYPTION_ERROR");
-  }
-  return result;
-}
-function decryptPrivateKey(encryptedKey, pubkey, masterKeyHex) {
-  const pubkeyWords = uint8ArrayToWordArray(pubkey);
-  const pubkeyHashWords = CryptoJS4.SHA256(CryptoJS4.SHA256(pubkeyWords));
-  const ivWords = CryptoJS4.lib.WordArray.create(pubkeyHashWords.words.slice(0, 4));
-  const masterKeyWords = CryptoJS4.enc.Hex.parse(masterKeyHex);
-  const encryptedWords = uint8ArrayToWordArray(encryptedKey);
-  const decrypted = CryptoJS4.AES.decrypt(
-    { ciphertext: encryptedWords },
-    masterKeyWords,
-    { iv: ivWords, padding: CryptoJS4.pad.Pkcs7, mode: CryptoJS4.mode.CBC }
-  );
-  return CryptoJS4.enc.Hex.stringify(decrypted);
-}
-function parseWalletDat(data) {
-  if (!isSQLiteDatabase(data)) {
-    return {
-      success: false,
-      error: "Invalid wallet.dat file - not an SQLite database"
-    };
-  }
-  const isEncrypted = isWalletDatEncrypted(data);
-  const cmasterKeys = isEncrypted ? findAllCMasterKeys(data) : [];
-  const descriptorKeys = isEncrypted ? [] : extractDescriptorKeys(data);
-  const legacyKeys = isEncrypted ? [] : extractLegacyKeys(data);
-  const { descriptorId: _descriptorId, xpubString, descriptorPath } = findWpkhDescriptor(data);
-  void _descriptorId;
-  let chainCode = null;
-  if (xpubString) {
-    try {
-      chainCode = extractChainCodeFromXpub(xpubString);
-    } catch {
-      chainCode = findMasterChainCode(data);
-    }
-  } else {
-    chainCode = findMasterChainCode(data);
-  }
-  if (!isEncrypted) {
-    let masterKey = null;
-    if (descriptorKeys.length > 0) {
-      masterKey = descriptorKeys[0];
-    } else if (legacyKeys.length > 0) {
-      masterKey = legacyKeys[0];
-    }
-    if (masterKey) {
-      const parsedData = {
-        masterKey,
-        chainCode: chainCode ?? void 0,
-        descriptorPath: descriptorPath ?? "84'/1'/0'",
-        derivationMode: chainCode ? "bip32" : "wif_hmac"
+        };
+      }
+      return {
+        success: false,
+        needsPassword: true,
+        error: "Password required for encrypted wallet"
       };
+    }
+    const masterKey = extractFromText(
+      content,
+      /MASTER PRIVATE KEY \(keep secret!\):\s*([^\n]+)/
+    );
+    if (!masterKey) {
       return {
-        success: true,
-        data: parsedData
+        success: false,
+        error: "Could not find master private key in backup file"
       };
     }
-    return {
-      success: false,
-      error: "No valid private keys found in wallet.dat file"
-    };
-  }
-  if (cmasterKeys.length === 0) {
-    return {
-      success: false,
-      error: "Encrypted wallet but no CMasterKey structures found"
+    const chainCode = extractFromText(
+      content,
+      /MASTER CHAIN CODE \(for (?:BIP32 HD|Alpha) wallet compatibility\):\s*([^\n]+)/
+    );
+    const descriptorPath = extractFromText(content, /DESCRIPTOR PATH:\s*([^\n]+)/);
+    const isBIP32 = content.includes("WALLET TYPE: BIP32 hierarchical deterministic wallet") || content.includes("WALLET TYPE: Alpha descriptor wallet") || !!chainCode;
+    const effectiveDescriptorPath = descriptorPath ?? (isBIP32 ? "84'/1'/0'" : void 0);
+    const data = {
+      masterKey,
+      chainCode: chainCode ?? void 0,
+      descriptorPath: effectiveDescriptorPath,
+      derivationMode: isBIP32 ? "bip32" : "wif_hmac"
     };
-  }
-  const firstCmk = cmasterKeys[0];
-  return {
-    success: false,
-    needsPassword: true,
-    encryptionInfo: {
-      iterations: firstCmk.iterations,
-      salt: firstCmk.salt,
-      encryptedKey: firstCmk.encryptedKey
-    },
-    error: "Password required for encrypted wallet"
-  };
-}
-async function parseAndDecryptWalletDat(data, password, onProgress) {
-  if (!isSQLiteDatabase(data)) {
     return {
-      success: false,
-      error: "Invalid wallet.dat file - not an SQLite database"
+      success: true,
+      data
     };
-  }
-  const isEncrypted = isWalletDatEncrypted(data);
-  if (!isEncrypted) {
-    return parseWalletDat(data);
-  }
-  const cmasterKeys = findAllCMasterKeys(data);
-  if (cmasterKeys.length === 0) {
+  } catch (e) {
     return {
       success: false,
-      error: "Encrypted wallet but no CMasterKey structures found"
+      error: `Failed to parse wallet text: ${e instanceof Error ? e.message : String(e)}`
     };
   }
-  let masterKeyHex = null;
-  for (const cmk of cmasterKeys) {
-    try {
-      masterKeyHex = await decryptCMasterKey(cmk, password, onProgress);
-      if (masterKeyHex && masterKeyHex.length === 64) {
-        break;
-      }
-    } catch {
-      continue;
+}
+function parseAndDecryptWalletText(content, password) {
+  try {
+    const isEncrypted = isTextWalletEncrypted(content);
+    if (!isEncrypted) {
+      return parseWalletText(content);
     }
-  }
-  if (!masterKeyHex || masterKeyHex.length !== 64) {
-    return {
-      success: false,
-      error: "Master key decryption failed - incorrect password"
-    };
-  }
-  const { descriptorId, xpubString, descriptorPath } = findWpkhDescriptor(data);
-  let chainCode = null;
-  if (xpubString) {
-    try {
-      chainCode = extractChainCodeFromXpub(xpubString);
-    } catch {
-      chainCode = findMasterChainCode(data);
+    const encryptedKey = extractFromText(
+      content,
+      /ENCRYPTED MASTER KEY \(password protected\):\s*([^\n]+)/
+    );
+    if (!encryptedKey) {
+      return {
+        success: false,
+        error: "Could not find encrypted master key in backup file"
+      };
     }
-  } else {
-    chainCode = findMasterChainCode(data);
-  }
-  if (!descriptorId) {
-    return {
-      success: false,
-      error: "Could not find native SegWit receive descriptor"
+    const masterKey = decryptTextFormatKey(encryptedKey, password);
+    if (!masterKey) {
+      return {
+        success: false,
+        error: "Failed to decrypt - incorrect password?"
+      };
+    }
+    const chainCode = extractFromText(
+      content,
+      /MASTER CHAIN CODE \(for (?:BIP32 HD|Alpha) wallet compatibility\):\s*([^\n]+)/
+    );
+    const descriptorPath = extractFromText(content, /DESCRIPTOR PATH:\s*([^\n]+)/);
+    const isBIP32 = content.includes("WALLET TYPE: BIP32 hierarchical deterministic wallet") || content.includes("WALLET TYPE: Alpha descriptor wallet") || !!chainCode;
+    const effectiveDescriptorPath = descriptorPath ?? (isBIP32 ? "84'/1'/0'" : void 0);
+    const data = {
+      masterKey,
+      chainCode: chainCode ?? void 0,
+      descriptorPath: effectiveDescriptorPath,
+      derivationMode: isBIP32 ? "bip32" : "wif_hmac"
     };
-  }
-  const encryptedKeyData = findEncryptedKeyForDescriptor(data, descriptorId);
-  if (!encryptedKeyData) {
     return {
-      success: false,
-      error: "Could not find encrypted private key for descriptor"
+      success: true,
+      data
     };
-  }
-  const bip32MasterKey = decryptPrivateKey(
-    encryptedKeyData.encryptedKey,
-    encryptedKeyData.pubkey,
-    masterKeyHex
-  );
-  if (!bip32MasterKey || bip32MasterKey.length !== 64) {
+  } catch (e) {
     return {
       success: false,
-      error: "Could not decrypt BIP32 master private key"
+      error: `Failed to parse/decrypt wallet text: ${e instanceof Error ? e.message : String(e)}`
     };
   }
-  const parsedData = {
-    masterKey: bip32MasterKey,
-    chainCode: chainCode ?? void 0,
-    descriptorPath: descriptorPath ?? "84'/1'/0'",
-    derivationMode: "bip32"
-  };
-  return {
-    success: true,
-    data: parsedData
-  };
 }
 
 // core/Sphere.ts
@@ -28527,32 +27853,196 @@ var Sphere = class _Sphere {
     if (this._transport.isConnected() && this._transport.fetchPendingEvents) {
       await this._transport.fetchPendingEvents();
     }
-  }
-  getAggregator() {
-    return this._oracle;
+  }
+  getAggregator() {
+    return this._oracle;
+  }
+  /**
+   * Apply a new gateway API key to the LIVE oracle + token engine WITHOUT a full
+   * Sphere rebuild (transport / realtime socket / discovery stay up). Use this to
+   * inject a per-wallet subscription key provisioned AFTER init, or a per-address
+   * key on an address switch, so the next money operation authenticates with it.
+   *
+   * Money-safety: the running token engine is snapshotted per-operation (the
+   * payments module reads `deps.tokenEngine` into a local at op start), so an
+   * in-flight send/mint completes on the OLD key (submit + proof stay paired on
+   * one client) and only operations started AFTER this call use the new key.
+   * Only the ACTIVE address's engine is rebuilt — other tracked addresses re-key
+   * on their next switch/build. No-op-safe if the engine can't be built (the
+   * modules fall back to their legacy path, same as init).
+   */
+  async setOracleApiKey(apiKey) {
+    this._oracle.setApiKey?.(apiKey);
+    const active = this._addressModules.get(this._currentAddressIndex);
+    const replaced = active?.tokenEngine ?? this._tokenEngine;
+    this._tokenEngine = await this.buildTokenEngine();
+    if (active) active.tokenEngine = this._tokenEngine;
+    this._payments.setTokenEngine(this._tokenEngine);
+    if (replaced && replaced !== this._tokenEngine) replaced.dispose?.();
+  }
+  /**
+   * Import a wallet from a backup file: a `UNICITY WALLET DETAILS` text backup
+   * (the format `exportToTxt` writes, optionally password-encrypted), a legacy
+   * flat-JSON webwallet export, or a bare mnemonic in a text file.
+   *
+   * @example
+   * const result = await Sphere.importFromLegacyFile({
+   *   fileContent: await file.text(),
+   *   fileName: file.name,
+   *   password,          // when the backup is encrypted
+   *   ...providers,
+   * });
+   */
+  static async importFromLegacyFile(options) {
+    const { fileContent, fileName, password, onDecryptProgress, ...baseOptions } = options;
+    const fileType = _Sphere.detectLegacyFileType(fileName, fileContent);
+    if (fileType === "unknown") {
+      return { success: false, error: "Unknown file format" };
+    }
+    if (fileType === "mnemonic") {
+      const mnemonic = fileContent.trim().toLowerCase().split(/\s+/).join(" ");
+      if (!_Sphere.validateMnemonic(mnemonic)) {
+        return { success: false, error: "Invalid mnemonic phrase" };
+      }
+      const sphere = await _Sphere.import({ ...baseOptions, mnemonic });
+      return { success: true, sphere, mnemonic };
+    }
+    if (fileType === "txt") {
+      const content = fileContent;
+      let parseResult;
+      if (password) {
+        parseResult = parseAndDecryptWalletText(content, password);
+      } else if (isTextWalletEncrypted(content)) {
+        return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
+      } else {
+        parseResult = parseWalletText(content);
+      }
+      if (parseResult.needsPassword && !password) {
+        return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
+      }
+      if (!parseResult.success || !parseResult.data) {
+        return { success: false, error: parseResult.error };
+      }
+      const { masterKey, chainCode, descriptorPath, derivationMode } = parseResult.data;
+      const basePath = descriptorPath ? `m/${descriptorPath}` : DEFAULT_BASE_PATH;
+      const sphere = await _Sphere.import({
+        ...baseOptions,
+        masterKey,
+        chainCode,
+        basePath,
+        derivationMode: derivationMode || (chainCode ? "bip32" : "wif_hmac")
+      });
+      return { success: true, sphere };
+    }
+    if (fileType === "json") {
+      const content = fileContent;
+      let parsed;
+      try {
+        parsed = JSON.parse(content);
+      } catch {
+        return { success: false, error: "Invalid JSON file" };
+      }
+      if (parsed.type === "sphere-wallet") {
+        const result = await _Sphere.importFromJSON({
+          ...baseOptions,
+          jsonContent: content,
+          password
+        });
+        if (result.success) {
+          const sphere2 = _Sphere.getInstance();
+          return { success: true, sphere: sphere2, mnemonic: result.mnemonic };
+        }
+        if (!password && result.error?.includes("Password required")) {
+          return { success: false, needsPassword: true, error: result.error };
+        }
+        return { success: false, error: result.error };
+      }
+      let masterKey;
+      let mnemonic;
+      if (parsed.encrypted && typeof parsed.encrypted === "object") {
+        if (!password) {
+          return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
+        }
+        const enc = parsed.encrypted;
+        if (!enc.salt || !enc.masterPrivateKey) {
+          return { success: false, error: "Invalid encrypted wallet format" };
+        }
+        const decryptedKey = decryptWithSalt(enc.masterPrivateKey, password, enc.salt);
+        if (!decryptedKey) {
+          return { success: false, error: "Failed to decrypt - incorrect password?" };
+        }
+        masterKey = decryptedKey;
+        if (enc.mnemonic) {
+          mnemonic = decryptWithSalt(enc.mnemonic, password, enc.salt) ?? void 0;
+        }
+      } else {
+        masterKey = parsed.masterPrivateKey;
+        mnemonic = parsed.mnemonic;
+      }
+      if (!masterKey) {
+        return { success: false, error: "No master key found in wallet JSON" };
+      }
+      const chainCode = parsed.chainCode;
+      const descriptorPath = parsed.descriptorPath;
+      const derivationMode = parsed.derivationMode;
+      const isBIP32 = derivationMode === "bip32" || !!chainCode;
+      const basePath = descriptorPath ? `m/${descriptorPath}` : isBIP32 ? "m/84'/1'/0'" : DEFAULT_BASE_PATH;
+      if (mnemonic) {
+        const sphere2 = await _Sphere.import({ ...baseOptions, mnemonic, basePath });
+        return { success: true, sphere: sphere2, mnemonic };
+      }
+      const sphere = await _Sphere.import({
+        ...baseOptions,
+        masterKey,
+        chainCode,
+        basePath,
+        derivationMode: derivationMode || (chainCode ? "bip32" : "wif_hmac")
+      });
+      return { success: true, sphere };
+    }
+    return { success: false, error: "Unsupported file type" };
+  }
+  /**
+   * Detect legacy file type from filename and content
+   */
+  static detectLegacyFileType(fileName, content) {
+    if (fileName.endsWith(".json")) {
+      return "json";
+    }
+    try {
+      const trimmed = content.trim();
+      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        JSON.parse(trimmed);
+        return "json";
+      }
+    } catch {
+    }
+    const words = content.trim().split(/\s+/);
+    if ((words.length === 12 || words.length === 24) && words.every((w) => /^[a-z]+$/.test(w.toLowerCase()))) {
+      return "mnemonic";
+    }
+    if (isWalletTextFormat(content)) {
+      return "txt";
+    }
+    return "unknown";
   }
   /**
-   * Apply a new gateway API key to the LIVE oracle + token engine WITHOUT a full
-   * Sphere rebuild (transport / realtime socket / discovery stay up). Use this to
-   * inject a per-wallet subscription key provisioned AFTER init, or a per-address
-   * key on an address switch, so the next money operation authenticates with it.
-   *
-   * Money-safety: the running token engine is snapshotted per-operation (the
-   * payments module reads `deps.tokenEngine` into a local at op start), so an
-   * in-flight send/mint completes on the OLD key (submit + proof stay paired on
-   * one client) and only operations started AFTER this call use the new key.
-   * Only the ACTIVE address's engine is rebuilt — other tracked addresses re-key
-   * on their next switch/build. No-op-safe if the engine can't be built (the
-   * modules fall back to their legacy path, same as init).
+   * Check if a legacy file is encrypted
    */
-  async setOracleApiKey(apiKey) {
-    this._oracle.setApiKey?.(apiKey);
-    const active = this._addressModules.get(this._currentAddressIndex);
-    const replaced = active?.tokenEngine ?? this._tokenEngine;
-    this._tokenEngine = await this.buildTokenEngine();
-    if (active) active.tokenEngine = this._tokenEngine;
-    this._payments.setTokenEngine(this._tokenEngine);
-    if (replaced && replaced !== this._tokenEngine) replaced.dispose?.();
+  static isLegacyFileEncrypted(fileName, content) {
+    const fileType = _Sphere.detectLegacyFileType(fileName, content);
+    if (fileType === "txt") {
+      return isTextWalletEncrypted(content);
+    }
+    if (fileType === "json") {
+      try {
+        const data = JSON.parse(content);
+        return !!data.encrypted;
+      } catch {
+        return false;
+      }
+    }
+    return false;
   }
   /**
    * Check if wallet has BIP32 master key for HD derivation
@@ -28824,224 +28314,6 @@ var Sphere = class _Sphere {
       };
     }
   }
-  /**
-   * Import wallet from legacy file (.dat, .txt, or mnemonic text)
-   *
-   * Supports:
-   * - Bitcoin Core wallet.dat files (SQLite format, encrypted or unencrypted)
-   * - Text backup files (UNICITY WALLET DETAILS format)
-   * - Plain mnemonic text (12 or 24 words)
-   *
-   * @returns Object with success status, created Sphere instance, and optionally recovered mnemonic
-   *
-   * @example
-   * ```ts
-   * // Import from .dat file
-   * const fileBuffer = await file.arrayBuffer();
-   * const result = await Sphere.importFromLegacyFile({
-   *   fileContent: new Uint8Array(fileBuffer),
-   *   fileName: 'wallet.dat',
-   *   password: 'wallet-password', // if encrypted
-   *   storage, transport, oracle,
-   * });
-   *
-   * // Import from .txt file
-   * const textContent = await file.text();
-   * const result = await Sphere.importFromLegacyFile({
-   *   fileContent: textContent,
-   *   fileName: 'backup.txt',
-   *   storage, transport, oracle,
-   * });
-   * ```
-   */
-  static async importFromLegacyFile(options) {
-    const { fileContent, fileName, password, onDecryptProgress, ...baseOptions } = options;
-    const fileType = _Sphere.detectLegacyFileType(fileName, fileContent);
-    if (fileType === "unknown") {
-      return { success: false, error: "Unknown file format" };
-    }
-    if (fileType === "mnemonic") {
-      const mnemonic = fileContent.trim().toLowerCase().split(/\s+/).join(" ");
-      if (!_Sphere.validateMnemonic(mnemonic)) {
-        return { success: false, error: "Invalid mnemonic phrase" };
-      }
-      const sphere = await _Sphere.import({ ...baseOptions, mnemonic });
-      return { success: true, sphere, mnemonic };
-    }
-    if (fileType === "dat") {
-      const data = fileContent instanceof Uint8Array ? fileContent : new TextEncoder().encode(fileContent);
-      let parseResult;
-      if (password) {
-        parseResult = await parseAndDecryptWalletDat(data, password, onDecryptProgress);
-      } else {
-        parseResult = parseWalletDat(data);
-      }
-      if (parseResult.needsPassword && !password) {
-        return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
-      }
-      if (!parseResult.success || !parseResult.data) {
-        return { success: false, error: parseResult.error };
-      }
-      const { masterKey, chainCode, descriptorPath, derivationMode } = parseResult.data;
-      const basePath = descriptorPath ? `m/${descriptorPath}` : DEFAULT_BASE_PATH;
-      const sphere = await _Sphere.import({
-        ...baseOptions,
-        masterKey,
-        chainCode,
-        basePath,
-        derivationMode: derivationMode || (chainCode ? "bip32" : "wif_hmac")
-      });
-      return { success: true, sphere };
-    }
-    if (fileType === "txt") {
-      const content = typeof fileContent === "string" ? fileContent : new TextDecoder().decode(fileContent);
-      let parseResult;
-      if (password) {
-        parseResult = parseAndDecryptWalletText(content, password);
-      } else if (isTextWalletEncrypted(content)) {
-        return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
-      } else {
-        parseResult = parseWalletText(content);
-      }
-      if (parseResult.needsPassword && !password) {
-        return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
-      }
-      if (!parseResult.success || !parseResult.data) {
-        return { success: false, error: parseResult.error };
-      }
-      const { masterKey, chainCode, descriptorPath, derivationMode } = parseResult.data;
-      const basePath = descriptorPath ? `m/${descriptorPath}` : DEFAULT_BASE_PATH;
-      const sphere = await _Sphere.import({
-        ...baseOptions,
-        masterKey,
-        chainCode,
-        basePath,
-        derivationMode: derivationMode || (chainCode ? "bip32" : "wif_hmac")
-      });
-      return { success: true, sphere };
-    }
-    if (fileType === "json") {
-      const content = typeof fileContent === "string" ? fileContent : new TextDecoder().decode(fileContent);
-      let parsed;
-      try {
-        parsed = JSON.parse(content);
-      } catch {
-        return { success: false, error: "Invalid JSON file" };
-      }
-      if (parsed.type === "sphere-wallet") {
-        const result = await _Sphere.importFromJSON({
-          ...baseOptions,
-          jsonContent: content,
-          password
-        });
-        if (result.success) {
-          const sphere2 = _Sphere.getInstance();
-          return { success: true, sphere: sphere2, mnemonic: result.mnemonic };
-        }
-        if (!password && result.error?.includes("Password required")) {
-          return { success: false, needsPassword: true, error: result.error };
-        }
-        return { success: false, error: result.error };
-      }
-      let masterKey;
-      let mnemonic;
-      if (parsed.encrypted && typeof parsed.encrypted === "object") {
-        if (!password) {
-          return { success: false, needsPassword: true, error: "Password required for encrypted wallet" };
-        }
-        const enc = parsed.encrypted;
-        if (!enc.salt || !enc.masterPrivateKey) {
-          return { success: false, error: "Invalid encrypted wallet format" };
-        }
-        const decryptedKey = decryptWithSalt(enc.masterPrivateKey, password, enc.salt);
-        if (!decryptedKey) {
-          return { success: false, error: "Failed to decrypt - incorrect password?" };
-        }
-        masterKey = decryptedKey;
-        if (enc.mnemonic) {
-          mnemonic = decryptWithSalt(enc.mnemonic, password, enc.salt) ?? void 0;
-        }
-      } else {
-        masterKey = parsed.masterPrivateKey;
-        mnemonic = parsed.mnemonic;
-      }
-      if (!masterKey) {
-        return { success: false, error: "No master key found in wallet JSON" };
-      }
-      const chainCode = parsed.chainCode;
-      const descriptorPath = parsed.descriptorPath;
-      const derivationMode = parsed.derivationMode;
-      const isBIP32 = derivationMode === "bip32" || !!chainCode;
-      const basePath = descriptorPath ? `m/${descriptorPath}` : isBIP32 ? "m/84'/1'/0'" : DEFAULT_BASE_PATH;
-      if (mnemonic) {
-        const sphere2 = await _Sphere.import({ ...baseOptions, mnemonic, basePath });
-        return { success: true, sphere: sphere2, mnemonic };
-      }
-      const sphere = await _Sphere.import({
-        ...baseOptions,
-        masterKey,
-        chainCode,
-        basePath,
-        derivationMode: derivationMode || (chainCode ? "bip32" : "wif_hmac")
-      });
-      return { success: true, sphere };
-    }
-    return { success: false, error: "Unsupported file type" };
-  }
-  /**
-   * Detect legacy file type from filename and content
-   */
-  static detectLegacyFileType(fileName, content) {
-    if (fileName.endsWith(".dat")) {
-      return "dat";
-    }
-    const textContent = typeof content === "string" ? content : content.length < 1e3 ? new TextDecoder().decode(content) : "";
-    if (fileName.endsWith(".json")) {
-      return "json";
-    }
-    try {
-      const trimmed = textContent.trim();
-      if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
-        JSON.parse(trimmed);
-        return "json";
-      }
-    } catch {
-    }
-    const words = textContent.trim().split(/\s+/);
-    if ((words.length === 12 || words.length === 24) && words.every((w) => /^[a-z]+$/.test(w.toLowerCase()))) {
-      return "mnemonic";
-    }
-    if (isWalletTextFormat(textContent)) {
-      return "txt";
-    }
-    if (content instanceof Uint8Array && isSQLiteDatabase(content)) {
-      return "dat";
-    }
-    return "unknown";
-  }
-  /**
-   * Check if a legacy file is encrypted
-   */
-  static isLegacyFileEncrypted(fileName, content) {
-    const fileType = _Sphere.detectLegacyFileType(fileName, content);
-    if (fileType === "dat" && content instanceof Uint8Array) {
-      return isWalletDatEncrypted(content);
-    }
-    if (fileType === "txt") {
-      const textContent = typeof content === "string" ? content : new TextDecoder().decode(content);
-      return isTextWalletEncrypted(textContent);
-    }
-    if (fileType === "json") {
-      try {
-        const textContent = typeof content === "string" ? content : new TextDecoder().decode(content);
-        const data = JSON.parse(textContent);
-        return !!data.encrypted;
-      } catch {
-        return false;
-      }
-    }
-    return false;
-  }
   /**
    * Get the current active address index
    *
@@ -30946,116 +30218,6 @@ function formatAmount(amount, options = {}) {
   return symbol ? `${readable} ${symbol}` : readable;
 }
 
-// core/bech32.ts
-var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-var GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
-function convertBits(data, fromBits, toBits, pad) {
-  let acc = 0;
-  let bits = 0;
-  const ret = [];
-  const maxv = (1 << toBits) - 1;
-  for (let i = 0; i < data.length; i++) {
-    const value = data[i];
-    if (value < 0 || value >> fromBits !== 0) return null;
-    acc = acc << fromBits | value;
-    bits += fromBits;
-    while (bits >= toBits) {
-      bits -= toBits;
-      ret.push(acc >> bits & maxv);
-    }
-  }
-  if (pad) {
-    if (bits > 0) {
-      ret.push(acc << toBits - bits & maxv);
-    }
-  } else if (bits >= fromBits || acc << toBits - bits & maxv) {
-    return null;
-  }
-  return ret;
-}
-function hrpExpand(hrp) {
-  const ret = [];
-  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) >> 5);
-  ret.push(0);
-  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) & 31);
-  return ret;
-}
-function bech32Polymod(values) {
-  let chk = 1;
-  for (let p = 0; p < values.length; p++) {
-    const top = chk >> 25;
-    chk = (chk & 33554431) << 5 ^ values[p];
-    for (let i = 0; i < 5; i++) {
-      if (top >> i & 1) chk ^= GENERATOR[i];
-    }
-  }
-  return chk;
-}
-function bech32Checksum(hrp, data) {
-  const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
-  const mod2 = bech32Polymod(values) ^ 1;
-  const ret = [];
-  for (let p = 0; p < 6; p++) {
-    ret.push(mod2 >> 5 * (5 - p) & 31);
-  }
-  return ret;
-}
-function encodeBech32(hrp, version, program) {
-  if (version < 0 || version > 16) {
-    throw new SphereError("Invalid witness version", "VALIDATION_ERROR");
-  }
-  const converted = convertBits(Array.from(program), 8, 5, true);
-  if (!converted) {
-    throw new SphereError("Failed to convert bits", "VALIDATION_ERROR");
-  }
-  const data = [version].concat(converted);
-  const checksum = bech32Checksum(hrp, data);
-  const combined = data.concat(checksum);
-  let out = hrp + "1";
-  for (let i = 0; i < combined.length; i++) {
-    out += CHARSET[combined[i]];
-  }
-  return out;
-}
-function decodeBech32(addr) {
-  addr = addr.toLowerCase();
-  const pos = addr.lastIndexOf("1");
-  if (pos < 1) return null;
-  const hrp = addr.substring(0, pos);
-  const dataStr = addr.substring(pos + 1);
-  const data = [];
-  for (let i = 0; i < dataStr.length; i++) {
-    const val = CHARSET.indexOf(dataStr[i]);
-    if (val === -1) return null;
-    data.push(val);
-  }
-  const checksum = bech32Checksum(hrp, data.slice(0, -6));
-  for (let i = 0; i < 6; i++) {
-    if (checksum[i] !== data[data.length - 6 + i]) {
-      return null;
-    }
-  }
-  const version = data[0];
-  const program = convertBits(data.slice(1, -6), 5, 8, false);
-  if (!program) return null;
-  return {
-    hrp,
-    witnessVersion: version,
-    data: Uint8Array.from(program)
-  };
-}
-function createAddress(hrp, pubkeyHash) {
-  const hashBytes = typeof pubkeyHash === "string" ? Uint8Array.from(Buffer.from(pubkeyHash, "hex")) : pubkeyHash;
-  return encodeBech32(hrp, 1, hashBytes);
-}
-function isValidBech32(addr) {
-  return decodeBech32(addr) !== null;
-}
-function getAddressHrp(addr) {
-  const result = decodeBech32(addr);
-  return result?.hrp ?? null;
-}
-
 // core/network-health.ts
 var DEFAULT_TIMEOUT_MS = 5e3;
 async function checkNetworkHealth(network = "testnet", options) {
@@ -31240,7 +30402,7 @@ async function runCustomCheck(name, checkFn, timeoutMs) {
 
 // storage/whole-blob-inventory-adapter.ts
 var TOKEN_KEY_RE = /^_[0-9a-f]{4,}$/i;
-function bytesToHex6(bytes) {
+function bytesToHex5(bytes) {
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
 function hexToBytes6(hex) {
@@ -31350,7 +30512,7 @@ var WholeBlobInventoryAdapter = class {
       if (isV2TokenEntry2(entry)) {
         try {
           const blob = decodeTokenBlob(hexToBytes6(entry.sdkData));
-          stateHash = bytesToHex6(sha256(blob.token));
+          stateHash = bytesToHex5(sha256(blob.token));
         } catch {
         }
       }
@@ -31375,7 +30537,7 @@ function hexToBytes7(hex) {
   for (let i = 0; i < out.length; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
   return out;
 }
-function bytesToHex7(bytes) {
+function bytesToHex6(bytes) {
   return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 }
 function computeDeliveryId(tokenIdHex, stateHashHex) {
@@ -31384,7 +30546,7 @@ function computeDeliveryId(tokenIdHex, stateHashHex) {
   const joined = new Uint8Array(tokenId.length + stateHash.length);
   joined.set(tokenId, 0);
   joined.set(stateHash, tokenId.length);
-  return bytesToHex7(sha256(joined));
+  return bytesToHex6(sha256(joined));
 }
 function composeDeliveryKeys(keys) {
   return { ...keys, deliveryId: computeDeliveryId(keys.tokenId, keys.stateHash) };
@@ -31794,7 +30956,6 @@ export {
   WalletApiError,
   WholeBlobInventoryAdapter,
   addressesMatch,
-  archivedKeyFromTokenId,
   areSameNametag,
   assertFieldEnvelopeShape,
   base58Decode,
@@ -31807,8 +30968,6 @@ export {
   composeDeliveryKeys,
   computeDeliveryId,
   computeSwapId,
-  countCommittedTransactions,
-  createAddress,
   createCommunicationsModule,
   createGroupChatModule,
   createKeyPair,
@@ -31819,15 +30978,12 @@ export {
   createSphere,
   createSwapModule,
   createTokenValidator,
-  decodeBech32,
   decrypt,
-  decryptCMasterKey,
   decryptField,
   decryptFieldBytes,
   decryptJson,
   decryptMnemonic,
   decryptNametag2 as decryptNametag,
-  decryptPrivateKey,
   decryptSimple,
   decryptTextFormatKey,
   decryptWithSalt,
@@ -31836,7 +30992,6 @@ export {
   deriveFieldEncryptionKey,
   deriveKeyAtPath,
   doubleSha256,
-  encodeBech32,
   encrypt,
   encryptField,
   encryptFieldBytes,
@@ -31845,28 +31000,21 @@ export {
   encryptSimple,
   extractFromText,
   findPattern,
-  forkedKeyFromTokenIdAndState,
   formatAmount,
   generateAddressFromMasterKey,
   generateMasterKey,
   generateMnemonic2 as generateMnemonic,
-  getAddressHrp,
   getAddressId,
   getAddressStorageKey,
   getCoinIdByName,
   getCoinIdBySymbol,
-  getCurrentStateHash,
   getPublicKey,
   getSphere,
   getTokenDecimals,
   getTokenDefinition,
   getTokenIconUrl,
-  getTokenId,
   getTokenName,
   getTokenSymbol,
-  hasMissingNewStateHash,
-  hasUncommittedTransactions,
-  hasValidTxfData,
   hash160,
   hashAddressForTag,
   hashNametag,
@@ -31874,22 +31022,17 @@ export {
   hexToBytes4 as hexToBytes,
   identityFromMnemonicSync,
   initSphere,
-  isArchivedKey,
-  isForkedKey,
   isKnownToken,
   isPhoneNumber2 as isPhoneNumber,
   isPossiblyCommittedSendOutcome,
-  isSQLiteDatabase,
   isSphereError,
   isTextWalletEncrypted,
   isTokenKey,
   isValidAddress,
-  isValidBech32,
   isValidDirectAddress,
   isValidNametag2 as isValidNametag,
   isValidPrivateKey,
   isValidTokenId,
-  isWalletDatEncrypted,
   isWalletTextFormat,
   keyFromTokenId,
   loadSphere,
@@ -31898,15 +31041,10 @@ export {
   normalizeAddress,
   normalizeCoinId,
   normalizeNametag2 as normalizeNametag,
-  normalizeSdkTokenToStorage,
-  objectToTxf,
   parseAddress,
-  parseAndDecryptWalletDat,
   parseAndDecryptWalletText,
-  parseForkedKey,
   parseTokenAmount,
   parseTxfStorageData,
-  parseWalletDat,
   parseWalletText,
   randomBytes4 as randomBytes,
   randomHex,
@@ -31920,10 +31058,7 @@ export {
   sleep,
   sphereExists,
   toHumanReadable,
-  tokenIdFromArchivedKey,
   tokenIdFromKey,
-  tokenToTxf,
-  txfToToken,
   validateManifest,
   validateMnemonic2 as validateMnemonic,
   verifyChallengeTemplate,