@unicitylabs/sphere-sdk 0.5.0 → 0.5.2

package/dist/index.js

@@ -91,7 +91,11 @@ var init_constants = __esm({
       /** Group chat: members for this address */
       GROUP_CHAT_MEMBERS: "group_chat_members",
       /** Group chat: processed event IDs for deduplication */
-      GROUP_CHAT_PROCESSED_EVENTS: "group_chat_processed_events"
+      GROUP_CHAT_PROCESSED_EVENTS: "group_chat_processed_events",
+      /** Processed V5 split group IDs for Nostr re-delivery dedup */
+      PROCESSED_SPLIT_GROUP_IDS: "processed_split_group_ids",
+      /** Processed V6 combined transfer IDs for Nostr re-delivery dedup */
+      PROCESSED_COMBINED_TRANSFER_IDS: "processed_combined_transfer_ids"
     };
     STORAGE_KEYS = {
       ...STORAGE_KEYS_GLOBAL,
@@ -3579,14 +3583,149 @@ var InstantSplitExecutor = class {
     this.devMode = config.devMode ?? false;
   }
   /**
-   * Execute an instant split transfer with V5 optimized flow.
+   * Build a V5 split bundle WITHOUT sending it via transport.
    *
-   * Critical path (~2.3s):
+   * Steps 1-5 of the V5 flow:
    * 1. Create and submit burn commitment
    * 2. Wait for burn proof
    * 3. Create mint commitments with SplitMintReason
    * 4. Create transfer commitment (no mint proof needed)
-   * 5. Send bundle via transport
+   * 5. Package V5 bundle
+   *
+   * The caller is responsible for sending the bundle and then calling
+   * `startBackground()` on the result to begin mint proof + change token creation.
+   */
+  async buildSplitBundle(tokenToSplit, splitAmount, remainderAmount, coinIdHex, recipientAddress, options) {
+    const splitGroupId = crypto.randomUUID();
+    const tokenIdHex = toHex2(tokenToSplit.id.bytes);
+    console.log(`[InstantSplit] Building V5 bundle for token ${tokenIdHex.slice(0, 8)}...`);
+    const coinId = new CoinId3(fromHex2(coinIdHex));
+    const seedString = `${tokenIdHex}_${splitAmount.toString()}_${remainderAmount.toString()}_${Date.now()}`;
+    const recipientTokenId = new TokenId3(await sha2563(seedString));
+    const senderTokenId = new TokenId3(await sha2563(seedString + "_sender"));
+    const recipientSalt = await sha2563(seedString + "_recipient_salt");
+    const senderSalt = await sha2563(seedString + "_sender_salt");
+    const senderAddressRef = await UnmaskedPredicateReference2.create(
+      tokenToSplit.type,
+      this.signingService.algorithm,
+      this.signingService.publicKey,
+      HashAlgorithm3.SHA256
+    );
+    const senderAddress = await senderAddressRef.toAddress();
+    const builder = new TokenSplitBuilder2();
+    const coinDataA = TokenCoinData2.create([[coinId, splitAmount]]);
+    builder.createToken(
+      recipientTokenId,
+      tokenToSplit.type,
+      new Uint8Array(0),
+      coinDataA,
+      senderAddress,
+      // Mint to sender first, then transfer
+      recipientSalt,
+      null
+    );
+    const coinDataB = TokenCoinData2.create([[coinId, remainderAmount]]);
+    builder.createToken(
+      senderTokenId,
+      tokenToSplit.type,
+      new Uint8Array(0),
+      coinDataB,
+      senderAddress,
+      senderSalt,
+      null
+    );
+    const split = await builder.build(tokenToSplit);
+    console.log("[InstantSplit] Step 1: Creating and submitting burn...");
+    const burnSalt = await sha2563(seedString + "_burn_salt");
+    const burnCommitment = await split.createBurnCommitment(burnSalt, this.signingService);
+    const burnResponse = await this.client.submitTransferCommitment(burnCommitment);
+    if (burnResponse.status !== "SUCCESS" && burnResponse.status !== "REQUEST_ID_EXISTS") {
+      throw new Error(`Burn submission failed: ${burnResponse.status}`);
+    }
+    console.log("[InstantSplit] Step 2: Waiting for burn proof...");
+    const burnProof = this.devMode ? await this.waitInclusionProofWithDevBypass(burnCommitment, options?.burnProofTimeoutMs) : await waitInclusionProof3(this.trustBase, this.client, burnCommitment);
+    const burnTransaction = burnCommitment.toTransaction(burnProof);
+    console.log(`[InstantSplit] Burn proof received`);
+    options?.onBurnCompleted?.(JSON.stringify(burnTransaction.toJSON()));
+    console.log("[InstantSplit] Step 3: Creating mint commitments...");
+    const mintCommitments = await split.createSplitMintCommitments(this.trustBase, burnTransaction);
+    const recipientIdHex = toHex2(recipientTokenId.bytes);
+    const senderIdHex = toHex2(senderTokenId.bytes);
+    const recipientMintCommitment = mintCommitments.find(
+      (c) => toHex2(c.transactionData.tokenId.bytes) === recipientIdHex
+    );
+    const senderMintCommitment = mintCommitments.find(
+      (c) => toHex2(c.transactionData.tokenId.bytes) === senderIdHex
+    );
+    if (!recipientMintCommitment || !senderMintCommitment) {
+      throw new Error("Failed to find expected mint commitments");
+    }
+    console.log("[InstantSplit] Step 4: Creating transfer commitment...");
+    const transferSalt = await sha2563(seedString + "_transfer_salt");
+    const transferCommitment = await this.createTransferCommitmentFromMintData(
+      recipientMintCommitment.transactionData,
+      recipientAddress,
+      transferSalt,
+      this.signingService
+    );
+    const mintedPredicate = await UnmaskedPredicate3.create(
+      recipientTokenId,
+      tokenToSplit.type,
+      this.signingService,
+      HashAlgorithm3.SHA256,
+      recipientSalt
+    );
+    const mintedState = new TokenState3(mintedPredicate, null);
+    console.log("[InstantSplit] Step 5: Packaging V5 bundle...");
+    const senderPubkey = toHex2(this.signingService.publicKey);
+    let nametagTokenJson;
+    const recipientAddressStr = recipientAddress.toString();
+    if (recipientAddressStr.startsWith("PROXY://") && tokenToSplit.nametagTokens?.length > 0) {
+      nametagTokenJson = JSON.stringify(tokenToSplit.nametagTokens[0].toJSON());
+    }
+    const bundle = {
+      version: "5.0",
+      type: "INSTANT_SPLIT",
+      burnTransaction: JSON.stringify(burnTransaction.toJSON()),
+      recipientMintData: JSON.stringify(recipientMintCommitment.transactionData.toJSON()),
+      transferCommitment: JSON.stringify(transferCommitment.toJSON()),
+      amount: splitAmount.toString(),
+      coinId: coinIdHex,
+      tokenTypeHex: toHex2(tokenToSplit.type.bytes),
+      splitGroupId,
+      senderPubkey,
+      recipientSaltHex: toHex2(recipientSalt),
+      transferSaltHex: toHex2(transferSalt),
+      mintedTokenStateJson: JSON.stringify(mintedState.toJSON()),
+      finalRecipientStateJson: "",
+      // Recipient creates their own
+      recipientAddressJson: recipientAddressStr,
+      nametagTokenJson
+    };
+    return {
+      bundle,
+      splitGroupId,
+      startBackground: async () => {
+        if (!options?.skipBackground) {
+          await this.submitBackgroundV5(senderMintCommitment, recipientMintCommitment, transferCommitment, {
+            signingService: this.signingService,
+            tokenType: tokenToSplit.type,
+            coinId,
+            senderTokenId,
+            senderSalt,
+            onProgress: options?.onBackgroundProgress,
+            onChangeTokenCreated: options?.onChangeTokenCreated,
+            onStorageSync: options?.onStorageSync
+          });
+        }
+      }
+    };
+  }
+  /**
+   * Execute an instant split transfer with V5 optimized flow.
+   *
+   * Builds the bundle via buildSplitBundle(), sends via transport,
+   * and starts background processing.
    *
    * @param tokenToSplit - The SDK token to split
    * @param splitAmount - Amount to send to recipient
@@ -3600,117 +3739,19 @@ var InstantSplitExecutor = class {
    */
   async executeSplitInstant(tokenToSplit, splitAmount, remainderAmount, coinIdHex, recipientAddress, transport, recipientPubkey, options) {
     const startTime = performance.now();
-    const splitGroupId = crypto.randomUUID();
-    const tokenIdHex = toHex2(tokenToSplit.id.bytes);
-    console.log(`[InstantSplit] Starting V5 split for token ${tokenIdHex.slice(0, 8)}...`);
     try {
-      const coinId = new CoinId3(fromHex2(coinIdHex));
-      const seedString = `${tokenIdHex}_${splitAmount.toString()}_${remainderAmount.toString()}_${Date.now()}`;
-      const recipientTokenId = new TokenId3(await sha2563(seedString));
-      const senderTokenId = new TokenId3(await sha2563(seedString + "_sender"));
-      const recipientSalt = await sha2563(seedString + "_recipient_salt");
-      const senderSalt = await sha2563(seedString + "_sender_salt");
-      const senderAddressRef = await UnmaskedPredicateReference2.create(
-        tokenToSplit.type,
-        this.signingService.algorithm,
-        this.signingService.publicKey,
-        HashAlgorithm3.SHA256
-      );
-      const senderAddress = await senderAddressRef.toAddress();
-      const builder = new TokenSplitBuilder2();
-      const coinDataA = TokenCoinData2.create([[coinId, splitAmount]]);
-      builder.createToken(
-        recipientTokenId,
-        tokenToSplit.type,
-        new Uint8Array(0),
-        coinDataA,
-        senderAddress,
-        // Mint to sender first, then transfer
-        recipientSalt,
-        null
-      );
-      const coinDataB = TokenCoinData2.create([[coinId, remainderAmount]]);
-      builder.createToken(
-        senderTokenId,
-        tokenToSplit.type,
-        new Uint8Array(0),
-        coinDataB,
-        senderAddress,
-        senderSalt,
-        null
-      );
-      const split = await builder.build(tokenToSplit);
-      console.log("[InstantSplit] Step 1: Creating and submitting burn...");
-      const burnSalt = await sha2563(seedString + "_burn_salt");
-      const burnCommitment = await split.createBurnCommitment(burnSalt, this.signingService);
-      const burnResponse = await this.client.submitTransferCommitment(burnCommitment);
-      if (burnResponse.status !== "SUCCESS" && burnResponse.status !== "REQUEST_ID_EXISTS") {
-        throw new Error(`Burn submission failed: ${burnResponse.status}`);
-      }
-      console.log("[InstantSplit] Step 2: Waiting for burn proof...");
-      const burnProof = this.devMode ? await this.waitInclusionProofWithDevBypass(burnCommitment, options?.burnProofTimeoutMs) : await waitInclusionProof3(this.trustBase, this.client, burnCommitment);
-      const burnTransaction = burnCommitment.toTransaction(burnProof);
-      const burnDuration = performance.now() - startTime;
-      console.log(`[InstantSplit] Burn proof received in ${burnDuration.toFixed(0)}ms`);
-      options?.onBurnCompleted?.(JSON.stringify(burnTransaction.toJSON()));
-      console.log("[InstantSplit] Step 3: Creating mint commitments...");
-      const mintCommitments = await split.createSplitMintCommitments(this.trustBase, burnTransaction);
-      const recipientIdHex = toHex2(recipientTokenId.bytes);
-      const senderIdHex = toHex2(senderTokenId.bytes);
-      const recipientMintCommitment = mintCommitments.find(
-        (c) => toHex2(c.transactionData.tokenId.bytes) === recipientIdHex
-      );
-      const senderMintCommitment = mintCommitments.find(
-        (c) => toHex2(c.transactionData.tokenId.bytes) === senderIdHex
-      );
-      if (!recipientMintCommitment || !senderMintCommitment) {
-        throw new Error("Failed to find expected mint commitments");
-      }
-      console.log("[InstantSplit] Step 4: Creating transfer commitment...");
-      const transferSalt = await sha2563(seedString + "_transfer_salt");
-      const transferCommitment = await this.createTransferCommitmentFromMintData(
-        recipientMintCommitment.transactionData,
+      const buildResult = await this.buildSplitBundle(
+        tokenToSplit,
+        splitAmount,
+        remainderAmount,
+        coinIdHex,
         recipientAddress,
-        transferSalt,
-        this.signingService
+        options
       );
-      const mintedPredicate = await UnmaskedPredicate3.create(
-        recipientTokenId,
-        tokenToSplit.type,
-        this.signingService,
-        HashAlgorithm3.SHA256,
-        recipientSalt
-      );
-      const mintedState = new TokenState3(mintedPredicate, null);
-      console.log("[InstantSplit] Step 5: Packaging V5 bundle...");
+      console.log("[InstantSplit] Sending via transport...");
       const senderPubkey = toHex2(this.signingService.publicKey);
-      let nametagTokenJson;
-      const recipientAddressStr = recipientAddress.toString();
-      if (recipientAddressStr.startsWith("PROXY://") && tokenToSplit.nametagTokens?.length > 0) {
-        nametagTokenJson = JSON.stringify(tokenToSplit.nametagTokens[0].toJSON());
-      }
-      const bundle = {
-        version: "5.0",
-        type: "INSTANT_SPLIT",
-        burnTransaction: JSON.stringify(burnTransaction.toJSON()),
-        recipientMintData: JSON.stringify(recipientMintCommitment.transactionData.toJSON()),
-        transferCommitment: JSON.stringify(transferCommitment.toJSON()),
-        amount: splitAmount.toString(),
-        coinId: coinIdHex,
-        tokenTypeHex: toHex2(tokenToSplit.type.bytes),
-        splitGroupId,
-        senderPubkey,
-        recipientSaltHex: toHex2(recipientSalt),
-        transferSaltHex: toHex2(transferSalt),
-        mintedTokenStateJson: JSON.stringify(mintedState.toJSON()),
-        finalRecipientStateJson: "",
-        // Recipient creates their own
-        recipientAddressJson: recipientAddressStr,
-        nametagTokenJson
-      };
-      console.log("[InstantSplit] Step 6: Sending via transport...");
       const nostrEventId = await transport.sendTokenTransfer(recipientPubkey, {
-        token: JSON.stringify(bundle),
+        token: JSON.stringify(buildResult.bundle),
         proof: null,
         // Proof is included in the bundle
         memo: options?.memo,
@@ -3721,25 +3762,13 @@ var InstantSplitExecutor = class {
       const criticalPathDuration = performance.now() - startTime;
       console.log(`[InstantSplit] V5 complete in ${criticalPathDuration.toFixed(0)}ms`);
       options?.onNostrDelivered?.(nostrEventId);
-      let backgroundPromise;
-      if (!options?.skipBackground) {
-        backgroundPromise = this.submitBackgroundV5(senderMintCommitment, recipientMintCommitment, transferCommitment, {
-          signingService: this.signingService,
-          tokenType: tokenToSplit.type,
-          coinId,
-          senderTokenId,
-          senderSalt,
-          onProgress: options?.onBackgroundProgress,
-          onChangeTokenCreated: options?.onChangeTokenCreated,
-          onStorageSync: options?.onStorageSync
-        });
-      }
+      const backgroundPromise = buildResult.startBackground();
       return {
         success: true,
         nostrEventId,
-        splitGroupId,
+        splitGroupId: buildResult.splitGroupId,
         criticalPathDurationMs: criticalPathDuration,
-        backgroundStarted: !options?.skipBackground,
+        backgroundStarted: true,
         backgroundPromise
       };
     } catch (error) {
@@ -3748,7 +3777,6 @@ var InstantSplitExecutor = class {
       console.error(`[InstantSplit] Failed after ${duration.toFixed(0)}ms:`, error);
       return {
         success: false,
-        splitGroupId,
         criticalPathDurationMs: duration,
         error: errorMessage,
         backgroundStarted: false
@@ -3953,6 +3981,11 @@ function isInstantSplitBundleV4(obj) {
 function isInstantSplitBundleV5(obj) {
   return isInstantSplitBundle(obj) && obj.version === "5.0";
 }
+function isCombinedTransferBundleV6(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const b = obj;
+  return b.version === "6.0" && b.type === "COMBINED_TRANSFER";
+}
 
 // modules/payments/InstantSplitProcessor.ts
 function fromHex3(hex) {
@@ -4595,6 +4628,19 @@ var PaymentsModule = class _PaymentsModule {
   // Poll every 2s
   static PROOF_POLLING_MAX_ATTEMPTS = 30;
   // Max 30 attempts (~60s)
+  // Periodic retry for resolveUnconfirmed (V5 lazy finalization)
+  resolveUnconfirmedTimer = null;
+  static RESOLVE_UNCONFIRMED_INTERVAL_MS = 1e4;
+  // Retry every 10s
+  // Guard: ensure load() completes before processing incoming bundles
+  loadedPromise = null;
+  loaded = false;
+  // Persistent dedup: tracks splitGroupIds that have been fully processed.
+  // Survives page reloads via KV storage so Nostr re-deliveries are ignored
+  // even when the confirmed token's in-memory ID differs from v5split_{id}.
+  processedSplitGroupIds = /* @__PURE__ */ new Set();
+  // Persistent dedup: tracks V6 combined transfer IDs that have been processed.
+  processedCombinedTransferIds = /* @__PURE__ */ new Set();
   // Storage event subscriptions (push-based sync)
   storageEventUnsubscribers = [];
   syncDebounceTimer = null;
@@ -4680,31 +4726,53 @@ var PaymentsModule = class _PaymentsModule {
    */
   async load() {
     this.ensureInitialized();
-    await TokenRegistry.waitForReady();
-    const providers = this.getTokenStorageProviders();
-    for (const [id, provider] of providers) {
-      try {
-        const result = await provider.load();
-        if (result.success && result.data) {
-          this.loadFromStorageData(result.data);
-          this.log(`Loaded metadata from provider ${id}`);
-          break;
+    const doLoad = async () => {
+      await TokenRegistry.waitForReady();
+      const providers = this.getTokenStorageProviders();
+      for (const [id, provider] of providers) {
+        try {
+          const result = await provider.load();
+          if (result.success && result.data) {
+            this.loadFromStorageData(result.data);
+            this.log(`Loaded metadata from provider ${id}`);
+            break;
+          }
+        } catch (err) {
+          console.error(`[Payments] Failed to load from provider ${id}:`, err);
         }
-      } catch (err) {
-        console.error(`[Payments] Failed to load from provider ${id}:`, err);
       }
-    }
-    await this.loadPendingV5Tokens();
-    await this.loadHistory();
-    const pending2 = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.PENDING_TRANSFERS);
-    if (pending2) {
-      const transfers = JSON.parse(pending2);
-      for (const transfer of transfers) {
-        this.pendingTransfers.set(transfer.id, transfer);
+      for (const [id, token] of this.tokens) {
+        try {
+          if (token.sdkData) {
+            const data = JSON.parse(token.sdkData);
+            if (data?._placeholder) {
+              this.tokens.delete(id);
+              console.log(`[Payments] Removed stale placeholder token: ${id}`);
+            }
+          }
+        } catch {
+        }
       }
-    }
+      const loadedTokens = Array.from(this.tokens.values()).map((t) => `${t.id.slice(0, 12)}(${t.status})`);
+      console.log(`[Payments][DEBUG] load(): from TXF providers: ${this.tokens.size} tokens [${loadedTokens.join(", ")}]`);
+      await this.loadPendingV5Tokens();
+      await this.loadProcessedSplitGroupIds();
+      await this.loadProcessedCombinedTransferIds();
+      await this.loadHistory();
+      const pending2 = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.PENDING_TRANSFERS);
+      if (pending2) {
+        const transfers = JSON.parse(pending2);
+        for (const transfer of transfers) {
+          this.pendingTransfers.set(transfer.id, transfer);
+        }
+      }
+      this.loaded = true;
+    };
+    this.loadedPromise = doLoad();
+    await this.loadedPromise;
     this.resolveUnconfirmed().catch(() => {
     });
+    this.scheduleResolveUnconfirmed();
   }
   /**
    * Cleanup all subscriptions, polling jobs, and pending resolvers.
@@ -4723,6 +4791,7 @@ var PaymentsModule = class _PaymentsModule {
     this.paymentRequestResponseHandlers.clear();
     this.stopProofPolling();
     this.proofPollingJobs.clear();
+    this.stopResolveUnconfirmedPolling();
     for (const [, resolver] of this.pendingResponseResolvers) {
       clearTimeout(resolver.timeout);
       resolver.reject(new Error("Module destroyed"));
@@ -4780,12 +4849,13 @@ var PaymentsModule = class _PaymentsModule {
         token.status = "transferring";
         this.tokens.set(token.id, token);
       }
+      await this.save();
       await this.saveToOutbox(result, recipientPubkey);
       result.status = "submitted";
       const recipientNametag = peerInfo?.nametag || (request.recipient.startsWith("@") ? request.recipient.slice(1) : void 0);
       const transferMode = request.transferMode ?? "instant";
-      if (splitPlan.requiresSplit && splitPlan.tokenToSplit) {
-        if (transferMode === "conservative") {
+      if (transferMode === "conservative") {
+        if (splitPlan.requiresSplit && splitPlan.tokenToSplit) {
           this.log("Executing conservative split...");
           const splitExecutor = new TokenSplitExecutor({
             stateTransitionClient: stClient,
@@ -4829,27 +4899,59 @@ var PaymentsModule = class _PaymentsModule {
             requestIdHex: splitRequestIdHex
           });
           this.log(`Conservative split transfer completed`);
-        } else {
-          this.log("Executing instant split...");
-          const devMode = this.deps.oracle.isDevMode?.() ?? false;
+        }
+        for (const tokenWithAmount of splitPlan.tokensToTransferDirectly) {
+          const token = tokenWithAmount.uiToken;
+          const commitment = await this.createSdkCommitment(token, recipientAddress, signingService);
+          console.log(`[Payments] CONSERVATIVE: Sending direct token ${token.id.slice(0, 8)}... to ${recipientPubkey.slice(0, 8)}...`);
+          const submitResponse = await stClient.submitTransferCommitment(commitment);
+          if (submitResponse.status !== "SUCCESS" && submitResponse.status !== "REQUEST_ID_EXISTS") {
+            throw new Error(`Transfer commitment failed: ${submitResponse.status}`);
+          }
+          const inclusionProof = await waitInclusionProof5(trustBase, stClient, commitment);
+          const transferTx = commitment.toTransaction(inclusionProof);
+          await this.deps.transport.sendTokenTransfer(recipientPubkey, {
+            sourceToken: JSON.stringify(tokenWithAmount.sdkToken.toJSON()),
+            transferTx: JSON.stringify(transferTx.toJSON()),
+            memo: request.memo
+          });
+          console.log(`[Payments] CONSERVATIVE: Direct token sent successfully`);
+          const requestIdBytes = commitment.requestId;
+          const requestIdHex = requestIdBytes instanceof Uint8Array ? Array.from(requestIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("") : String(requestIdBytes);
+          result.tokenTransfers.push({
+            sourceTokenId: token.id,
+            method: "direct",
+            requestIdHex
+          });
+          this.log(`Token ${token.id} sent via CONSERVATIVE, requestId: ${requestIdHex}`);
+          await this.removeToken(token.id);
+        }
+      } else {
+        const devMode = this.deps.oracle.isDevMode?.() ?? false;
+        const senderPubkey = this.deps.identity.chainPubkey;
+        let changeTokenPlaceholderId = null;
+        let builtSplit = null;
+        if (splitPlan.requiresSplit && splitPlan.tokenToSplit) {
+          this.log("Building instant split bundle...");
           const executor = new InstantSplitExecutor({
             stateTransitionClient: stClient,
             trustBase,
             signingService,
             devMode
           });
-          const instantResult = await executor.executeSplitInstant(
+          builtSplit = await executor.buildSplitBundle(
             splitPlan.tokenToSplit.sdkToken,
             splitPlan.splitAmount,
             splitPlan.remainderAmount,
             splitPlan.coinId,
             recipientAddress,
-            this.deps.transport,
-            recipientPubkey,
             {
               memo: request.memo,
               onChangeTokenCreated: async (changeToken) => {
                 const changeTokenData = changeToken.toJSON();
+                if (changeTokenPlaceholderId && this.tokens.has(changeTokenPlaceholderId)) {
+                  this.tokens.delete(changeTokenPlaceholderId);
+                }
                 const uiToken = {
                   id: crypto.randomUUID(),
                   coinId: request.coinId,
@@ -4872,65 +4974,103 @@ var PaymentsModule = class _PaymentsModule {
               }
             }
           );
-          if (!instantResult.success) {
-            throw new Error(instantResult.error || "Instant split failed");
-          }
-          if (instantResult.backgroundPromise) {
-            this.pendingBackgroundTasks.push(instantResult.backgroundPromise);
-          }
+          this.log(`Split bundle built: splitGroupId=${builtSplit.splitGroupId}`);
+        }
+        const directCommitments = await Promise.all(
+          splitPlan.tokensToTransferDirectly.map(
+            (tw) => this.createSdkCommitment(tw.uiToken, recipientAddress, signingService)
+          )
+        );
+        const directTokenEntries = splitPlan.tokensToTransferDirectly.map(
+          (tw, i) => ({
+            sourceToken: JSON.stringify(tw.sdkToken.toJSON()),
+            commitmentData: JSON.stringify(directCommitments[i].toJSON()),
+            amount: tw.uiToken.amount,
+            coinId: tw.uiToken.coinId,
+            tokenId: extractTokenIdFromSdkData(tw.uiToken.sdkData) || void 0
+          })
+        );
+        const combinedBundle = {
+          version: "6.0",
+          type: "COMBINED_TRANSFER",
+          transferId: result.id,
+          splitBundle: builtSplit?.bundle ?? null,
+          directTokens: directTokenEntries,
+          totalAmount: request.amount.toString(),
+          coinId: request.coinId,
+          senderPubkey,
+          memo: request.memo
+        };
+        console.log(
+          `[Payments] Sending V6 combined bundle: transfer=${result.id.slice(0, 8)}... split=${!!builtSplit} direct=${directTokenEntries.length}`
+        );
+        await this.deps.transport.sendTokenTransfer(recipientPubkey, {
+          token: JSON.stringify(combinedBundle),
+          proof: null,
+          memo: request.memo,
+          sender: { transportPubkey: senderPubkey }
+        });
+        console.log(`[Payments] V6 combined bundle sent successfully`);
+        if (builtSplit) {
+          const bgPromise = builtSplit.startBackground();
+          this.pendingBackgroundTasks.push(bgPromise);
+        }
+        if (builtSplit && splitPlan.remainderAmount) {
+          changeTokenPlaceholderId = crypto.randomUUID();
+          const placeholder = {
+            id: changeTokenPlaceholderId,
+            coinId: request.coinId,
+            symbol: this.getCoinSymbol(request.coinId),
+            name: this.getCoinName(request.coinId),
+            decimals: this.getCoinDecimals(request.coinId),
+            iconUrl: this.getCoinIconUrl(request.coinId),
+            amount: splitPlan.remainderAmount.toString(),
+            status: "transferring",
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            sdkData: JSON.stringify({ _placeholder: true })
+          };
+          this.tokens.set(placeholder.id, placeholder);
+          this.log(`Placeholder change token created: ${placeholder.id} (${placeholder.amount})`);
+        }
+        for (const commitment of directCommitments) {
+          stClient.submitTransferCommitment(commitment).catch(
+            (err) => console.error("[Payments] Background commitment submit failed:", err)
+          );
+        }
+        if (splitPlan.requiresSplit && splitPlan.tokenToSplit) {
           await this.removeToken(splitPlan.tokenToSplit.uiToken.id);
           result.tokenTransfers.push({
             sourceTokenId: splitPlan.tokenToSplit.uiToken.id,
             method: "split",
-            splitGroupId: instantResult.splitGroupId,
-            nostrEventId: instantResult.nostrEventId
+            splitGroupId: builtSplit.splitGroupId
           });
-          this.log(`Instant split transfer completed`);
         }
-      }
-      for (const tokenWithAmount of splitPlan.tokensToTransferDirectly) {
-        const token = tokenWithAmount.uiToken;
-        const commitment = await this.createSdkCommitment(token, recipientAddress, signingService);
-        if (transferMode === "conservative") {
-          console.log(`[Payments] CONSERVATIVE: Sending direct token ${token.id.slice(0, 8)}... to ${recipientPubkey.slice(0, 8)}...`);
-          const submitResponse = await stClient.submitTransferCommitment(commitment);
-          if (submitResponse.status !== "SUCCESS" && submitResponse.status !== "REQUEST_ID_EXISTS") {
-            throw new Error(`Transfer commitment failed: ${submitResponse.status}`);
-          }
-          const inclusionProof = await waitInclusionProof5(trustBase, stClient, commitment);
-          const transferTx = commitment.toTransaction(inclusionProof);
-          await this.deps.transport.sendTokenTransfer(recipientPubkey, {
-            sourceToken: JSON.stringify(tokenWithAmount.sdkToken.toJSON()),
-            transferTx: JSON.stringify(transferTx.toJSON()),
-            memo: request.memo
-          });
-          console.log(`[Payments] CONSERVATIVE: Direct token sent successfully`);
-        } else {
-          console.log(`[Payments] NOSTR-FIRST: Sending direct token ${token.id.slice(0, 8)}... to ${recipientPubkey.slice(0, 8)}...`);
-          await this.deps.transport.sendTokenTransfer(recipientPubkey, {
-            sourceToken: JSON.stringify(tokenWithAmount.sdkToken.toJSON()),
-            commitmentData: JSON.stringify(commitment.toJSON()),
-            memo: request.memo
+        for (let i = 0; i < splitPlan.tokensToTransferDirectly.length; i++) {
+          const token = splitPlan.tokensToTransferDirectly[i].uiToken;
+          const commitment = directCommitments[i];
+          const requestIdBytes = commitment.requestId;
+          const requestIdHex = requestIdBytes instanceof Uint8Array ? Array.from(requestIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("") : String(requestIdBytes);
+          result.tokenTransfers.push({
+            sourceTokenId: token.id,
+            method: "direct",
+            requestIdHex
           });
-          console.log(`[Payments] NOSTR-FIRST: Direct token sent successfully`);
-          stClient.submitTransferCommitment(commitment).catch(
-            (err) => console.error("[Payments] Background commitment submit failed:", err)
-          );
+          await this.removeToken(token.id);
         }
-        const requestIdBytes = commitment.requestId;
-        const requestIdHex = requestIdBytes instanceof Uint8Array ? Array.from(requestIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("") : String(requestIdBytes);
-        result.tokenTransfers.push({
-          sourceTokenId: token.id,
-          method: "direct",
-          requestIdHex
-        });
-        this.log(`Token ${token.id} sent via ${transferMode.toUpperCase()}, requestId: ${requestIdHex}`);
-        await this.removeToken(token.id);
+        this.log(`V6 combined transfer completed`);
       }
       result.status = "delivered";
       await this.save();
       await this.removeFromOutbox(result.id);
       result.status = "completed";
+      const tokenMap = new Map(result.tokens.map((t) => [t.id, t]));
+      const sentTokenIds = result.tokenTransfers.map((tt) => ({
+        id: tt.sourceTokenId,
+        // For split tokens, use splitAmount (the portion sent), not the original token amount
+        amount: tt.method === "split" ? splitPlan.splitAmount?.toString() || "0" : tokenMap.get(tt.sourceTokenId)?.amount || "0",
+        source: tt.method === "split" ? "split" : "direct"
+      }));
       const sentTokenId = result.tokens[0] ? extractTokenIdFromSdkData(result.tokens[0].sdkData) : void 0;
       await this.addToHistory({
         type: "SENT",
@@ -4943,7 +5083,8 @@ var PaymentsModule = class _PaymentsModule {
         recipientAddress: peerInfo?.directAddress || recipientAddress?.toString() || recipientPubkey,
         memo: request.memo,
         transferId: result.id,
-        tokenId: sentTokenId || void 0
+        tokenId: sentTokenId || void 0,
+        tokenIds: sentTokenIds.length > 0 ? sentTokenIds : void 0
       });
       this.deps.emitEvent("transfer:confirmed", result);
       return result;
@@ -5113,6 +5254,267 @@ var PaymentsModule = class _PaymentsModule {
       };
     }
   }
+  // ===========================================================================
+  // Shared Helpers for V5 and V6 Receiver Processing
+  // ===========================================================================
+  /**
+   * Save a V5 split bundle as an unconfirmed token (shared by V5 standalone and V6 combined).
+   * Returns the created UI token, or null if deduped.
+   *
+   * @param deferPersistence - If true, skip addToken/save calls (caller batches them).
+   *   The token is still added to the in-memory map for dedup; caller must call save().
+   */
+  async saveUnconfirmedV5Token(bundle, senderPubkey, deferPersistence = false) {
+    const deterministicId = `v5split_${bundle.splitGroupId}`;
+    if (this.tokens.has(deterministicId) || this.processedSplitGroupIds.has(bundle.splitGroupId)) {
+      console.log(`[Payments] V5 bundle ${bundle.splitGroupId.slice(0, 12)}... already processed, skipping`);
+      return null;
+    }
+    const registry = TokenRegistry.getInstance();
+    const pendingData = {
+      type: "v5_bundle",
+      stage: "RECEIVED",
+      bundleJson: JSON.stringify(bundle),
+      senderPubkey,
+      savedAt: Date.now(),
+      attemptCount: 0
+    };
+    const uiToken = {
+      id: deterministicId,
+      coinId: bundle.coinId,
+      symbol: registry.getSymbol(bundle.coinId) || bundle.coinId,
+      name: registry.getName(bundle.coinId) || bundle.coinId,
+      decimals: registry.getDecimals(bundle.coinId) ?? 8,
+      amount: bundle.amount,
+      status: "submitted",
+      // UNCONFIRMED
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      sdkData: JSON.stringify({ _pendingFinalization: pendingData })
+    };
+    this.processedSplitGroupIds.add(bundle.splitGroupId);
+    if (deferPersistence) {
+      this.tokens.set(uiToken.id, uiToken);
+    } else {
+      await this.addToken(uiToken);
+      await this.saveProcessedSplitGroupIds();
+    }
+    return uiToken;
+  }
+  /**
+   * Save a commitment-only (NOSTR-FIRST) token and start proof polling.
+   * Shared by standalone NOSTR-FIRST handler and V6 combined handler.
+   * Returns the created UI token, or null if deduped/tombstoned.
+   *
+   * @param deferPersistence - If true, skip save() and commitment submission
+   *   (caller batches them). Token is added to in-memory map + proof polling is queued.
+   * @param skipGenesisDedup - If true, skip genesis-ID-only dedup. V6 handler sets this
+   *   because bundle-level dedup protects against replays, and split children share genesis IDs.
+   */
+  async saveCommitmentOnlyToken(sourceTokenInput, commitmentInput, senderPubkey, deferPersistence = false, skipGenesisDedup = false) {
+    const tokenInfo = await parseTokenInfo(sourceTokenInput);
+    const sdkData = typeof sourceTokenInput === "string" ? sourceTokenInput : JSON.stringify(sourceTokenInput);
+    const nostrTokenId = extractTokenIdFromSdkData(sdkData);
+    const nostrStateHash = extractStateHashFromSdkData(sdkData);
+    if (nostrTokenId && nostrStateHash && this.isStateTombstoned(nostrTokenId, nostrStateHash)) {
+      this.log(`NOSTR-FIRST: Rejecting tombstoned token ${nostrTokenId.slice(0, 8)}..._${nostrStateHash.slice(0, 8)}...`);
+      return null;
+    }
+    if (nostrTokenId) {
+      for (const existing of this.tokens.values()) {
+        const existingTokenId = extractTokenIdFromSdkData(existing.sdkData);
+        if (existingTokenId !== nostrTokenId) continue;
+        const existingStateHash = extractStateHashFromSdkData(existing.sdkData);
+        if (nostrStateHash && existingStateHash === nostrStateHash) {
+          console.log(
+            `[Payments] NOSTR-FIRST: Skipping duplicate token state ${nostrTokenId.slice(0, 8)}..._${nostrStateHash.slice(0, 8)}...`
+          );
+          return null;
+        }
+        if (!skipGenesisDedup) {
+          console.log(
+            `[Payments] NOSTR-FIRST: Skipping replay of finalized token ${nostrTokenId.slice(0, 8)}...`
+          );
+          return null;
+        }
+      }
+    }
+    const token = {
+      id: crypto.randomUUID(),
+      coinId: tokenInfo.coinId,
+      symbol: tokenInfo.symbol,
+      name: tokenInfo.name,
+      decimals: tokenInfo.decimals,
+      iconUrl: tokenInfo.iconUrl,
+      amount: tokenInfo.amount,
+      status: "submitted",
+      // NOSTR-FIRST: unconfirmed until proof
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      sdkData
+    };
+    this.tokens.set(token.id, token);
+    if (!deferPersistence) {
+      await this.save();
+    }
+    try {
+      const commitment = await TransferCommitment4.fromJSON(commitmentInput);
+      const requestIdBytes = commitment.requestId;
+      const requestIdHex = requestIdBytes instanceof Uint8Array ? Array.from(requestIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("") : String(requestIdBytes);
+      if (!deferPersistence) {
+        const stClient = this.deps.oracle.getStateTransitionClient?.();
+        if (stClient) {
+          const response = await stClient.submitTransferCommitment(commitment);
+          this.log(`NOSTR-FIRST recipient commitment submit: ${response.status}`);
+        }
+      }
+      this.addProofPollingJob({
+        tokenId: token.id,
+        requestIdHex,
+        commitmentJson: JSON.stringify(commitmentInput),
+        startedAt: Date.now(),
+        attemptCount: 0,
+        lastAttemptAt: 0,
+        onProofReceived: async (tokenId) => {
+          await this.finalizeReceivedToken(tokenId, sourceTokenInput, commitmentInput);
+        }
+      });
+    } catch (err) {
+      console.error("[Payments] Failed to parse commitment for proof polling:", err);
+    }
+    return token;
+  }
+  // ===========================================================================
+  // Combined Transfer V6 — Receiver
+  // ===========================================================================
+  /**
+   * Process a received COMBINED_TRANSFER V6 bundle.
+   *
+   * Unpacks a single Nostr message into its component tokens:
+   * - Optional V5 split bundle (saved as unconfirmed, resolved lazily)
+   * - Zero or more direct tokens (saved as unconfirmed, proof-polled)
+   *
+   * Emits ONE transfer:incoming event and records ONE history entry.
+   */
+  async processCombinedTransferBundle(bundle, senderPubkey) {
+    this.ensureInitialized();
+    if (!this.loaded && this.loadedPromise) {
+      await this.loadedPromise;
+    }
+    if (this.processedCombinedTransferIds.has(bundle.transferId)) {
+      console.log(`[Payments] V6 combined transfer ${bundle.transferId.slice(0, 12)}... already processed, skipping`);
+      return;
+    }
+    console.log(
+      `[Payments] Processing V6 combined transfer ${bundle.transferId.slice(0, 12)}... (split=${!!bundle.splitBundle}, direct=${bundle.directTokens.length})`
+    );
+    const allTokens = [];
+    const tokenBreakdown = [];
+    const parsedDirectEntries = bundle.directTokens.map((entry) => ({
+      sourceToken: typeof entry.sourceToken === "string" ? JSON.parse(entry.sourceToken) : entry.sourceToken,
+      commitment: typeof entry.commitmentData === "string" ? JSON.parse(entry.commitmentData) : entry.commitmentData
+    }));
+    if (bundle.splitBundle) {
+      const splitToken = await this.saveUnconfirmedV5Token(bundle.splitBundle, senderPubkey, true);
+      if (splitToken) {
+        allTokens.push(splitToken);
+        tokenBreakdown.push({ id: splitToken.id, amount: splitToken.amount, source: "split" });
+      } else {
+        console.warn(`[Payments] V6: split token was deduped/failed \u2014 amount=${bundle.splitBundle.amount}`);
+      }
+    }
+    const directResults = await Promise.all(
+      parsedDirectEntries.map(
+        ({ sourceToken, commitment }) => this.saveCommitmentOnlyToken(sourceToken, commitment, senderPubkey, true, true)
+      )
+    );
+    for (let i = 0; i < directResults.length; i++) {
+      const token = directResults[i];
+      if (token) {
+        allTokens.push(token);
+        tokenBreakdown.push({ id: token.id, amount: token.amount, source: "direct" });
+      } else {
+        const entry = bundle.directTokens[i];
+        console.warn(
+          `[Payments] V6: direct token #${i} dropped (amount=${entry.amount}, tokenId=${entry.tokenId?.slice(0, 12) ?? "N/A"})`
+        );
+      }
+    }
+    if (allTokens.length === 0) {
+      console.log(`[Payments] V6 combined transfer: all tokens deduped, nothing to save`);
+      return;
+    }
+    this.processedCombinedTransferIds.add(bundle.transferId);
+    const [senderInfo] = await Promise.all([
+      this.resolveSenderInfo(senderPubkey),
+      this.save(),
+      this.saveProcessedCombinedTransferIds(),
+      ...bundle.splitBundle ? [this.saveProcessedSplitGroupIds()] : []
+    ]);
+    const stClient = this.deps.oracle.getStateTransitionClient?.();
+    if (stClient) {
+      for (const { commitment } of parsedDirectEntries) {
+        TransferCommitment4.fromJSON(commitment).then(
+          (c) => stClient.submitTransferCommitment(c)
+        ).catch(
+          (err) => console.error("[Payments] V6 background commitment submit failed:", err)
+        );
+      }
+    }
+    this.deps.emitEvent("transfer:incoming", {
+      id: bundle.transferId,
+      senderPubkey,
+      senderNametag: senderInfo.senderNametag,
+      tokens: allTokens,
+      memo: bundle.memo,
+      receivedAt: Date.now()
+    });
+    const actualAmount = allTokens.reduce((sum, t) => sum + BigInt(t.amount || "0"), 0n).toString();
+    await this.addToHistory({
+      type: "RECEIVED",
+      amount: actualAmount,
+      coinId: bundle.coinId,
+      symbol: allTokens[0]?.symbol || bundle.coinId,
+      timestamp: Date.now(),
+      senderPubkey,
+      ...senderInfo,
+      memo: bundle.memo,
+      transferId: bundle.transferId,
+      tokenId: allTokens[0]?.id,
+      tokenIds: tokenBreakdown
+    });
+    if (bundle.splitBundle) {
+      this.resolveUnconfirmed().catch(() => {
+      });
+      this.scheduleResolveUnconfirmed();
+    }
+  }
+  /**
+   * Persist processed combined transfer IDs to KV storage.
+   */
+  async saveProcessedCombinedTransferIds() {
+    const ids = Array.from(this.processedCombinedTransferIds);
+    if (ids.length > 0) {
+      await this.deps.storage.set(
+        STORAGE_KEYS_ADDRESS.PROCESSED_COMBINED_TRANSFER_IDS,
+        JSON.stringify(ids)
+      );
+    }
+  }
+  /**
+   * Load processed combined transfer IDs from KV storage.
+   */
+  async loadProcessedCombinedTransferIds() {
+    const data = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.PROCESSED_COMBINED_TRANSFER_IDS);
+    if (!data) return;
+    try {
+      const ids = JSON.parse(data);
+      for (const id of ids) {
+        this.processedCombinedTransferIds.add(id);
+      }
+    } catch {
+    }
+  }
   /**
    * Process a received INSTANT_SPLIT bundle.
    *
@@ -5129,39 +5531,17 @@ var PaymentsModule = class _PaymentsModule {
    */
   async processInstantSplitBundle(bundle, senderPubkey, memo) {
     this.ensureInitialized();
+    if (!this.loaded && this.loadedPromise) {
+      await this.loadedPromise;
+    }
     if (!isInstantSplitBundleV5(bundle)) {
       return this.processInstantSplitBundleSync(bundle, senderPubkey, memo);
     }
     try {
-      const deterministicId = `v5split_${bundle.splitGroupId}`;
-      if (this.tokens.has(deterministicId)) {
-        this.log(`V5 bundle ${deterministicId.slice(0, 16)}... already exists, skipping duplicate`);
+      const uiToken = await this.saveUnconfirmedV5Token(bundle, senderPubkey);
+      if (!uiToken) {
         return { success: true, durationMs: 0 };
       }
-      const registry = TokenRegistry.getInstance();
-      const pendingData = {
-        type: "v5_bundle",
-        stage: "RECEIVED",
-        bundleJson: JSON.stringify(bundle),
-        senderPubkey,
-        savedAt: Date.now(),
-        attemptCount: 0
-      };
-      const uiToken = {
-        id: deterministicId,
-        coinId: bundle.coinId,
-        symbol: registry.getSymbol(bundle.coinId) || bundle.coinId,
-        name: registry.getName(bundle.coinId) || bundle.coinId,
-        decimals: registry.getDecimals(bundle.coinId) ?? 8,
-        amount: bundle.amount,
-        status: "submitted",
-        // UNCONFIRMED
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-        sdkData: JSON.stringify({ _pendingFinalization: pendingData })
-      };
-      await this.addToken(uiToken);
-      this.log(`V5 bundle saved as unconfirmed: ${uiToken.id.slice(0, 8)}...`);
       const senderInfo = await this.resolveSenderInfo(senderPubkey);
       await this.addToHistory({
         type: "RECEIVED",
@@ -5172,7 +5552,7 @@ var PaymentsModule = class _PaymentsModule {
         senderPubkey,
         ...senderInfo,
         memo,
-        tokenId: deterministicId
+        tokenId: uiToken.id
       });
       this.deps.emitEvent("transfer:incoming", {
         id: bundle.splitGroupId,
@@ -5185,6 +5565,7 @@ var PaymentsModule = class _PaymentsModule {
       await this.save();
       this.resolveUnconfirmed().catch(() => {
       });
+      this.scheduleResolveUnconfirmed();
       return { success: true, durationMs: 0 };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -5821,16 +6202,18 @@ var PaymentsModule = class _PaymentsModule {
   }
   /**
    * Aggregate tokens by coinId with confirmed/unconfirmed breakdown.
-   * Excludes tokens with status 'spent', 'invalid', or 'transferring'.
+   * Excludes tokens with status 'spent' or 'invalid'.
+   * Tokens with status 'transferring' are counted as unconfirmed (visible in UI as "Sending").
    */
   aggregateTokens(coinId) {
     const assetsMap = /* @__PURE__ */ new Map();
     for (const token of this.tokens.values()) {
-      if (token.status === "spent" || token.status === "invalid" || token.status === "transferring") continue;
+      if (token.status === "spent" || token.status === "invalid") continue;
       if (coinId && token.coinId !== coinId) continue;
       const key = token.coinId;
       const amount = BigInt(token.amount);
       const isConfirmed = token.status === "confirmed";
+      const isTransferring = token.status === "transferring";
       const existing = assetsMap.get(key);
       if (existing) {
         if (isConfirmed) {
@@ -5840,6 +6223,7 @@ var PaymentsModule = class _PaymentsModule {
           existing.unconfirmedAmount += amount;
           existing.unconfirmedTokenCount++;
         }
+        if (isTransferring) existing.transferringTokenCount++;
       } else {
         assetsMap.set(key, {
           coinId: token.coinId,
@@ -5850,7 +6234,8 @@ var PaymentsModule = class _PaymentsModule {
           confirmedAmount: isConfirmed ? amount : 0n,
           unconfirmedAmount: isConfirmed ? 0n : amount,
           confirmedTokenCount: isConfirmed ? 1 : 0,
-          unconfirmedTokenCount: isConfirmed ? 0 : 1
+          unconfirmedTokenCount: isConfirmed ? 0 : 1,
+          transferringTokenCount: isTransferring ? 1 : 0
         });
       }
     }
@@ -5868,6 +6253,7 @@ var PaymentsModule = class _PaymentsModule {
         unconfirmedAmount: raw.unconfirmedAmount.toString(),
         confirmedTokenCount: raw.confirmedTokenCount,
         unconfirmedTokenCount: raw.unconfirmedTokenCount,
+        transferringTokenCount: raw.transferringTokenCount,
         priceUsd: null,
         priceEur: null,
         change24h: null,
@@ -5931,28 +6317,70 @@ var PaymentsModule = class _PaymentsModule {
     };
     const stClient = this.deps.oracle.getStateTransitionClient?.();
     const trustBase = this.deps.oracle.getTrustBase?.();
-    if (!stClient || !trustBase) return result;
+    if (!stClient || !trustBase) {
+      console.log(`[V5-RESOLVE] resolveUnconfirmed: EARLY EXIT \u2014 stClient=${!!stClient} trustBase=${!!trustBase}`);
+      return result;
+    }
     const signingService = await this.createSigningService();
+    const submittedCount = Array.from(this.tokens.values()).filter((t) => t.status === "submitted").length;
+    console.log(`[V5-RESOLVE] resolveUnconfirmed: ${submittedCount} submitted token(s) to process`);
     for (const [tokenId, token] of this.tokens) {
       if (token.status !== "submitted") continue;
       const pending2 = this.parsePendingFinalization(token.sdkData);
       if (!pending2) {
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 16)}: no pending finalization metadata, skipping`);
         result.stillPending++;
         continue;
       }
       if (pending2.type === "v5_bundle") {
+        console.log(`[V5-RESOLVE] Processing ${tokenId.slice(0, 16)}... stage=${pending2.stage} attempt=${pending2.attemptCount}`);
         const progress = await this.resolveV5Token(tokenId, token, pending2, stClient, trustBase, signingService);
+        console.log(`[V5-RESOLVE] Result for ${tokenId.slice(0, 16)}...: ${progress} (stage now: ${pending2.stage})`);
         result.details.push({ tokenId, stage: pending2.stage, status: progress });
         if (progress === "resolved") result.resolved++;
         else if (progress === "failed") result.failed++;
         else result.stillPending++;
       }
     }
-    if (result.resolved > 0 || result.failed > 0) {
+    if (result.resolved > 0 || result.failed > 0 || result.stillPending > 0) {
+      console.log(`[V5-RESOLVE] Saving: resolved=${result.resolved} failed=${result.failed} stillPending=${result.stillPending}`);
       await this.save();
     }
     return result;
   }
+  /**
+   * Start a periodic interval that retries resolveUnconfirmed() until all
+   * tokens are confirmed or failed.  Stops automatically when nothing is
+   * pending and is cleaned up by destroy().
+   */
+  scheduleResolveUnconfirmed() {
+    if (this.resolveUnconfirmedTimer) return;
+    const hasUnconfirmed = Array.from(this.tokens.values()).some(
+      (t) => t.status === "submitted"
+    );
+    if (!hasUnconfirmed) {
+      console.log(`[V5-RESOLVE] scheduleResolveUnconfirmed: no submitted tokens, not starting timer`);
+      return;
+    }
+    console.log(`[V5-RESOLVE] scheduleResolveUnconfirmed: starting periodic retry (every ${_PaymentsModule.RESOLVE_UNCONFIRMED_INTERVAL_MS}ms)`);
+    this.resolveUnconfirmedTimer = setInterval(async () => {
+      try {
+        const result = await this.resolveUnconfirmed();
+        if (result.stillPending === 0) {
+          console.log(`[V5-RESOLVE] All tokens resolved, stopping periodic retry`);
+          this.stopResolveUnconfirmedPolling();
+        }
+      } catch (err) {
+        console.log(`[V5-RESOLVE] Periodic retry error:`, err);
+      }
+    }, _PaymentsModule.RESOLVE_UNCONFIRMED_INTERVAL_MS);
+  }
+  stopResolveUnconfirmedPolling() {
+    if (this.resolveUnconfirmedTimer) {
+      clearInterval(this.resolveUnconfirmedTimer);
+      this.resolveUnconfirmedTimer = null;
+    }
+  }
   // ===========================================================================
   // Private - V5 Lazy Resolution Helpers
   // ===========================================================================
@@ -5965,10 +6393,12 @@ var PaymentsModule = class _PaymentsModule {
     pending2.lastAttemptAt = Date.now();
     try {
       if (pending2.stage === "RECEIVED") {
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: RECEIVED \u2192 submitting mint commitment...`);
         const mintDataJson = JSON.parse(bundle.recipientMintData);
         const mintData = await MintTransactionData3.fromJSON(mintDataJson);
         const mintCommitment = await MintCommitment3.create(mintData);
         const mintResponse = await stClient.submitMintCommitment(mintCommitment);
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: mint response status=${mintResponse.status}`);
         if (mintResponse.status !== "SUCCESS" && mintResponse.status !== "REQUEST_ID_EXISTS") {
           throw new Error(`Mint submission failed: ${mintResponse.status}`);
         }
@@ -5976,22 +6406,27 @@ var PaymentsModule = class _PaymentsModule {
         this.updatePendingFinalization(token, pending2);
       }
       if (pending2.stage === "MINT_SUBMITTED") {
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: MINT_SUBMITTED \u2192 checking mint proof...`);
         const mintDataJson = JSON.parse(bundle.recipientMintData);
         const mintData = await MintTransactionData3.fromJSON(mintDataJson);
         const mintCommitment = await MintCommitment3.create(mintData);
         const proof = await this.quickProofCheck(stClient, trustBase, mintCommitment);
         if (!proof) {
+          console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: mint proof not yet available, staying MINT_SUBMITTED`);
           this.updatePendingFinalization(token, pending2);
           return "pending";
         }
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: mint proof obtained!`);
         pending2.mintProofJson = JSON.stringify(proof);
         pending2.stage = "MINT_PROVEN";
         this.updatePendingFinalization(token, pending2);
       }
       if (pending2.stage === "MINT_PROVEN") {
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: MINT_PROVEN \u2192 submitting transfer commitment...`);
         const transferCommitmentJson = JSON.parse(bundle.transferCommitment);
         const transferCommitment = await TransferCommitment4.fromJSON(transferCommitmentJson);
         const transferResponse = await stClient.submitTransferCommitment(transferCommitment);
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: transfer response status=${transferResponse.status}`);
         if (transferResponse.status !== "SUCCESS" && transferResponse.status !== "REQUEST_ID_EXISTS") {
           throw new Error(`Transfer submission failed: ${transferResponse.status}`);
         }
@@ -5999,13 +6434,16 @@ var PaymentsModule = class _PaymentsModule {
         this.updatePendingFinalization(token, pending2);
       }
       if (pending2.stage === "TRANSFER_SUBMITTED") {
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: TRANSFER_SUBMITTED \u2192 checking transfer proof...`);
         const transferCommitmentJson = JSON.parse(bundle.transferCommitment);
         const transferCommitment = await TransferCommitment4.fromJSON(transferCommitmentJson);
         const proof = await this.quickProofCheck(stClient, trustBase, transferCommitment);
         if (!proof) {
+          console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: transfer proof not yet available, staying TRANSFER_SUBMITTED`);
           this.updatePendingFinalization(token, pending2);
           return "pending";
         }
+        console.log(`[V5-RESOLVE] ${tokenId.slice(0, 12)}: transfer proof obtained! Finalizing...`);
         const finalizedToken = await this.finalizeFromV5Bundle(bundle, pending2, signingService, stClient, trustBase);
         const confirmedToken = {
           id: token.id,
@@ -6021,6 +6459,12 @@ var PaymentsModule = class _PaymentsModule {
           sdkData: JSON.stringify(finalizedToken.toJSON())
         };
         this.tokens.set(tokenId, confirmedToken);
+        this.deps.emitEvent("transfer:confirmed", {
+          id: crypto.randomUUID(),
+          status: "completed",
+          tokens: [confirmedToken],
+          tokenTransfers: []
+        });
         this.log(`V5 token resolved: ${tokenId.slice(0, 8)}...`);
         return "resolved";
       }
@@ -6162,11 +6606,20 @@ var PaymentsModule = class _PaymentsModule {
       }
     }
     if (pendingTokens.length > 0) {
+      const json = JSON.stringify(pendingTokens);
+      this.log(`[V5-PERSIST] Saving ${pendingTokens.length} pending V5 token(s): ${pendingTokens.map((t) => t.id.slice(0, 16)).join(", ")} (${json.length} bytes)`);
       await this.deps.storage.set(
         STORAGE_KEYS_ADDRESS.PENDING_V5_TOKENS,
-        JSON.stringify(pendingTokens)
+        json
       );
+      const verify = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.PENDING_V5_TOKENS);
+      if (!verify) {
+        console.error("[Payments][V5-PERSIST] CRITICAL: KV write succeeded but read-back is empty!");
+      } else {
+        this.log(`[V5-PERSIST] Verified: read-back ${verify.length} bytes`);
+      }
     } else {
+      this.log(`[V5-PERSIST] No pending V5 tokens to save (total tokens: ${this.tokens.size}), clearing KV`);
       await this.deps.storage.set(STORAGE_KEYS_ADDRESS.PENDING_V5_TOKENS, "");
     }
   }
@@ -6176,16 +6629,47 @@ var PaymentsModule = class _PaymentsModule {
    */
   async loadPendingV5Tokens() {
     const data = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.PENDING_V5_TOKENS);
+    this.log(`[V5-PERSIST] loadPendingV5Tokens: KV data = ${data ? `${data.length} bytes` : "null/empty"}`);
     if (!data) return;
     try {
       const pendingTokens = JSON.parse(data);
+      this.log(`[V5-PERSIST] Parsed ${pendingTokens.length} pending V5 token(s): ${pendingTokens.map((t) => t.id.slice(0, 16)).join(", ")}`);
       for (const token of pendingTokens) {
         if (!this.tokens.has(token.id)) {
           this.tokens.set(token.id, token);
+          this.log(`[V5-PERSIST] Restored token ${token.id.slice(0, 16)} (status=${token.status})`);
+        } else {
+          this.log(`[V5-PERSIST] Token ${token.id.slice(0, 16)} already in map, skipping`);
         }
       }
-      if (pendingTokens.length > 0) {
-        this.log(`Restored ${pendingTokens.length} pending V5 token(s)`);
+    } catch (err) {
+      console.error("[Payments][V5-PERSIST] Failed to parse pending V5 tokens:", err);
+    }
+  }
+  /**
+   * Persist the set of processed splitGroupIds to KV storage.
+   * This ensures Nostr re-deliveries are ignored across page reloads,
+   * even when the confirmed token's in-memory ID differs from v5split_{id}.
+   */
+  async saveProcessedSplitGroupIds() {
+    const ids = Array.from(this.processedSplitGroupIds);
+    if (ids.length > 0) {
+      await this.deps.storage.set(
+        STORAGE_KEYS_ADDRESS.PROCESSED_SPLIT_GROUP_IDS,
+        JSON.stringify(ids)
+      );
+    }
+  }
+  /**
+   * Load processed splitGroupIds from KV storage.
+   */
+  async loadProcessedSplitGroupIds() {
+    const data = await this.deps.storage.get(STORAGE_KEYS_ADDRESS.PROCESSED_SPLIT_GROUP_IDS);
+    if (!data) return;
+    try {
+      const ids = JSON.parse(data);
+      for (const id of ids) {
+        this.processedSplitGroupIds.add(id);
       }
     } catch {
     }
@@ -6840,7 +7324,32 @@ var PaymentsModule = class _PaymentsModule {
         try {
           const result = await provider.sync(localData);
           if (result.success && result.merged) {
+            const savedTokens = new Map(this.tokens);
             this.loadFromStorageData(result.merged);
+            let restoredCount = 0;
+            for (const [tokenId, token] of savedTokens) {
+              if (this.tokens.has(tokenId)) continue;
+              const sdkTokenId = extractTokenIdFromSdkData(token.sdkData);
+              const stateHash = extractStateHashFromSdkData(token.sdkData);
+              if (sdkTokenId && stateHash && this.isStateTombstoned(sdkTokenId, stateHash)) {
+                continue;
+              }
+              if (sdkTokenId) {
+                let hasEquivalent = false;
+                for (const existing of this.tokens.values()) {
+                  if (extractTokenIdFromSdkData(existing.sdkData) === sdkTokenId) {
+                    hasEquivalent = true;
+                    break;
+                  }
+                }
+                if (hasEquivalent) continue;
+              }
+              this.tokens.set(tokenId, token);
+              restoredCount++;
+            }
+            if (restoredCount > 0) {
+              console.log(`[Payments] Sync: restored ${restoredCount} token(s) lost by loadFromStorageData`);
+            }
             if (this.nametags.length === 0 && savedNametags.length > 0) {
               this.nametags = savedNametags;
             }
@@ -7142,7 +7651,7 @@ var PaymentsModule = class _PaymentsModule {
   /**
    * Handle NOSTR-FIRST commitment-only transfer (recipient side)
    * This is called when receiving a transfer with only commitmentData and no proof yet.
-   * We create the token as 'submitted', submit commitment (idempotent), and poll for proof.
+   * Delegates to saveCommitmentOnlyToken() helper, then emits event + records history.
    */
   async handleCommitmentOnlyTransfer(transfer, payload) {
     try {
@@ -7152,40 +7661,22 @@ var PaymentsModule = class _PaymentsModule {
         console.warn("[Payments] Invalid NOSTR-FIRST transfer format");
         return;
       }
-      const tokenInfo = await parseTokenInfo(sourceTokenInput);
-      const token = {
-        id: tokenInfo.tokenId ?? crypto.randomUUID(),
-        coinId: tokenInfo.coinId,
-        symbol: tokenInfo.symbol,
-        name: tokenInfo.name,
-        decimals: tokenInfo.decimals,
-        iconUrl: tokenInfo.iconUrl,
-        amount: tokenInfo.amount,
-        status: "submitted",
-        // NOSTR-FIRST: unconfirmed until proof
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-        sdkData: typeof sourceTokenInput === "string" ? sourceTokenInput : JSON.stringify(sourceTokenInput)
-      };
-      const nostrTokenId = extractTokenIdFromSdkData(token.sdkData);
-      const nostrStateHash = extractStateHashFromSdkData(token.sdkData);
-      if (nostrTokenId && nostrStateHash && this.isStateTombstoned(nostrTokenId, nostrStateHash)) {
-        this.log(`NOSTR-FIRST: Rejecting tombstoned token ${nostrTokenId.slice(0, 8)}..._${nostrStateHash.slice(0, 8)}...`);
-        return;
-      }
-      this.tokens.set(token.id, token);
-      await this.save();
-      this.log(`NOSTR-FIRST: Token ${token.id.slice(0, 8)}... added as submitted (unconfirmed)`);
+      const token = await this.saveCommitmentOnlyToken(
+        sourceTokenInput,
+        commitmentInput,
+        transfer.senderTransportPubkey
+      );
+      if (!token) return;
       const senderInfo = await this.resolveSenderInfo(transfer.senderTransportPubkey);
-      const incomingTransfer = {
+      this.deps.emitEvent("transfer:incoming", {
         id: transfer.id,
         senderPubkey: transfer.senderTransportPubkey,
         senderNametag: senderInfo.senderNametag,
         tokens: [token],
         memo: payload.memo,
         receivedAt: transfer.timestamp
-      };
-      this.deps.emitEvent("transfer:incoming", incomingTransfer);
+      });
+      const nostrTokenId = extractTokenIdFromSdkData(token.sdkData);
       await this.addToHistory({
         type: "RECEIVED",
         amount: token.amount,
@@ -7197,29 +7688,6 @@ var PaymentsModule = class _PaymentsModule {
         memo: payload.memo,
         tokenId: nostrTokenId || token.id
       });
-      try {
-        const commitment = await TransferCommitment4.fromJSON(commitmentInput);
-        const requestIdBytes = commitment.requestId;
-        const requestIdHex = requestIdBytes instanceof Uint8Array ? Array.from(requestIdBytes).map((b) => b.toString(16).padStart(2, "0")).join("") : String(requestIdBytes);
-        const stClient = this.deps.oracle.getStateTransitionClient?.();
-        if (stClient) {
-          const response = await stClient.submitTransferCommitment(commitment);
-          this.log(`NOSTR-FIRST recipient commitment submit: ${response.status}`);
-        }
-        this.addProofPollingJob({
-          tokenId: token.id,
-          requestIdHex,
-          commitmentJson: JSON.stringify(commitmentInput),
-          startedAt: Date.now(),
-          attemptCount: 0,
-          lastAttemptAt: 0,
-          onProofReceived: async (tokenId) => {
-            await this.finalizeReceivedToken(tokenId, sourceTokenInput, commitmentInput);
-          }
-        });
-      } catch (err) {
-        console.error("[Payments] Failed to parse commitment for proof polling:", err);
-      }
     } catch (error) {
       console.error("[Payments] Failed to process NOSTR-FIRST transfer:", error);
     }
@@ -7332,8 +7800,34 @@ var PaymentsModule = class _PaymentsModule {
     }
   }
   async handleIncomingTransfer(transfer) {
+    if (!this.loaded && this.loadedPromise) {
+      await this.loadedPromise;
+    }
     try {
       const payload = transfer.payload;
+      console.log("[Payments][DEBUG] handleIncomingTransfer: keys=", Object.keys(payload).join(","));
+      let combinedBundle = null;
+      if (isCombinedTransferBundleV6(payload)) {
+        combinedBundle = payload;
+      } else if (payload.token) {
+        try {
+          const inner = typeof payload.token === "string" ? JSON.parse(payload.token) : payload.token;
+          if (isCombinedTransferBundleV6(inner)) {
+            combinedBundle = inner;
+          }
+        } catch {
+        }
+      }
+      if (combinedBundle) {
+        this.log("Processing COMBINED_TRANSFER V6 bundle...");
+        try {
+          await this.processCombinedTransferBundle(combinedBundle, transfer.senderTransportPubkey);
+          this.log("COMBINED_TRANSFER V6 processed successfully");
+        } catch (err) {
+          console.error("[Payments] COMBINED_TRANSFER V6 processing error:", err);
+        }
+        return;
+      }
       let instantBundle = null;
       if (isInstantSplitBundle(payload)) {
         instantBundle = payload;
@@ -7365,7 +7859,7 @@ var PaymentsModule = class _PaymentsModule {
         return;
       }
       if (payload.sourceToken && payload.commitmentData && !payload.transferTx) {
-        this.log("Processing NOSTR-FIRST commitment-only transfer...");
+        console.log("[Payments][DEBUG] >>> NOSTR-FIRST commitment-only transfer detected");
         await this.handleCommitmentOnlyTransfer(transfer, payload);
         return;
       }
@@ -7485,17 +7979,19 @@ var PaymentsModule = class _PaymentsModule {
           memo: payload.memo,
           tokenId: incomingTokenId || token.id
         });
+        const incomingTransfer = {
+          id: transfer.id,
+          senderPubkey: transfer.senderTransportPubkey,
+          senderNametag: senderInfo.senderNametag,
+          tokens: [token],
+          memo: payload.memo,
+          receivedAt: transfer.timestamp
+        };
+        this.deps.emitEvent("transfer:incoming", incomingTransfer);
+        this.log(`Incoming transfer processed: ${token.id}, ${token.amount} ${token.symbol}`);
+      } else {
+        this.log(`Duplicate transfer ignored: ${token.id}, ${token.amount} ${token.symbol}`);
       }
-      const incomingTransfer = {
-        id: transfer.id,
-        senderPubkey: transfer.senderTransportPubkey,
-        senderNametag: senderInfo.senderNametag,
-        tokens: [token],
-        memo: payload.memo,
-        receivedAt: transfer.timestamp
-      };
-      this.deps.emitEvent("transfer:incoming", incomingTransfer);
-      this.log(`Incoming transfer processed: ${token.id}, ${token.amount} ${token.symbol}`);
     } catch (error) {
       console.error("[Payments] Failed to process incoming transfer:", error);
     }
@@ -7528,17 +8024,24 @@ var PaymentsModule = class _PaymentsModule {
   // ===========================================================================
   async save() {
     const providers = this.getTokenStorageProviders();
-    if (providers.size === 0) {
-      this.log("No token storage providers - tokens not persisted");
-      return;
-    }
-    const data = await this.createStorageData();
-    for (const [id, provider] of providers) {
-      try {
-        await provider.save(data);
-      } catch (err) {
-        console.error(`[Payments] Failed to save to provider ${id}:`, err);
+    const tokenStats = Array.from(this.tokens.values()).map((t) => {
+      const txf = tokenToTxf(t);
+      return `${t.id.slice(0, 12)}(${t.status},txf=${!!txf})`;
+    });
+    console.log(`[Payments][DEBUG] save(): providers=${providers.size}, tokens=[${tokenStats.join(", ")}]`);
+    if (providers.size > 0) {
+      const data = await this.createStorageData();
+      const dataKeys = Object.keys(data).filter((k) => k.startsWith("token-"));
+      console.log(`[Payments][DEBUG] save(): TXF keys=${dataKeys.length} (${dataKeys.join(", ")})`);
+      for (const [id, provider] of providers) {
+        try {
+          await provider.save(data);
+        } catch (err) {
+          console.error(`[Payments] Failed to save to provider ${id}:`, err);
+        }
       }
+    } else {
+      console.log("[Payments][DEBUG] save(): No token storage providers - TXF not persisted");
     }
     await this.savePendingV5Tokens();
   }
@@ -7574,6 +8077,7 @@ var PaymentsModule = class _PaymentsModule {
   }
   loadFromStorageData(data) {
     const parsed = parseTxfStorageData(data);
+    console.log(`[Payments][DEBUG] loadFromStorageData: parsed ${parsed.tokens.length} tokens, ${parsed.tombstones.length} tombstones, errors=[${parsed.validationErrors.join("; ")}]`);
     this.tombstones = parsed.tombstones;
     this.tokens.clear();
     for (const token of parsed.tokens) {
@@ -16608,6 +17112,7 @@ export {
   identityFromMnemonicSync,
   initSphere,
   isArchivedKey,
+  isCombinedTransferBundleV6,
   isForkedKey,
   isInstantSplitBundle,
   isInstantSplitBundleV4,