@unicitylabs/sphere-sdk 0.7.2 → 0.8.0-dev.0

package/dist/index.cjs

@@ -917,8 +917,8 @@ __export(index_exports, {
   NETWORKS: () => NETWORKS,
   NIP29_KINDS: () => NIP29_KINDS,
   NOSTR_EVENT_KINDS: () => NOSTR_EVENT_KINDS,
-  NostrClient: () => import_nostr_js_sdk7.NostrClient,
-  NostrKeyManager: () => import_nostr_js_sdk7.NostrKeyManager,
+  NostrClient: () => import_nostr_js_sdk6.NostrClient,
+  NostrKeyManager: () => import_nostr_js_sdk6.NostrKeyManager,
   PaymentsModule: () => PaymentsModule,
   SIGN_MESSAGE_PREFIX: () => SIGN_MESSAGE_PREFIX,
   STORAGE_KEYS: () => STORAGE_KEYS,
@@ -936,7 +936,7 @@ __export(index_exports, {
   TokenValidator: () => TokenValidator,
   addressesMatch: () => addressesMatch,
   archivedKeyFromTokenId: () => archivedKeyFromTokenId,
-  areSameNametag: () => import_nostr_js_sdk6.areSameNametag,
+  areSameNametag: () => import_nostr_js_sdk5.areSameNametag,
   base58Decode: () => base58Decode,
   base58Encode: () => base58Encode2,
   buildManifest: () => buildManifest,
@@ -966,7 +966,7 @@ __export(index_exports, {
   decryptCMasterKey: () => decryptCMasterKey,
   decryptJson: () => decryptJson,
   decryptMnemonic: () => decryptMnemonic,
-  decryptNametag: () => import_nostr_js_sdk6.decryptNametag,
+  decryptNametag: () => import_nostr_js_sdk5.decryptNametag,
   decryptPrivateKey: () => decryptPrivateKey,
   decryptSimple: () => decryptSimple,
   decryptTextFormatKey: () => decryptTextFormatKey,
@@ -979,7 +979,7 @@ __export(index_exports, {
   encodeBech32: () => encodeBech32,
   encrypt: () => encrypt2,
   encryptMnemonic: () => encryptMnemonic,
-  encryptNametag: () => import_nostr_js_sdk6.encryptNametag,
+  encryptNametag: () => import_nostr_js_sdk5.encryptNametag,
   encryptSimple: () => encryptSimple,
   encryptWallet: () => encryptWallet,
   extractFromText: () => extractFromText,
@@ -1008,8 +1008,8 @@ __export(index_exports, {
   hasUncommittedTransactions: () => hasUncommittedTransactions,
   hasValidTxfData: () => hasValidTxfData,
   hash160: () => hash160,
-  hashAddressForTag: () => import_nostr_js_sdk6.hashAddressForTag,
-  hashNametag: () => import_nostr_js_sdk6.hashNametag,
+  hashAddressForTag: () => import_nostr_js_sdk5.hashAddressForTag,
+  hashNametag: () => import_nostr_js_sdk5.hashNametag,
   hashSignMessage: () => hashSignMessage,
   hexToBytes: () => hexToBytes2,
   hexToWIF: () => hexToWIF,
@@ -1024,7 +1024,7 @@ __export(index_exports, {
   isKnownToken: () => isKnownToken,
   isPaymentSessionTerminal: () => isPaymentSessionTerminal,
   isPaymentSessionTimedOut: () => isPaymentSessionTimedOut,
-  isPhoneNumber: () => import_nostr_js_sdk6.isPhoneNumber,
+  isPhoneNumber: () => import_nostr_js_sdk5.isPhoneNumber,
   isSQLiteDatabase: () => isSQLiteDatabase,
   isSphereError: () => isSphereError,
   isTextWalletEncrypted: () => isTextWalletEncrypted,
@@ -1043,7 +1043,7 @@ __export(index_exports, {
   mnemonicToSeedSync: () => mnemonicToSeedSync2,
   normalizeAddress: () => normalizeAddress,
   normalizeCoinId: () => normalizeCoinId,
-  normalizeNametag: () => import_nostr_js_sdk6.normalizeNametag,
+  normalizeNametag: () => import_nostr_js_sdk5.normalizeNametag,
   normalizeSdkTokenToStorage: () => normalizeSdkTokenToStorage,
   objectToTxf: () => objectToTxf,
   parseAddress: () => parseAddress,
@@ -2096,26 +2096,14 @@ var NostrTransportProvider = class _NostrTransportProvider {
   }
   /**
    * Convert a BindingInfo (from nostr-js-sdk) to PeerInfo (sphere-sdk type).
-   * Computes PROXY address from nametag if available.
    */
   async bindingInfoToPeerInfo(binding, nametag) {
-    const nametagValue = nametag || binding.nametag;
-    let proxyAddress = binding.proxyAddress;
-    if (nametagValue && !proxyAddress) {
-      try {
-        const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
-        const proxyAddr = await ProxyAddress.fromNameTag(nametagValue);
-        proxyAddress = proxyAddr.toString();
-      } catch {
-      }
-    }
     return {
-      nametag: nametagValue,
+      nametag: nametag || binding.nametag,
       transportPubkey: binding.transportPubkey,
       chainPubkey: binding.publicKey || "",
       l1Address: binding.l1Address || "",
       directAddress: binding.directAddress || "",
-      proxyAddress,
       timestamp: binding.timestamp
     };
   }
@@ -2141,7 +2129,6 @@ var NostrTransportProvider = class _NostrTransportProvider {
         chainPubkey: content.public_key || "",
         l1Address: content.l1_address || "",
         directAddress: content.direct_address || "",
-        proxyAddress: content.proxy_address || void 0,
         timestamp: bindingEvent.created_at * 1e3
       };
     } catch {
@@ -2184,7 +2171,6 @@ var NostrTransportProvider = class _NostrTransportProvider {
           chainPubkey: content.public_key || "",
           l1Address: content.l1_address || "",
           directAddress: content.direct_address || "",
-          proxyAddress: content.proxy_address || void 0,
           timestamp: event.created_at * 1e3
         });
       } catch {
@@ -2254,8 +2240,6 @@ var NostrTransportProvider = class _NostrTransportProvider {
     }
     const nostrPubkey = this.getNostrPubkey();
     if (nametag) {
-      const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
-      const proxyAddr = await ProxyAddress.fromNameTag(nametag);
       try {
         const success2 = await this.nostrClient.publishNametagBinding(
           nametag,
@@ -2263,8 +2247,7 @@ var NostrTransportProvider = class _NostrTransportProvider {
           {
             publicKey: chainPubkey,
             l1Address,
-            directAddress,
-            proxyAddress: proxyAddr.toString()
+            directAddress
           }
         );
         if (success2) {
@@ -6468,6 +6451,13 @@ function createL1PaymentsModule(config) {
   return new L1PaymentsModule(config);
 }
 
+// types/v2-transfer.ts
+function isV2TransferPayload(obj) {
+  if (!obj || typeof obj !== "object") return false;
+  const p = obj;
+  return p.type === "V2_TRANSFER" && typeof p.tokenBlob === "string" && p.tokenBlob.length > 0;
+}
+
 // modules/payments/TokenSplitExecutor.ts
 init_logger();
 init_errors();
@@ -6841,18 +6831,117 @@ var TokenReservationLedger = class {
 // modules/payments/SpendQueue.ts
 init_logger();
 init_errors();
-var import_Token2 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
+var import_Token3 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
 var import_CoinId2 = require("@unicitylabs/state-transition-sdk/lib/token/fungible/CoinId");
+
+// token-engine/sdk.ts
+var import_StateTransitionClient = require("state-transition-sdk-v2/lib/StateTransitionClient.js");
+var import_AggregatorClient = require("state-transition-sdk-v2/lib/api/AggregatorClient.js");
+var import_NetworkId = require("state-transition-sdk-v2/lib/api/NetworkId.js");
+var import_CertificationData = require("state-transition-sdk-v2/lib/api/CertificationData.js");
+var import_CertificationResponse = require("state-transition-sdk-v2/lib/api/CertificationResponse.js");
+var import_StateId = require("state-transition-sdk-v2/lib/api/StateId.js");
+var import_InclusionProof = require("state-transition-sdk-v2/lib/api/InclusionProof.js");
+var import_InclusionProofResponse = require("state-transition-sdk-v2/lib/api/InclusionProofResponse.js");
+var import_RootTrustBase = require("state-transition-sdk-v2/lib/api/bft/RootTrustBase.js");
+var import_InclusionProofUtils2 = require("state-transition-sdk-v2/lib/util/InclusionProofUtils.js");
+var import_Token2 = require("state-transition-sdk-v2/lib/transaction/Token.js");
+var import_MintTransaction = require("state-transition-sdk-v2/lib/transaction/MintTransaction.js");
+var import_TransferTransaction = require("state-transition-sdk-v2/lib/transaction/TransferTransaction.js");
+var import_CertifiedMintTransaction = require("state-transition-sdk-v2/lib/transaction/CertifiedMintTransaction.js");
+var import_CertifiedTransferTransaction = require("state-transition-sdk-v2/lib/transaction/CertifiedTransferTransaction.js");
+var import_TokenId2 = require("state-transition-sdk-v2/lib/transaction/TokenId.js");
+var import_TokenType = require("state-transition-sdk-v2/lib/transaction/TokenType.js");
+var import_TokenSalt = require("state-transition-sdk-v2/lib/transaction/TokenSalt.js");
+var import_MintJustificationVerifierService = require("state-transition-sdk-v2/lib/transaction/verification/MintJustificationVerifierService.js");
+var import_EncodedPredicate = require("state-transition-sdk-v2/lib/predicate/EncodedPredicate.js");
+var import_SignaturePredicate = require("state-transition-sdk-v2/lib/predicate/builtin/SignaturePredicate.js");
+var import_SignaturePredicateUnlockScript = require("state-transition-sdk-v2/lib/predicate/builtin/SignaturePredicateUnlockScript.js");
+var import_BurnPredicate = require("state-transition-sdk-v2/lib/predicate/builtin/BurnPredicate.js");
+var import_PredicateVerifierService = require("state-transition-sdk-v2/lib/predicate/verification/PredicateVerifierService.js");
+var import_SigningService = require("state-transition-sdk-v2/lib/crypto/secp256k1/SigningService.js");
+var import_Signature = require("state-transition-sdk-v2/lib/crypto/secp256k1/Signature.js");
+var import_MintSigningService = require("state-transition-sdk-v2/lib/crypto/MintSigningService.js");
+var import_HashAlgorithm2 = require("state-transition-sdk-v2/lib/crypto/hash/HashAlgorithm.js");
+var import_DataHash = require("state-transition-sdk-v2/lib/crypto/hash/DataHash.js");
+var import_DataHasher = require("state-transition-sdk-v2/lib/crypto/hash/DataHasher.js");
+var import_DataHasherFactory = require("state-transition-sdk-v2/lib/crypto/hash/DataHasherFactory.js");
+var import_CborSerializer = require("state-transition-sdk-v2/lib/serialization/cbor/CborSerializer.js");
+var import_CborDeserializer = require("state-transition-sdk-v2/lib/serialization/cbor/CborDeserializer.js");
+var import_CborError = require("state-transition-sdk-v2/lib/serialization/cbor/CborError.js");
+var import_Asset = require("state-transition-sdk-v2/lib/payment/asset/Asset.js");
+var import_AssetId = require("state-transition-sdk-v2/lib/payment/asset/AssetId.js");
+var import_PaymentAssetCollection = require("state-transition-sdk-v2/lib/payment/asset/PaymentAssetCollection.js");
+var import_TokenSplit = require("state-transition-sdk-v2/lib/payment/TokenSplit.js");
+var import_SplitTokenRequest = require("state-transition-sdk-v2/lib/payment/SplitTokenRequest.js");
+var import_SplitToken = require("state-transition-sdk-v2/lib/payment/SplitToken.js");
+var import_SplitAssetProof = require("state-transition-sdk-v2/lib/payment/SplitAssetProof.js");
+var import_SplitMintJustification = require("state-transition-sdk-v2/lib/payment/SplitMintJustification.js");
+var import_SplitMintJustificationVerifier = require("state-transition-sdk-v2/lib/payment/SplitMintJustificationVerifier.js");
+var import_VerificationStatus = require("state-transition-sdk-v2/lib/verification/VerificationStatus.js");
+var import_VerificationResult = require("state-transition-sdk-v2/lib/verification/VerificationResult.js");
+var import_HexConverter = require("state-transition-sdk-v2/lib/util/HexConverter.js");
+var import_BigintConverter = require("state-transition-sdk-v2/lib/util/BigintConverter.js");
+var import_BitString = require("state-transition-sdk-v2/lib/util/BitString.js");
+
+// token-engine/token-blob.ts
+var TOKEN_BLOB_TAG = 39051n;
+var TOKEN_BLOB_VERSION = 1;
+function encodeTokenBlob(blob) {
+  return import_CborSerializer.CborSerializer.encodeTag(
+    TOKEN_BLOB_TAG,
+    import_CborSerializer.CborSerializer.encodeArray(
+      import_CborSerializer.CborSerializer.encodeUnsignedInteger(BigInt(blob.v)),
+      import_CborSerializer.CborSerializer.encodeUnsignedInteger(BigInt(blob.network)),
+      import_CborSerializer.CborSerializer.encodeTextString(blob.tokenId),
+      import_CborSerializer.CborSerializer.encodeByteString(blob.token)
+    )
+  );
+}
+function decodeTokenBlob(bytes) {
+  const tag = import_CborDeserializer.CborDeserializer.decodeTag(bytes);
+  if (tag.tag !== TOKEN_BLOB_TAG) {
+    throw new import_CborError.CborError(`Invalid TokenBlob tag: ${tag.tag}`);
+  }
+  const fields = import_CborDeserializer.CborDeserializer.decodeArray(tag.data, 4);
+  const v = Number(import_CborDeserializer.CborDeserializer.decodeUnsignedInteger(fields[0]));
+  if (v !== TOKEN_BLOB_VERSION) {
+    throw new import_CborError.CborError(`Unsupported TokenBlob version: ${v}`);
+  }
+  return {
+    v,
+    network: Number(import_CborDeserializer.CborDeserializer.decodeUnsignedInteger(fields[1])),
+    tokenId: import_CborDeserializer.CborDeserializer.decodeTextString(fields[2]),
+    token: import_CborDeserializer.CborDeserializer.decodeByteString(fields[3])
+  };
+}
+
+// modules/payments/SpendQueue.ts
 var QUEUE_TIMEOUT_MS = 3e4;
 var QUEUE_MAX_SIZE = 100;
 var TAG2 = "SpendQueue";
 var SpendPlanner = class {
+  /**
+   * Token engine (path B). When injected, value reads go through the v2 engine
+   * (sdkData = engine blob); otherwise the legacy v1 SdkToken path is used. The
+   * engine is wired after construction via {@link setEngine} (it is bound to the
+   * payments deps, which arrive after the planner is built).
+   */
+  engine;
+  constructor(engine) {
+    this.engine = engine;
+  }
+  /** Inject (or clear) the token engine. */
+  setEngine(engine) {
+    this.engine = engine;
+  }
   /**
    * Async pre-computation: parse all tokens for a given coinId.
    * Called BEFORE the synchronous critical section.
    *
-   * Filters to confirmed tokens matching the coinId, parses each
-   * token's sdkData into an SdkToken, and extracts the bigint amount.
+   * Filters to confirmed tokens matching the coinId, decodes each token's
+   * sdkData and extracts the bigint amount — via the v2 engine when injected,
+   * else the legacy v1 SdkToken path.
    */
   async buildParsedPool(tokens, coinId) {
     const pool = /* @__PURE__ */ new Map();
@@ -6861,20 +6950,28 @@ var SpendPlanner = class {
       if (t.status !== "confirmed") continue;
       if (!t.sdkData) continue;
       try {
-        const parsed = JSON.parse(t.sdkData);
-        const sdkToken = await import_Token2.Token.fromJSON(parsed);
-        const realAmount = this.getTokenBalance(sdkToken, coinId);
-        if (realAmount <= 0n) {
+        const { sdkToken, amount } = this.engine ? await this.parseViaEngine(t.sdkData, coinId) : await this.parseViaSdk(t.sdkData, coinId);
+        if (amount <= 0n) {
           logger.warn(TAG2, `Token ${t.id} has 0 balance for coinId ${coinId}`);
           continue;
         }
-        pool.set(t.id, { token: t, sdkToken, amount: realAmount });
+        pool.set(t.id, { token: t, sdkToken, amount });
       } catch (e) {
         logger.warn(TAG2, "Failed to parse token", t.id, e);
       }
     }
     return pool;
   }
+  /** Engine path (v2): sdkData is the engine blob (hex of CBOR(TokenBlob)). */
+  async parseViaEngine(sdkData, coinId) {
+    const token = await this.engine.decodeToken(decodeTokenBlob(hexToBytes2(sdkData)));
+    return { sdkToken: token, amount: this.engine.balanceOf(token, coinId) };
+  }
+  /** Legacy v1 path: sdkData is TXF JSON. */
+  async parseViaSdk(sdkData, coinId) {
+    const sdkToken = await import_Token3.Token.fromJSON(JSON.parse(sdkData));
+    return { sdkToken, amount: this.getTokenBalance(sdkToken, coinId) };
+  }
   /**
    * SYNCHRONOUS critical section. NO await allowed anywhere in this method.
    *
@@ -7285,174 +7382,6 @@ var SpendQueue = class {
   }
 };
 
-// modules/payments/NametagMinter.ts
-init_logger();
-var import_Token3 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
-var import_TokenId2 = require("@unicitylabs/state-transition-sdk/lib/token/TokenId");
-var import_TokenType = require("@unicitylabs/state-transition-sdk/lib/token/TokenType");
-var import_TokenState2 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
-var import_MintTransactionData = require("@unicitylabs/state-transition-sdk/lib/transaction/MintTransactionData");
-var import_MintCommitment = require("@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment");
-var import_HashAlgorithm2 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
-var import_UnmaskedPredicate2 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
-var import_InclusionProofUtils2 = require("@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils");
-var import_nostr_js_sdk3 = require("@unicitylabs/nostr-js-sdk");
-var UNICITY_TOKEN_TYPE_HEX = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
-var NametagMinter = class {
-  client;
-  trustBase;
-  signingService;
-  skipVerification;
-  debug;
-  constructor(config) {
-    this.client = config.stateTransitionClient;
-    this.trustBase = config.trustBase;
-    this.signingService = config.signingService;
-    this.skipVerification = config.skipVerification ?? false;
-    this.debug = config.debug ?? false;
-  }
-  log(message, ...args) {
-    logger.debug("NametagMinter", message, ...args);
-  }
-  /**
-   * Check if a nametag is available (not already minted)
-   */
-  async isNametagAvailable(nametag) {
-    try {
-      const stripped = nametag.startsWith("@") ? nametag.slice(1) : nametag;
-      const cleanNametag = (0, import_nostr_js_sdk3.normalizeNametag)(stripped);
-      const nametagTokenId = await import_TokenId2.TokenId.fromNameTag(cleanNametag);
-      const isMinted = await this.client.isMinted(this.trustBase, nametagTokenId);
-      return !isMinted;
-    } catch (error) {
-      this.log("Error checking nametag availability:", error);
-      return false;
-    }
-  }
-  /**
-   * Mint a nametag token on-chain
-   *
-   * @param nametag - The nametag to mint (e.g., "alice" or "@alice")
-   * @param ownerAddress - The owner's direct address
-   * @returns MintNametagResult with token if successful
-   */
-  async mintNametag(nametag, ownerAddress) {
-    const stripped = nametag.startsWith("@") ? nametag.slice(1) : nametag;
-    const cleanNametag = (0, import_nostr_js_sdk3.normalizeNametag)(stripped);
-    this.log(`Starting mint for nametag: ${cleanNametag}`);
-    try {
-      const nametagTokenId = await import_TokenId2.TokenId.fromNameTag(cleanNametag);
-      const nametagTokenType = new import_TokenType.TokenType(
-        Buffer.from(UNICITY_TOKEN_TYPE_HEX, "hex")
-      );
-      const nametagBytes = new TextEncoder().encode(cleanNametag);
-      const pubKey = this.signingService.publicKey;
-      const saltInput = new Uint8Array(pubKey.length + nametagBytes.length);
-      saltInput.set(pubKey, 0);
-      saltInput.set(nametagBytes, pubKey.length);
-      const saltBuffer = await crypto.subtle.digest("SHA-256", saltInput);
-      const salt = new Uint8Array(saltBuffer);
-      this.log("Generated deterministic salt");
-      const mintData = await import_MintTransactionData.MintTransactionData.createFromNametag(
-        cleanNametag,
-        nametagTokenType,
-        ownerAddress,
-        salt,
-        ownerAddress
-      );
-      this.log("Created MintTransactionData");
-      const commitment = await import_MintCommitment.MintCommitment.create(mintData);
-      this.log("Created MintCommitment");
-      const MAX_RETRIES = 3;
-      let submitSuccess = false;
-      for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        try {
-          this.log(`Submitting commitment (attempt ${attempt}/${MAX_RETRIES})...`);
-          const response = await this.client.submitMintCommitment(commitment);
-          if (response.status === "SUCCESS" || response.status === "REQUEST_ID_EXISTS") {
-            this.log(`Commitment ${response.status === "REQUEST_ID_EXISTS" ? "already exists" : "submitted successfully"}`);
-            submitSuccess = true;
-            break;
-          } else {
-            this.log(`Commitment failed: ${response.status}`);
-            if (attempt === MAX_RETRIES) {
-              return {
-                success: false,
-                error: `Failed to submit commitment after ${MAX_RETRIES} attempts: ${response.status}`
-              };
-            }
-            await new Promise((r) => setTimeout(r, 1e3 * attempt));
-          }
-        } catch (error) {
-          this.log(`Attempt ${attempt} error:`, error);
-          if (attempt === MAX_RETRIES) {
-            return {
-              success: false,
-              error: `Submit failed: ${error instanceof Error ? error.message : String(error)}`
-            };
-          }
-          await new Promise((r) => setTimeout(r, 1e3 * attempt));
-        }
-      }
-      if (!submitSuccess) {
-        return {
-          success: false,
-          error: "Failed to submit commitment after retries"
-        };
-      }
-      this.log("Waiting for inclusion proof...");
-      const inclusionProof = await (0, import_InclusionProofUtils2.waitInclusionProof)(this.trustBase, this.client, commitment);
-      this.log("Received inclusion proof");
-      const genesisTransaction = commitment.toTransaction(inclusionProof);
-      const nametagPredicate = await import_UnmaskedPredicate2.UnmaskedPredicate.create(
-        nametagTokenId,
-        nametagTokenType,
-        this.signingService,
-        import_HashAlgorithm2.HashAlgorithm.SHA256,
-        salt
-      );
-      const tokenState = new import_TokenState2.TokenState(nametagPredicate, null);
-      let token;
-      if (this.skipVerification) {
-        this.log("Creating token WITHOUT verification (dev mode)");
-        const tokenJson = {
-          version: "2.0",
-          state: tokenState.toJSON(),
-          genesis: genesisTransaction.toJSON(),
-          transactions: [],
-          nametags: []
-        };
-        token = await import_Token3.Token.fromJSON(tokenJson);
-      } else {
-        token = await import_Token3.Token.mint(
-          this.trustBase,
-          tokenState,
-          genesisTransaction
-        );
-      }
-      this.log(`Nametag minted successfully: ${cleanNametag}`);
-      const nametagData = {
-        name: cleanNametag,
-        token: token.toJSON(),
-        timestamp: Date.now(),
-        format: "txf",
-        version: "2.0"
-      };
-      return {
-        success: true,
-        token,
-        nametagData
-      };
-    } catch (error) {
-      this.log("Minting failed:", error);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error)
-      };
-    }
-  }
-};
-
 // modules/payments/PaymentsModule.ts
 init_constants();
 
@@ -8069,6 +7998,15 @@ function txfToToken(tokenId, txf) {
     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: {
@@ -8099,6 +8037,8 @@ async function buildTxfStorageData(tokens, meta, options) {
     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) {
@@ -8196,6 +8136,8 @@ function parseTxfStorageData(data) {
         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}`);
@@ -8471,12 +8413,12 @@ init_logger();
 init_errors();
 var import_Token4 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
 var import_TokenId3 = require("@unicitylabs/state-transition-sdk/lib/token/TokenId");
-var import_TokenState3 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
+var import_TokenState2 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
 var import_CoinId3 = require("@unicitylabs/state-transition-sdk/lib/token/fungible/CoinId");
 var import_TokenCoinData2 = require("@unicitylabs/state-transition-sdk/lib/token/fungible/TokenCoinData");
 var import_TokenSplitBuilder2 = require("@unicitylabs/state-transition-sdk/lib/transaction/split/TokenSplitBuilder");
 var import_HashAlgorithm3 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
-var import_UnmaskedPredicate3 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
+var import_UnmaskedPredicate2 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
 var import_UnmaskedPredicateReference2 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
 var import_TransferCommitment2 = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferCommitment");
 var import_InclusionProofUtils3 = require("@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils");
@@ -8598,14 +8540,14 @@ var InstantSplitExecutor = class {
       options?.message
       // on-chain message (invoice memo bytes, or null)
     );
-    const mintedPredicate = await import_UnmaskedPredicate3.UnmaskedPredicate.create(
+    const mintedPredicate = await import_UnmaskedPredicate2.UnmaskedPredicate.create(
       recipientTokenId,
       tokenToSplit.type,
       this.signingService,
       import_HashAlgorithm3.HashAlgorithm.SHA256,
       recipientSalt
     );
-    const mintedState = new import_TokenState3.TokenState(mintedPredicate, null);
+    const mintedState = new import_TokenState2.TokenState(mintedPredicate, null);
     logger.debug("InstantSplit", "Step 5: Packaging V5 bundle...");
     const senderPubkey = toHex2(this.signingService.publicKey);
     let nametagTokenJson;
@@ -8720,14 +8662,14 @@ var InstantSplitExecutor = class {
    * It does NOT need the genesis transaction or mint proof.
    */
   async createTransferCommitmentFromMintData(mintData, recipientAddress, transferSalt, signingService, nametagTokens, message) {
-    const predicate = await import_UnmaskedPredicate3.UnmaskedPredicate.create(
+    const predicate = await import_UnmaskedPredicate2.UnmaskedPredicate.create(
       mintData.tokenId,
       mintData.tokenType,
       signingService,
       import_HashAlgorithm3.HashAlgorithm.SHA256,
       mintData.salt
     );
-    const state = new import_TokenState3.TokenState(predicate, null);
+    const state = new import_TokenState2.TokenState(predicate, null);
     const minimalToken = {
       state,
       nametagTokens: nametagTokens || [],
@@ -8788,14 +8730,14 @@ var InstantSplitExecutor = class {
           message: `Mint proof received in ${proofDuration.toFixed(0)}ms`
         });
         const mintTransaction = senderMintCommitment.toTransaction(senderMintProof);
-        const predicate = await import_UnmaskedPredicate3.UnmaskedPredicate.create(
+        const predicate = await import_UnmaskedPredicate2.UnmaskedPredicate.create(
           context.senderTokenId,
           context.tokenType,
           context.signingService,
           import_HashAlgorithm3.HashAlgorithm.SHA256,
           context.senderSalt
         );
-        const state = new import_TokenState3.TokenState(predicate, null);
+        const state = new import_TokenState2.TokenState(predicate, null);
         const changeToken = await import_Token4.Token.mint(this.trustBase, state, mintTransaction);
         if (!this.devMode) {
           const verification = await changeToken.verify(this.trustBase);
@@ -8875,14 +8817,14 @@ var InstantSplitExecutor = class {
 init_logger();
 init_errors();
 var import_Token5 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
-var import_TokenState4 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
+var import_TokenState3 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
 var import_TokenType2 = require("@unicitylabs/state-transition-sdk/lib/token/TokenType");
 var import_HashAlgorithm4 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
-var import_UnmaskedPredicate4 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
+var import_UnmaskedPredicate3 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
 var import_TransferCommitment3 = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferCommitment");
-var import_TransferTransaction = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferTransaction");
-var import_MintCommitment2 = require("@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment");
-var import_MintTransactionData2 = require("@unicitylabs/state-transition-sdk/lib/transaction/MintTransactionData");
+var import_TransferTransaction2 = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferTransaction");
+var import_MintCommitment = require("@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment");
+var import_MintTransactionData = require("@unicitylabs/state-transition-sdk/lib/transaction/MintTransactionData");
 var import_InclusionProofUtils4 = require("@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils");
 
 // types/instant-split.ts
@@ -8975,11 +8917,11 @@ var InstantSplitProcessor = class {
         logger.warn("InstantSplit", "Sender pubkey mismatch (non-fatal)");
       }
       const burnTxJson = JSON.parse(bundle.burnTransaction);
-      const _burnTransaction = await import_TransferTransaction.TransferTransaction.fromJSON(burnTxJson);
+      const _burnTransaction = await import_TransferTransaction2.TransferTransaction.fromJSON(burnTxJson);
       logger.debug("InstantSplit", "Burn transaction validated");
       const mintDataJson = JSON.parse(bundle.recipientMintData);
-      const mintData = await import_MintTransactionData2.MintTransactionData.fromJSON(mintDataJson);
-      const mintCommitment = await import_MintCommitment2.MintCommitment.create(mintData);
+      const mintData = await import_MintTransactionData.MintTransactionData.fromJSON(mintDataJson);
+      const mintCommitment = await import_MintCommitment.MintCommitment.create(mintData);
       logger.debug("InstantSplit", "Mint commitment recreated");
       const mintResponse = await this.client.submitMintCommitment(mintCommitment);
       if (mintResponse.status !== "SUCCESS" && mintResponse.status !== "REQUEST_ID_EXISTS") {
@@ -9011,14 +8953,14 @@ var InstantSplitProcessor = class {
       const transferTransaction = transferCommitment.toTransaction(transferProof);
       logger.debug("InstantSplit", "Transfer proof received");
       const transferSalt = fromHex3(bundle.transferSaltHex);
-      const finalRecipientPredicate = await import_UnmaskedPredicate4.UnmaskedPredicate.create(
+      const finalRecipientPredicate = await import_UnmaskedPredicate3.UnmaskedPredicate.create(
         mintData.tokenId,
         tokenType,
         signingService,
         import_HashAlgorithm4.HashAlgorithm.SHA256,
         transferSalt
       );
-      const finalRecipientState = new import_TokenState4.TokenState(finalRecipientPredicate, null);
+      const finalRecipientState = new import_TokenState3.TokenState(finalRecipientPredicate, null);
       logger.debug("InstantSplit", "Final recipient state created");
       let nametagTokens = [];
       const recipientAddressStr = bundle.recipientAddressJson;
@@ -9125,8 +9067,8 @@ var InstantSplitProcessor = class {
       await this.waitInclusionProofWithDevBypass(burnCommitment, options?.proofTimeoutMs);
       logger.debug("InstantSplit", "V4: Burn proof received");
       const mintDataJson = JSON.parse(bundle.recipientMintData);
-      const mintData = await import_MintTransactionData2.MintTransactionData.fromJSON(mintDataJson);
-      const mintCommitment = await import_MintCommitment2.MintCommitment.create(mintData);
+      const mintData = await import_MintTransactionData.MintTransactionData.fromJSON(mintDataJson);
+      const mintCommitment = await import_MintCommitment.MintCommitment.create(mintData);
       const mintResponse = await this.client.submitMintCommitment(mintCommitment);
       if (mintResponse.status !== "SUCCESS" && mintResponse.status !== "REQUEST_ID_EXISTS") {
         throw new SphereError(`Mint submission failed: ${mintResponse.status}`, "TRANSFER_FAILED");
@@ -9139,14 +9081,14 @@ var InstantSplitProcessor = class {
       logger.debug("InstantSplit", "V4: Mint proof received");
       const tokenType = new import_TokenType2.TokenType(fromHex3(bundle.tokenTypeHex));
       const recipientSalt = fromHex3(bundle.recipientSaltHex);
-      const recipientPredicate = await import_UnmaskedPredicate4.UnmaskedPredicate.create(
+      const recipientPredicate = await import_UnmaskedPredicate3.UnmaskedPredicate.create(
         mintData.tokenId,
         tokenType,
         signingService,
         import_HashAlgorithm4.HashAlgorithm.SHA256,
         recipientSalt
       );
-      const recipientState = new import_TokenState4.TokenState(recipientPredicate, null);
+      const recipientState = new import_TokenState3.TokenState(recipientPredicate, null);
       const tokenJson = {
         version: "2.0",
         state: recipientState.toJSON(),
@@ -9169,14 +9111,14 @@ var InstantSplitProcessor = class {
       const transferTransaction = transferCommitment.toTransaction(transferProof);
       logger.debug("InstantSplit", "V4: Transfer proof received");
       const transferSalt = fromHex3(bundle.transferSaltHex);
-      const finalPredicate = await import_UnmaskedPredicate4.UnmaskedPredicate.create(
+      const finalPredicate = await import_UnmaskedPredicate3.UnmaskedPredicate.create(
         mintData.tokenId,
         tokenType,
         signingService,
         import_HashAlgorithm4.HashAlgorithm.SHA256,
         transferSalt
       );
-      const finalState = new import_TokenState4.TokenState(finalPredicate, null);
+      const finalState = new import_TokenState3.TokenState(finalPredicate, null);
       const finalTokenJson = mintedToken.toJSON();
       finalTokenJson.state = finalState.toJSON();
       finalTokenJson.transactions = [transferTransaction.toJSON()];
@@ -9227,17 +9169,17 @@ var InstantSplitProcessor = class {
 var import_Token6 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
 var import_CoinId4 = require("@unicitylabs/state-transition-sdk/lib/token/fungible/CoinId");
 var import_TransferCommitment4 = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferCommitment");
-var import_TransferTransaction2 = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferTransaction");
-var import_SigningService = require("@unicitylabs/state-transition-sdk/lib/sign/SigningService");
+var import_TransferTransaction3 = require("@unicitylabs/state-transition-sdk/lib/transaction/TransferTransaction");
+var import_SigningService2 = require("@unicitylabs/state-transition-sdk/lib/sign/SigningService");
 var import_AddressScheme = require("@unicitylabs/state-transition-sdk/lib/address/AddressScheme");
-var import_UnmaskedPredicate5 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
-var import_TokenState5 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
+var import_UnmaskedPredicate4 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
+var import_TokenState4 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
 var import_HashAlgorithm5 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
 var import_TokenType3 = require("@unicitylabs/state-transition-sdk/lib/token/TokenType");
-var import_MintCommitment3 = require("@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment");
-var import_MintTransactionData3 = require("@unicitylabs/state-transition-sdk/lib/transaction/MintTransactionData");
+var import_MintCommitment2 = require("@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment");
+var import_MintTransactionData2 = require("@unicitylabs/state-transition-sdk/lib/transaction/MintTransactionData");
 var import_InclusionProofUtils5 = require("@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils");
-var import_InclusionProof = require("@unicitylabs/state-transition-sdk/lib/transaction/InclusionProof");
+var import_InclusionProof2 = require("@unicitylabs/state-transition-sdk/lib/transaction/InclusionProof");
 function computeHistoryDedupKey(type, tokenId, transferId) {
   if (type === "SENT" && transferId) return `${type}_transfer_${transferId}`;
   if (tokenId) return `${type}_${tokenId}`;
@@ -9258,7 +9200,7 @@ function enrichWithRegistry(info) {
   }
   return info;
 }
-async function parseTokenInfo(tokenData) {
+async function parseTokenInfo(tokenData, engine) {
   const defaultInfo = {
     coinId: "ALPHA",
     symbol: "ALPHA",
@@ -9266,6 +9208,25 @@ async function parseTokenInfo(tokenData) {
     decimals: 0,
     amount: "0"
   };
+  if (engine && typeof tokenData === "string" && looksLikeTokenBlob(tokenData)) {
+    try {
+      const token = await engine.decodeToken(decodeTokenBlob(hexToBytes2(tokenData)));
+      const first = engine.readValue(token)?.assets[0];
+      if (first) {
+        return enrichWithRegistry({
+          coinId: first.coinId,
+          symbol: first.coinId.slice(0, 8),
+          name: `Token ${first.coinId.slice(0, 8)}`,
+          decimals: 0,
+          amount: String(first.amount),
+          tokenId: engine.tokenId(token)
+        });
+      }
+      return { ...defaultInfo, tokenId: engine.tokenId(token) };
+    } catch (error) {
+      logger.warn("Payments", "Failed to parse token info via engine:", error);
+    }
+  }
   try {
     const data = typeof tokenData === "string" ? JSON.parse(tokenData) : tokenData;
     try {
@@ -9404,27 +9365,41 @@ async function parseTokenInfo(tokenData) {
 }
 var sdkDataCache = /* @__PURE__ */ new Map();
 var SDK_DATA_CACHE_MAX = 2e3;
+function looksLikeTokenBlob(sdkData) {
+  return sdkData.length >= 2 && sdkData.length % 2 === 0 && sdkData[0] !== "{" && /^[0-9a-f]+$/i.test(sdkData);
+}
+function tryParseBlobKeys(sdkData) {
+  try {
+    const blob = decodeTokenBlob(hexToBytes2(sdkData));
+    return { tokenId: blob.tokenId, stateHash: sha2562(bytesToHex3(blob.token), "hex") };
+  } catch {
+    return null;
+  }
+}
 function parseSdkDataCached(sdkData) {
   const cached = sdkDataCache.get(sdkData);
   if (cached) return cached;
-  let tokenId = null;
-  let stateHash = "";
-  try {
-    const txf = JSON.parse(sdkData);
-    tokenId = txf.genesis?.data?.tokenId || null;
-    stateHash = getCurrentStateHash(txf) || "";
-    if (!stateHash) {
-      if (txf.state?.hash) {
-        stateHash = txf.state.hash;
-      } else if (txf.stateHash) {
-        stateHash = txf.stateHash;
-      } else if (txf.currentStateHash) {
-        stateHash = txf.currentStateHash;
+  let entry = looksLikeTokenBlob(sdkData) ? tryParseBlobKeys(sdkData) : null;
+  if (!entry) {
+    let tokenId = null;
+    let stateHash = "";
+    try {
+      const txf = JSON.parse(sdkData);
+      tokenId = txf.genesis?.data?.tokenId || null;
+      stateHash = getCurrentStateHash(txf) || "";
+      if (!stateHash) {
+        if (txf.state?.hash) {
+          stateHash = txf.state.hash;
+        } else if (txf.stateHash) {
+          stateHash = txf.stateHash;
+        } else if (txf.currentStateHash) {
+          stateHash = txf.currentStateHash;
+        }
       }
+    } catch {
     }
-  } catch {
+    entry = { tokenId, stateHash };
   }
-  const entry = { tokenId, stateHash };
   if (sdkDataCache.size >= SDK_DATA_CACHE_MAX) {
     sdkDataCache.clear();
   }
@@ -9701,6 +9676,7 @@ var PaymentsModule = class _PaymentsModule {
     );
     this.deps = deps;
     this.priceProvider = deps.price ?? null;
+    this.spendPlanner.setEngine(deps.tokenEngine);
     if (this.l1) {
       this.l1.initialize({
         identity: deps.identity,
@@ -9925,7 +9901,59 @@ var PaymentsModule = class _PaymentsModule {
         request.invoiceRefundAddress,
         request.invoiceContact
       );
-      if (transferMode === "conservative") {
+      if (this.deps?.tokenEngine && peerInfo?.chainPubkey) {
+        const engine = this.deps.tokenEngine;
+        const recipientChainPubkey = hexToBytes2(peerInfo.chainPubkey);
+        const memoData = onChainMessage ?? void 0;
+        const handToRecipient = async (finished) => {
+          const tokenBlob = bytesToHex3(encodeTokenBlob(engine.encodeToken(finished)));
+          await this.deps.transport.sendTokenTransfer(recipientPubkey, {
+            type: "V2_TRANSFER",
+            version: "2.0",
+            tokenBlob,
+            memo: request.memo
+          });
+        };
+        for (const tw of splitPlan.tokensToTransferDirectly) {
+          const finished = await engine.transfer({
+            token: tw.sdkToken,
+            recipientPubkey: recipientChainPubkey,
+            data: memoData
+          });
+          await handToRecipient(finished);
+          result.tokenTransfers.push({ sourceTokenId: tw.uiToken.id, method: "direct" });
+          await this.removeToken(tw.uiToken.id, result.id);
+        }
+        if (splitPlan.requiresSplit && splitPlan.tokenToSplit) {
+          const selfChainPubkey = hexToBytes2(this.deps.identity.chainPubkey);
+          const { outputs } = await engine.split({
+            token: splitPlan.tokenToSplit.sdkToken,
+            outputs: [
+              { recipientPubkey: recipientChainPubkey, coinId: request.coinId, amount: splitPlan.splitAmount, data: memoData },
+              { recipientPubkey: selfChainPubkey, coinId: request.coinId, amount: splitPlan.remainderAmount }
+            ]
+          });
+          await handToRecipient(outputs[0]);
+          const changeToken = outputs[1];
+          const changeBlob = bytesToHex3(encodeTokenBlob(engine.encodeToken(changeToken)));
+          const changeInfo = await parseTokenInfo(changeBlob, engine);
+          const registry = TokenRegistry.getInstance();
+          await this.addToken({
+            id: `v2_${engine.tokenId(changeToken)}`,
+            coinId: changeInfo.coinId,
+            symbol: registry.getSymbol(changeInfo.coinId) || changeInfo.symbol,
+            name: registry.getName(changeInfo.coinId) || changeInfo.name,
+            decimals: registry.getDecimals(changeInfo.coinId) ?? changeInfo.decimals,
+            amount: changeInfo.amount,
+            status: "confirmed",
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            sdkData: changeBlob
+          });
+          result.tokenTransfers.push({ sourceTokenId: splitPlan.tokenToSplit.uiToken.id, method: "split" });
+          await this.removeToken(splitPlan.tokenToSplit.uiToken.id, result.id);
+        }
+      } else if (transferMode === "conservative") {
         if (splitPlan.requiresSplit && splitPlan.tokenToSplit) {
           logger.debug("Payments", "Executing conservative split...");
           const splitExecutor = new TokenSplitExecutor({
@@ -10521,7 +10549,7 @@ var PaymentsModule = class _PaymentsModule {
    *   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 tokenInfo = await parseTokenInfo(sourceTokenInput, this.deps?.tokenEngine);
     const sdkData = typeof sourceTokenInput === "string" ? sourceTokenInput : JSON.stringify(sourceTokenInput);
     const nostrTokenId = extractTokenIdFromSdkData(sdkData);
     const nostrStateHash = extractStateHashFromSdkData(sdkData);
@@ -11613,8 +11641,8 @@ var PaymentsModule = class _PaymentsModule {
       if (pending2.stage === "RECEIVED") {
         logger.debug("Payments", `[V5-RESOLVE] ${tokenId.slice(0, 12)}: RECEIVED \u2192 submitting mint commitment...`);
         const mintDataJson = JSON.parse(bundle.recipientMintData);
-        const mintData = await import_MintTransactionData3.MintTransactionData.fromJSON(mintDataJson);
-        const mintCommitment = await import_MintCommitment3.MintCommitment.create(mintData);
+        const mintData = await import_MintTransactionData2.MintTransactionData.fromJSON(mintDataJson);
+        const mintCommitment = await import_MintCommitment2.MintCommitment.create(mintData);
         const mintResponse = await stClient.submitMintCommitment(mintCommitment);
         logger.debug("Payments", `[V5-RESOLVE] ${tokenId.slice(0, 12)}: mint response status=${mintResponse.status}`);
         if (mintResponse.status !== "SUCCESS" && mintResponse.status !== "REQUEST_ID_EXISTS") {
@@ -11626,8 +11654,8 @@ var PaymentsModule = class _PaymentsModule {
       if (pending2.stage === "MINT_SUBMITTED") {
         logger.debug("Payments", `[V5-RESOLVE] ${tokenId.slice(0, 12)}: MINT_SUBMITTED \u2192 checking mint proof...`);
         const mintDataJson = JSON.parse(bundle.recipientMintData);
-        const mintData = await import_MintTransactionData3.MintTransactionData.fromJSON(mintDataJson);
-        const mintCommitment = await import_MintCommitment3.MintCommitment.create(mintData);
+        const mintData = await import_MintTransactionData2.MintTransactionData.fromJSON(mintDataJson);
+        const mintCommitment = await import_MintCommitment2.MintCommitment.create(mintData);
         const proof = await this.quickProofCheck(stClient, trustBase, mintCommitment);
         if (!proof) {
           logger.debug("Payments", `[V5-RESOLVE] ${tokenId.slice(0, 12)}: mint proof not yet available, staying MINT_SUBMITTED`);
@@ -11724,10 +11752,10 @@ var PaymentsModule = class _PaymentsModule {
    */
   async finalizeFromV5Bundle(bundle, pending2, signingService, stClient, trustBase) {
     const mintDataJson = JSON.parse(bundle.recipientMintData);
-    const mintData = await import_MintTransactionData3.MintTransactionData.fromJSON(mintDataJson);
-    const mintCommitment = await import_MintCommitment3.MintCommitment.create(mintData);
+    const mintData = await import_MintTransactionData2.MintTransactionData.fromJSON(mintDataJson);
+    const mintCommitment = await import_MintCommitment2.MintCommitment.create(mintData);
     const mintProofJson = JSON.parse(pending2.mintProofJson);
-    const mintProof = import_InclusionProof.InclusionProof.fromJSON(mintProofJson);
+    const mintProof = import_InclusionProof2.InclusionProof.fromJSON(mintProofJson);
     const mintTransaction = mintCommitment.toTransaction(mintProof);
     const tokenType = new import_TokenType3.TokenType(fromHex4(bundle.tokenTypeHex));
     const senderMintedStateJson = JSON.parse(bundle.mintedTokenStateJson);
@@ -11744,14 +11772,14 @@ var PaymentsModule = class _PaymentsModule {
     const transferProof = await (0, import_InclusionProofUtils5.waitInclusionProof)(trustBase, stClient, transferCommitment);
     const transferTransaction = transferCommitment.toTransaction(transferProof);
     const transferSalt = fromHex4(bundle.transferSaltHex);
-    const recipientPredicate = await import_UnmaskedPredicate5.UnmaskedPredicate.create(
+    const recipientPredicate = await import_UnmaskedPredicate4.UnmaskedPredicate.create(
       mintData.tokenId,
       tokenType,
       signingService,
       import_HashAlgorithm5.HashAlgorithm.SHA256,
       transferSalt
     );
-    const recipientState = new import_TokenState5.TokenState(recipientPredicate, null);
+    const recipientState = new import_TokenState4.TokenState(recipientPredicate, null);
     let nametagTokens = [];
     const recipientAddressStr = bundle.recipientAddressJson;
     if (recipientAddressStr.startsWith("PROXY://")) {
@@ -12488,68 +12516,6 @@ var PaymentsModule = class _PaymentsModule {
       }
     }
   }
-  /**
-   * Mint a nametag token on-chain (like Sphere wallet and lottery)
-   * This creates the nametag token required for receiving tokens via PROXY addresses
-   *
-   * @param nametag - The nametag to mint (e.g., "alice" or "@alice")
-   * @returns MintNametagResult with success status and token if successful
-   */
-  async mintNametag(nametag) {
-    this.ensureInitialized();
-    const stClient = this.deps.oracle.getStateTransitionClient?.();
-    if (!stClient) {
-      return {
-        success: false,
-        error: "State transition client not available. Oracle provider must implement getStateTransitionClient()"
-      };
-    }
-    const trustBase = this.deps.oracle.getTrustBase?.();
-    if (!trustBase) {
-      return {
-        success: false,
-        error: "Trust base not available. Oracle provider must implement getTrustBase()"
-      };
-    }
-    try {
-      const signingService = await this.createSigningService();
-      const { UnmaskedPredicateReference: UnmaskedPredicateReference4 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
-      const { TokenType: TokenType6 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenType");
-      const UNICITY_TOKEN_TYPE_HEX3 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
-      const tokenType = new TokenType6(Buffer.from(UNICITY_TOKEN_TYPE_HEX3, "hex"));
-      const addressRef = await UnmaskedPredicateReference4.create(
-        tokenType,
-        signingService.algorithm,
-        signingService.publicKey,
-        import_HashAlgorithm5.HashAlgorithm.SHA256
-      );
-      const ownerAddress = await addressRef.toAddress();
-      const minter = new NametagMinter({
-        stateTransitionClient: stClient,
-        trustBase,
-        signingService,
-        debug: this.moduleConfig.debug
-      });
-      const result = await minter.mintNametag(nametag, ownerAddress);
-      if (result.success && result.nametagData) {
-        await this.setNametag(result.nametagData);
-        logger.debug("Payments", `Unicity ID minted and saved: ${result.nametagData.name}`);
-        this.deps.emitEvent("nametag:registered", {
-          nametag: result.nametagData.name,
-          addressIndex: 0
-          // Primary address
-        });
-      }
-      return result;
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      logger.debug("Payments", "mintNametag failed:", errorMsg);
-      return {
-        success: false,
-        error: errorMsg
-      };
-    }
-  }
   /**
    * Mint a fungible token directly to this wallet (genesis mint).
    *
@@ -12590,18 +12556,18 @@ var PaymentsModule = class _PaymentsModule {
     }
     try {
       const signingService = await this.createSigningService();
-      const { TokenId: TokenId5 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenId");
+      const { TokenId: TokenId4 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenId");
       const { TokenCoinData: TokenCoinData3 } = await import("@unicitylabs/state-transition-sdk/lib/token/fungible/TokenCoinData");
-      const { UnmaskedPredicateReference: UnmaskedPredicateReference4 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
+      const { UnmaskedPredicateReference: UnmaskedPredicateReference3 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
       const tokenTypeBytes = fromHex4("f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509");
       const tokenType = new import_TokenType3.TokenType(tokenTypeBytes);
       const tokenIdBytes = new Uint8Array(32);
       crypto.getRandomValues(tokenIdBytes);
-      const tokenId = new TokenId5(tokenIdBytes);
+      const tokenId = new TokenId4(tokenIdBytes);
       const coinIdBytes = fromHex4(coinIdHex);
       const coinId = new import_CoinId4.CoinId(coinIdBytes);
       const coinData = TokenCoinData3.create([[coinId, amount]]);
-      const addressRef = await UnmaskedPredicateReference4.create(
+      const addressRef = await UnmaskedPredicateReference3.create(
         tokenType,
         signingService.algorithm,
         signingService.publicKey,
@@ -12610,7 +12576,7 @@ var PaymentsModule = class _PaymentsModule {
       const ownerAddress = await addressRef.toAddress();
       const salt = new Uint8Array(32);
       crypto.getRandomValues(salt);
-      const mintData = await import_MintTransactionData3.MintTransactionData.create(
+      const mintData = await import_MintTransactionData2.MintTransactionData.create(
         tokenId,
         tokenType,
         null,
@@ -12625,7 +12591,7 @@ var PaymentsModule = class _PaymentsModule {
         null
         // reason: null (genesis, no burn predecessor)
       );
-      const commitment = await import_MintCommitment3.MintCommitment.create(mintData);
+      const commitment = await import_MintCommitment2.MintCommitment.create(mintData);
       const MAX_RETRIES = 3;
       let lastStatus;
       for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
@@ -12642,14 +12608,14 @@ var PaymentsModule = class _PaymentsModule {
       }
       const inclusionProof = await (0, import_InclusionProofUtils5.waitInclusionProof)(trustBase, stClient, commitment);
       const genesisTransaction = commitment.toTransaction(inclusionProof);
-      const predicate = await import_UnmaskedPredicate5.UnmaskedPredicate.create(
+      const predicate = await import_UnmaskedPredicate4.UnmaskedPredicate.create(
         tokenId,
         tokenType,
         signingService,
         import_HashAlgorithm5.HashAlgorithm.SHA256,
         salt
       );
-      const tokenState = new import_TokenState5.TokenState(predicate, null);
+      const tokenState = new import_TokenState4.TokenState(predicate, null);
       const sdkToken = await import_Token6.Token.mint(trustBase, tokenState, genesisTransaction);
       const tokenIdHex = tokenId.toJSON();
       const symbol = this.getCoinSymbol(coinIdHex);
@@ -12676,29 +12642,6 @@ var PaymentsModule = class _PaymentsModule {
       return { success: false, error: `Local mint failed: ${msg}` };
     }
   }
-  /**
-   * Check if a nametag is available for minting
-   * @param nametag - The nametag to check (e.g., "alice" or "@alice")
-   */
-  async isNametagAvailable(nametag) {
-    this.ensureInitialized();
-    const stClient = this.deps.oracle.getStateTransitionClient?.();
-    const trustBase = this.deps.oracle.getTrustBase?.();
-    if (!stClient || !trustBase) {
-      return false;
-    }
-    try {
-      const signingService = await this.createSigningService();
-      const minter = new NametagMinter({
-        stateTransitionClient: stClient,
-        trustBase,
-        signingService
-      });
-      return await minter.isNametagAvailable(nametag);
-    } catch {
-      return false;
-    }
-  }
   // ===========================================================================
   // Public API - Sync & Validate
   // ===========================================================================
@@ -13014,7 +12957,7 @@ var PaymentsModule = class _PaymentsModule {
     const privateKeyBytes = new Uint8Array(
       privateKeyHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
     );
-    return import_SigningService.SigningService.createFromSecret(privateKeyBytes);
+    return import_SigningService2.SigningService.createFromSecret(privateKeyBytes);
   }
   /**
    * Get the wallet's signing public key (used for token ownership predicates).
@@ -13029,14 +12972,14 @@ var PaymentsModule = class _PaymentsModule {
    * Create DirectAddress from a public key using UnmaskedPredicateReference
    */
   async createDirectAddressFromPubkey(pubkeyHex) {
-    const { UnmaskedPredicateReference: UnmaskedPredicateReference4 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
-    const { TokenType: TokenType6 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenType");
-    const UNICITY_TOKEN_TYPE_HEX3 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
-    const tokenType = new TokenType6(Buffer.from(UNICITY_TOKEN_TYPE_HEX3, "hex"));
+    const { UnmaskedPredicateReference: UnmaskedPredicateReference3 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
+    const { TokenType: TokenType4 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenType");
+    const UNICITY_TOKEN_TYPE_HEX2 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
+    const tokenType = new TokenType4(Buffer.from(UNICITY_TOKEN_TYPE_HEX2, "hex"));
     const pubkeyBytes = new Uint8Array(
       pubkeyHex.match(/.{1,2}/g).map((byte) => parseInt(byte, 16))
     );
-    const addressRef = await UnmaskedPredicateReference4.create(
+    const addressRef = await UnmaskedPredicateReference3.create(
       tokenType,
       "secp256k1",
       pubkeyBytes,
@@ -13048,10 +12991,9 @@ var PaymentsModule = class _PaymentsModule {
    * Resolve recipient to IAddress for L3 transfers.
    * Uses pre-resolved PeerInfo when available to avoid redundant network queries.
    */
-  async resolveRecipientAddress(recipient, addressMode = "auto", peerInfo) {
+  async resolveRecipientAddress(recipient, _addressMode = "auto", peerInfo) {
     const { AddressFactory } = await import("@unicitylabs/state-transition-sdk/lib/address/AddressFactory");
-    const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
-    if (recipient.startsWith("PROXY:") || recipient.startsWith("DIRECT:")) {
+    if (recipient.startsWith("DIRECT:")) {
       return AddressFactory.createAddress(recipient);
     }
     if (recipient.length === 66 && /^[0-9a-fA-F]+$/.test(recipient)) {
@@ -13061,28 +13003,19 @@ var PaymentsModule = class _PaymentsModule {
     const info = peerInfo ?? await this.deps?.transport.resolve?.(recipient) ?? null;
     if (!info) {
       throw new SphereError(
-        `Recipient "${recipient}" not found. Use @nametag, a valid PROXY:/DIRECT: address, or a 33-byte hex pubkey.`,
+        `Recipient "${recipient}" not found. Use @nametag, a DIRECT: address, or a 33-byte hex pubkey.`,
         "INVALID_RECIPIENT"
       );
     }
     const nametag = recipient.startsWith("@") ? recipient.slice(1) : info.nametag || recipient;
-    if (addressMode === "proxy") {
-      logger.debug("Payments", `Using PROXY address for "${nametag}" (forced)`);
-      return ProxyAddress.fromNameTag(nametag);
-    }
-    if (addressMode === "direct") {
-      if (!info.directAddress) {
-        throw new SphereError(`"${nametag}" has no DirectAddress stored. It may be a legacy registration.`, "INVALID_RECIPIENT");
-      }
-      logger.debug("Payments", `Using DirectAddress for "${nametag}" (forced): ${info.directAddress.slice(0, 30)}...`);
-      return AddressFactory.createAddress(info.directAddress);
-    }
-    if (info.directAddress) {
-      logger.debug("Payments", `Using DirectAddress for "${nametag}": ${info.directAddress.slice(0, 30)}...`);
-      return AddressFactory.createAddress(info.directAddress);
+    if (!info.directAddress) {
+      throw new SphereError(
+        `"${nametag}" has no DirectAddress \u2014 the recipient must publish a key-based identity binding.`,
+        "INVALID_RECIPIENT"
+      );
     }
-    logger.debug("Payments", `Using PROXY address for legacy nametag "${nametag}"`);
-    return ProxyAddress.fromNameTag(nametag);
+    logger.debug("Payments", `Using DirectAddress for "${nametag}": ${info.directAddress.slice(0, 30)}...`);
+    return AddressFactory.createAddress(info.directAddress);
   }
   /**
    * Handle NOSTR-FIRST commitment-only transfer (recipient side)
@@ -13137,14 +13070,14 @@ var PaymentsModule = class _PaymentsModule {
     const addressScheme = recipientAddress.scheme;
     const signingService = await this.createSigningService();
     const transferSalt = transferTx.data.salt;
-    const recipientPredicate = await import_UnmaskedPredicate5.UnmaskedPredicate.create(
+    const recipientPredicate = await import_UnmaskedPredicate4.UnmaskedPredicate.create(
       sourceToken.id,
       sourceToken.type,
       signingService,
       import_HashAlgorithm5.HashAlgorithm.SHA256,
       transferSalt
     );
-    const recipientState = new import_TokenState5.TokenState(recipientPredicate, null);
+    const recipientState = new import_TokenState4.TokenState(recipientPredicate, null);
     let nametagTokens = [];
     if (addressScheme === import_AddressScheme.AddressScheme.PROXY) {
       const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
@@ -13241,6 +13174,67 @@ var PaymentsModule = class _PaymentsModule {
       }
     }
   }
+  /**
+   * v2 engine transfer (sender-driven): the sender handed us a FINISHED token.
+   * Decode the blob, dedup by the genesis-stable token id, store it as a
+   * confirmed token, and emit/record the receipt. No commitment / inclusion-proof
+   * / finalization round-trip (contrast the v1 sourceToken+transferTx path).
+   */
+  async handleV2Transfer(payload, senderPubkey) {
+    this.ensureInitialized();
+    if (!this.loaded && this.loadedPromise) {
+      await this.loadedPromise;
+    }
+    const engine = this.deps.tokenEngine;
+    if (!engine) return;
+    let token;
+    try {
+      token = await engine.decodeToken(decodeTokenBlob(hexToBytes2(payload.tokenBlob)));
+    } catch (err) {
+      logger.error("Payments", "V2 transfer: failed to decode token blob:", err);
+      return;
+    }
+    const id = `v2_${engine.tokenId(token)}`;
+    if (this.tokens.has(id)) {
+      logger.debug("Payments", `V2 transfer ${id.slice(0, 16)}... already present, skipping`);
+      return;
+    }
+    const info = await parseTokenInfo(payload.tokenBlob, engine);
+    const registry = TokenRegistry.getInstance();
+    const uiToken = {
+      id,
+      coinId: info.coinId,
+      symbol: registry.getSymbol(info.coinId) || info.symbol,
+      name: registry.getName(info.coinId) || info.name,
+      decimals: registry.getDecimals(info.coinId) ?? info.decimals,
+      amount: info.amount,
+      status: "confirmed",
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      sdkData: payload.tokenBlob
+    };
+    await this.addToken(uiToken);
+    const senderInfo = await this.resolveSenderInfo(senderPubkey);
+    this.deps.emitEvent("transfer:incoming", {
+      id,
+      senderPubkey,
+      senderNametag: senderInfo.senderNametag,
+      tokens: [uiToken],
+      memo: payload.memo,
+      receivedAt: Date.now()
+    });
+    await this.addToHistory({
+      type: "RECEIVED",
+      amount: info.amount,
+      coinId: info.coinId,
+      symbol: uiToken.symbol,
+      timestamp: Date.now(),
+      senderPubkey,
+      ...senderInfo,
+      memo: payload.memo,
+      tokenId: id
+    });
+  }
   async handleIncomingTransfer(transfer) {
     if (!this.loaded && this.loadedPromise) {
       await this.loadedPromise;
@@ -13248,6 +13242,10 @@ var PaymentsModule = class _PaymentsModule {
     try {
       const payload = transfer.payload;
       logger.debug("Payments", "handleIncomingTransfer: keys=", Object.keys(payload).join(","));
+      if (this.deps.tokenEngine && isV2TransferPayload(transfer.payload)) {
+        await this.handleV2Transfer(transfer.payload, transfer.senderTransportPubkey);
+        return;
+      }
       let combinedBundle = null;
       if (isCombinedTransferBundleV6(payload)) {
         combinedBundle = payload;
@@ -13329,7 +13327,7 @@ var PaymentsModule = class _PaymentsModule {
           const hasTransactionData = transferTxInput.transactionData !== void 0;
           const hasAuthenticator = transferTxInput.authenticator !== void 0;
           if (hasData && hasInclusionProof) {
-            transferTx = await import_TransferTransaction2.TransferTransaction.fromJSON(transferTxInput);
+            transferTx = await import_TransferTransaction3.TransferTransaction.fromJSON(transferTxInput);
           } else if (hasTransactionData && hasAuthenticator) {
             const commitment = await import_TransferCommitment4.TransferCommitment.fromJSON(transferTxInput);
             const stClient = this.deps.oracle.getStateTransitionClient?.();
@@ -13350,7 +13348,7 @@ var PaymentsModule = class _PaymentsModule {
             transferTx = commitment.toTransaction(inclusionProof);
           } else {
             try {
-              transferTx = await import_TransferTransaction2.TransferTransaction.fromJSON(transferTxInput);
+              transferTx = await import_TransferTransaction3.TransferTransaction.fromJSON(transferTxInput);
             } catch {
               const commitment = await import_TransferCommitment4.TransferCommitment.fromJSON(transferTxInput);
               const stClient = this.deps.oracle.getStateTransitionClient?.();
@@ -13392,7 +13390,7 @@ var PaymentsModule = class _PaymentsModule {
         logger.warn("Payments", "Received invalid token");
         return;
       }
-      const tokenInfo = await parseTokenInfo(tokenData);
+      const tokenInfo = await parseTokenInfo(tokenData, this.deps?.tokenEngine);
       const token = {
         id: tokenInfo.tokenId ?? crypto.randomUUID(),
         coinId: tokenInfo.coinId,
@@ -13698,25 +13696,7 @@ function createPaymentsModule(config) {
   return new PaymentsModule(config);
 }
 
-// modules/payments/TokenSplitCalculator.ts
-init_logger();
-var import_Token7 = require("@unicitylabs/state-transition-sdk/lib/token/Token");
-var import_CoinId5 = require("@unicitylabs/state-transition-sdk/lib/token/fungible/CoinId");
-
-// modules/payments/BackgroundCommitmentService.ts
-init_logger();
-init_errors();
-
-// modules/payments/TokenRecoveryService.ts
-init_logger();
-var import_TokenId4 = require("@unicitylabs/state-transition-sdk/lib/token/TokenId");
-var import_TokenState6 = require("@unicitylabs/state-transition-sdk/lib/token/TokenState");
-var import_TokenType4 = require("@unicitylabs/state-transition-sdk/lib/token/TokenType");
-var import_CoinId6 = require("@unicitylabs/state-transition-sdk/lib/token/fungible/CoinId");
-var import_HashAlgorithm6 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
-var import_UnmaskedPredicate6 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate");
-
-// modules/communications/CommunicationsModule.ts
+// modules/communications/CommunicationsModule.ts
 init_logger();
 init_errors();
 
@@ -14397,7 +14377,7 @@ function createCommunicationsModule(config) {
 }
 
 // modules/groupchat/GroupChatModule.ts
-var import_nostr_js_sdk4 = require("@unicitylabs/nostr-js-sdk");
+var import_nostr_js_sdk3 = require("@unicitylabs/nostr-js-sdk");
 init_logger();
 init_errors();
 init_constants();
@@ -14415,7 +14395,7 @@ var GroupVisibility = {
 
 // modules/groupchat/GroupChatModule.ts
 function createNip29Filter(data) {
-  return new import_nostr_js_sdk4.Filter(data);
+  return new import_nostr_js_sdk3.Filter(data);
 }
 var GroupChatModule = class {
   config;
@@ -14464,7 +14444,7 @@ var GroupChatModule = class {
     }
     this.deps = deps;
     const secretKey = Buffer.from(deps.identity.privateKey, "hex");
-    this.keyManager = import_nostr_js_sdk4.NostrKeyManager.fromPrivateKey(secretKey);
+    this.keyManager = import_nostr_js_sdk3.NostrKeyManager.fromPrivateKey(secretKey);
   }
   async load() {
     this.ensureInitialized();
@@ -14605,7 +14585,7 @@ var GroupChatModule = class {
     }
     this.subscriptionIds = [];
     const secretKey = Buffer.from(this.deps.identity.privateKey, "hex");
-    this.keyManager = import_nostr_js_sdk4.NostrKeyManager.fromPrivateKey(secretKey);
+    this.keyManager = import_nostr_js_sdk3.NostrKeyManager.fromPrivateKey(secretKey);
     if (this.groups.size === 0) {
       await this.restoreJoinedGroups();
     } else {
@@ -14617,13 +14597,13 @@ var GroupChatModule = class {
     this.ensureInitialized();
     if (!this.keyManager) {
       const secretKey = Buffer.from(this.deps.identity.privateKey, "hex");
-      this.keyManager = import_nostr_js_sdk4.NostrKeyManager.fromPrivateKey(secretKey);
+      this.keyManager = import_nostr_js_sdk3.NostrKeyManager.fromPrivateKey(secretKey);
     }
     const primaryRelay = this.config.relays[0];
     if (primaryRelay) {
       await this.checkAndClearOnRelayChange(primaryRelay);
     }
-    this.client = new import_nostr_js_sdk4.NostrClient(this.keyManager);
+    this.client = new import_nostr_js_sdk3.NostrClient(this.keyManager);
     try {
       await this.client.connect(...this.config.relays);
       this.connected = true;
@@ -14910,7 +14890,7 @@ var GroupChatModule = class {
     if (!this.client) return [];
     const groupsMap = /* @__PURE__ */ new Map();
     await this.oneshotSubscription(
-      new import_nostr_js_sdk4.Filter({ kinds: [NIP29_KINDS.GROUP_METADATA] }),
+      new import_nostr_js_sdk3.Filter({ kinds: [NIP29_KINDS.GROUP_METADATA] }),
       {
         onEvent: (event) => {
           const group = this.parseGroupMetadata(event);
@@ -15410,7 +15390,7 @@ var GroupChatModule = class {
     if (!this.client) return /* @__PURE__ */ new Set();
     const adminPubkeys = /* @__PURE__ */ new Set();
     return this.oneshotSubscription(
-      new import_nostr_js_sdk4.Filter({ kinds: [NIP29_KINDS.GROUP_ADMINS], "#d": ["", "_"] }),
+      new import_nostr_js_sdk3.Filter({ kinds: [NIP29_KINDS.GROUP_ADMINS], "#d": ["", "_"] }),
       {
         onEvent: (event) => {
           const pTags = event.tags.filter((t) => t[0] === "p");
@@ -15432,7 +15412,7 @@ var GroupChatModule = class {
     if (!this.client) return null;
     let result = null;
     return this.oneshotSubscription(
-      new import_nostr_js_sdk4.Filter({ kinds: [NIP29_KINDS.GROUP_METADATA], "#d": [groupId] }),
+      new import_nostr_js_sdk3.Filter({ kinds: [NIP29_KINDS.GROUP_METADATA], "#d": [groupId] }),
       {
         onEvent: (event) => {
           if (!result) result = this.parseGroupMetadata(event);
@@ -15469,7 +15449,7 @@ var GroupChatModule = class {
     if (!this.client) return [];
     const members = [];
     return this.oneshotSubscription(
-      new import_nostr_js_sdk4.Filter({ kinds: [NIP29_KINDS.GROUP_MEMBERS], "#d": [groupId] }),
+      new import_nostr_js_sdk3.Filter({ kinds: [NIP29_KINDS.GROUP_MEMBERS], "#d": [groupId] }),
       {
         onEvent: (event) => {
           const pTags = event.tags.filter((t) => t[0] === "p");
@@ -15490,7 +15470,7 @@ var GroupChatModule = class {
     if (!this.client) return [];
     const adminPubkeys = [];
     return this.oneshotSubscription(
-      new import_nostr_js_sdk4.Filter({ kinds: [NIP29_KINDS.GROUP_ADMINS], "#d": [groupId] }),
+      new import_nostr_js_sdk3.Filter({ kinds: [NIP29_KINDS.GROUP_ADMINS], "#d": [groupId] }),
       {
         onEvent: (event) => {
           const pTags = event.tags.filter((t) => t[0] === "p");
@@ -17353,7 +17333,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
     const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : void 0;
     return abytes(bytes, sizer);
   }
-  class Signature {
+  class Signature2 {
     r;
     s;
     recovery;
@@ -17373,7 +17353,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
       let recid;
       if (format === "der") {
         const { r: r2, s: s2 } = DER.toSig(abytes(bytes));
-        return new Signature(r2, s2);
+        return new Signature2(r2, s2);
       }
       if (format === "recovered") {
         recid = bytes[0];
@@ -17383,7 +17363,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
       const L = lengths.signature / 2;
       const r = bytes.subarray(0, L);
       const s = bytes.subarray(L, L * 2);
-      return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);
+      return new Signature2(Fn.fromBytes(r), Fn.fromBytes(s), recid);
     }
     static fromHex(hex, format) {
       return this.fromBytes(hexToBytes(hex), format);
@@ -17395,7 +17375,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
       return recovery;
     }
     addRecoveryBit(recovery) {
-      return new Signature(this.r, this.s, recovery);
+      return new Signature2(this.r, this.s, recovery);
     }
     recoverPublicKey(messageHash) {
       const { r, s } = this;
@@ -17487,7 +17467,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
         normS = Fn.neg(s);
         recovery ^= 1;
       }
-      return new Signature(r, normS, hasLargeCofactor ? void 0 : recovery);
+      return new Signature2(r, normS, hasLargeCofactor ? void 0 : recovery);
     }
     return { seed, k2sig };
   }
@@ -17502,12 +17482,12 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
     publicKey = abytes(publicKey, void 0, "publicKey");
     message = validateMsgAndHash(message, prehash);
     if (!isBytes(signature)) {
-      const end = signature instanceof Signature ? ", use sig.toBytes()" : "";
+      const end = signature instanceof Signature2 ? ", use sig.toBytes()" : "";
       throw new Error("verify expects Uint8Array signature" + end);
     }
     validateSigLength(signature, format);
     try {
-      const sig = Signature.fromBytes(signature, format);
+      const sig = Signature2.fromBytes(signature, format);
       const P = Point.fromBytes(publicKey);
       if (lowS && sig.hasHighS())
         return false;
@@ -17528,7 +17508,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
   function recoverPublicKey(signature, message, opts = {}) {
     const { prehash } = validateSigOpts(opts, defaultSigOpts);
     message = validateMsgAndHash(message, prehash);
-    return Signature.fromBytes(signature, "recovered").recoverPublicKey(message).toBytes();
+    return Signature2.fromBytes(signature, "recovered").recoverPublicKey(message).toBytes();
   }
   return Object.freeze({
     keygen,
@@ -17540,7 +17520,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
     sign,
     verify,
     recoverPublicKey,
-    Signature,
+    Signature: Signature2,
     hash
   });
 }
@@ -18812,7 +18792,7 @@ function freezeCoinAsset(coinAsset, state, latestSender) {
 }
 
 // modules/accounting/AccountingModule.ts
-var import_Token8 = require("@unicitylabs/state-transition-sdk/lib/token/Token.js");
+var import_Token7 = require("@unicitylabs/state-transition-sdk/lib/token/Token.js");
 var LOG_TAG2 = "Accounting";
 var INV_LEDGER_PREFIX = "inv_ledger:";
 var AccountingModule = class _AccountingModule {
@@ -19465,129 +19445,146 @@ var AccountingModule = class _AccountingModule {
       );
     }
     try {
-      const { TokenId: TokenId5 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenId.js");
-      const { TokenType: TokenType6 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenType.js");
-      const { MintTransactionData: MintTransactionData4 } = await import("@unicitylabs/state-transition-sdk/lib/transaction/MintTransactionData.js");
-      const { MintCommitment: MintCommitment4 } = await import("@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment.js");
-      const { SigningService: SigningService3 } = await import("@unicitylabs/state-transition-sdk/lib/sign/SigningService.js");
-      const { HashAlgorithm: HashAlgorithm8 } = await import("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm.js");
-      const { DataHasher } = await import("@unicitylabs/state-transition-sdk/lib/hash/DataHasher.js");
-      const { UnmaskedPredicate: UnmaskedPredicate7 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate.js");
-      const { UnmaskedPredicateReference: UnmaskedPredicateReference4 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference.js");
-      const { TokenState: TokenState7 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenState.js");
-      const { Token: SdkToken5 } = await import("@unicitylabs/state-transition-sdk/lib/token/Token.js");
-      const { waitInclusionProof: waitInclusionProof6 } = await import("@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils.js");
-      const hash = await new DataHasher(HashAlgorithm8.SHA256).update(invoiceBytesEncoded).digest();
-      const invoiceTokenId = new TokenId5(hash.imprint);
-      const invoiceId = invoiceTokenId.toJSON();
-      if (this.invoiceTermsCache.has(invoiceId)) {
-        throw new SphereError(
-          `Invoice already exists locally: ${invoiceId}`,
-          "INVOICE_ALREADY_EXISTS"
+      let invoiceId;
+      let sdkData;
+      const engine = deps.tokenEngine;
+      if (engine) {
+        const invoiceToken = await engine.mintDataToken({
+          recipientPubkey: hexToBytes(deps.identity.chainPubkey),
+          data: invoiceBytesEncoded,
+          tokenType: hexToBytes(INVOICE_TOKEN_TYPE_HEX),
+          salt
+        });
+        invoiceId = engine.tokenId(invoiceToken);
+        if (this.invoiceTermsCache.has(invoiceId)) {
+          throw new SphereError(`Invoice already exists locally: ${invoiceId}`, "INVOICE_ALREADY_EXISTS");
+        }
+        sdkData = bytesToHex(encodeTokenBlob(engine.encodeToken(invoiceToken)));
+      } else {
+        const { TokenId: TokenId4 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenId.js");
+        const { TokenType: TokenType4 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenType.js");
+        const { MintTransactionData: MintTransactionData3 } = await import("@unicitylabs/state-transition-sdk/lib/transaction/MintTransactionData.js");
+        const { MintCommitment: MintCommitment3 } = await import("@unicitylabs/state-transition-sdk/lib/transaction/MintCommitment.js");
+        const { SigningService: SigningService3 } = await import("@unicitylabs/state-transition-sdk/lib/sign/SigningService.js");
+        const { HashAlgorithm: HashAlgorithm6 } = await import("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm.js");
+        const { DataHasher: DataHasher2 } = await import("@unicitylabs/state-transition-sdk/lib/hash/DataHasher.js");
+        const { UnmaskedPredicate: UnmaskedPredicate5 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicate.js");
+        const { UnmaskedPredicateReference: UnmaskedPredicateReference3 } = await import("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference.js");
+        const { TokenState: TokenState5 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenState.js");
+        const { Token: SdkToken4 } = await import("@unicitylabs/state-transition-sdk/lib/token/Token.js");
+        const { waitInclusionProof: waitInclusionProof6 } = await import("@unicitylabs/state-transition-sdk/lib/util/InclusionProofUtils.js");
+        const hash = await new DataHasher2(HashAlgorithm6.SHA256).update(invoiceBytesEncoded).digest();
+        const invoiceTokenId = new TokenId4(hash.imprint);
+        invoiceId = invoiceTokenId.toJSON();
+        if (this.invoiceTermsCache.has(invoiceId)) {
+          throw new SphereError(
+            `Invoice already exists locally: ${invoiceId}`,
+            "INVOICE_ALREADY_EXISTS"
+          );
+        }
+        const invoiceTokenType = new TokenType4(
+          Buffer.from(INVOICE_TOKEN_TYPE_HEX, "hex")
         );
-      }
-      const invoiceTokenType = new TokenType6(
-        Buffer.from(INVOICE_TOKEN_TYPE_HEX, "hex")
-      );
-      const signingService = await SigningService3.createFromSecret(signingKeyBytes);
-      const addressRef = await UnmaskedPredicateReference4.create(
-        invoiceTokenType,
-        signingService.algorithm,
-        signingService.publicKey,
-        HashAlgorithm8.SHA256
-      );
-      const ownerAddress = await addressRef.toAddress();
-      const mintData = await MintTransactionData4.create(
-        invoiceTokenId,
-        invoiceTokenType,
-        invoiceBytesEncoded,
-        // tokenData: serialized InvoiceTerms (UTF-8 JSON)
-        null,
-        // coinData: null (non-fungible invoice token)
-        ownerAddress,
-        salt,
-        null,
-        // recipientDataHash: null
-        null
-        // reason: null
-      );
-      if (this.config.debug) {
-        logger.debug(LOG_TAG2, `Created MintTransactionData for invoice ${invoiceId}`);
-      }
-      const commitment = await MintCommitment4.create(mintData);
-      if (this.config.debug) {
-        logger.debug(LOG_TAG2, "Created MintCommitment for invoice");
-      }
-      const MAX_RETRIES = 3;
-      let submitSuccess = false;
-      for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-        try {
-          if (this.config.debug) {
-            logger.debug(
-              LOG_TAG2,
-              `Submitting invoice commitment (attempt ${attempt}/${MAX_RETRIES})...`
-            );
-          }
-          const response = await stClient.submitMintCommitment(commitment);
-          if (response.status === "SUCCESS" || response.status === "REQUEST_ID_EXISTS") {
+        const signingService = await SigningService3.createFromSecret(signingKeyBytes);
+        const addressRef = await UnmaskedPredicateReference3.create(
+          invoiceTokenType,
+          signingService.algorithm,
+          signingService.publicKey,
+          HashAlgorithm6.SHA256
+        );
+        const ownerAddress = await addressRef.toAddress();
+        const mintData = await MintTransactionData3.create(
+          invoiceTokenId,
+          invoiceTokenType,
+          invoiceBytesEncoded,
+          // tokenData: serialized InvoiceTerms (UTF-8 JSON)
+          null,
+          // coinData: null (non-fungible invoice token)
+          ownerAddress,
+          salt,
+          null,
+          // recipientDataHash: null
+          null
+          // reason: null
+        );
+        if (this.config.debug) {
+          logger.debug(LOG_TAG2, `Created MintTransactionData for invoice ${invoiceId}`);
+        }
+        const commitment = await MintCommitment3.create(mintData);
+        if (this.config.debug) {
+          logger.debug(LOG_TAG2, "Created MintCommitment for invoice");
+        }
+        const MAX_RETRIES = 3;
+        let submitSuccess = false;
+        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+          try {
             if (this.config.debug) {
               logger.debug(
                 LOG_TAG2,
-                response.status === "REQUEST_ID_EXISTS" ? "Invoice commitment already exists (idempotent re-mint)" : "Invoice commitment submitted successfully"
+                `Submitting invoice commitment (attempt ${attempt}/${MAX_RETRIES})...`
               );
             }
-            submitSuccess = true;
-            break;
-          } else {
-            logger.warn(LOG_TAG2, `Invoice commitment submission failed: ${response.status}`);
+            const response = await stClient.submitMintCommitment(commitment);
+            if (response.status === "SUCCESS" || response.status === "REQUEST_ID_EXISTS") {
+              if (this.config.debug) {
+                logger.debug(
+                  LOG_TAG2,
+                  response.status === "REQUEST_ID_EXISTS" ? "Invoice commitment already exists (idempotent re-mint)" : "Invoice commitment submitted successfully"
+                );
+              }
+              submitSuccess = true;
+              break;
+            } else {
+              logger.warn(LOG_TAG2, `Invoice commitment submission failed: ${response.status}`);
+              if (attempt === MAX_RETRIES) {
+                throw new SphereError(
+                  `Failed to mint invoice token: commitment rejected after ${MAX_RETRIES} attempts: ${response.status}`,
+                  "INVOICE_MINT_FAILED"
+                );
+              }
+              await new Promise((r) => setTimeout(r, 1e3 * attempt));
+            }
+          } catch (retryErr) {
+            if (retryErr instanceof SphereError && (retryErr.code === "INVOICE_ORACLE_REQUIRED" || retryErr.code === "INVOICE_INVALID_PROOF" || retryErr.code === "INVOICE_MINT_FAILED" || retryErr.code === "NOT_INITIALIZED" || retryErr.code === "MODULE_DESTROYED")) throw retryErr;
+            logger.warn(LOG_TAG2, `Invoice commitment attempt ${attempt} error:`, retryErr);
             if (attempt === MAX_RETRIES) {
               throw new SphereError(
-                `Failed to mint invoice token: commitment rejected after ${MAX_RETRIES} attempts: ${response.status}`,
-                "INVOICE_MINT_FAILED"
+                `Failed to mint invoice token: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`,
+                "INVOICE_MINT_FAILED",
+                retryErr
               );
             }
             await new Promise((r) => setTimeout(r, 1e3 * attempt));
           }
-        } catch (retryErr) {
-          if (retryErr instanceof SphereError && (retryErr.code === "INVOICE_ORACLE_REQUIRED" || retryErr.code === "INVOICE_INVALID_PROOF" || retryErr.code === "INVOICE_MINT_FAILED" || retryErr.code === "NOT_INITIALIZED" || retryErr.code === "MODULE_DESTROYED")) throw retryErr;
-          logger.warn(LOG_TAG2, `Invoice commitment attempt ${attempt} error:`, retryErr);
-          if (attempt === MAX_RETRIES) {
-            throw new SphereError(
-              `Failed to mint invoice token: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`,
-              "INVOICE_MINT_FAILED",
-              retryErr
-            );
-          }
-          await new Promise((r) => setTimeout(r, 1e3 * attempt));
         }
-      }
-      if (!submitSuccess) {
-        throw new SphereError(
-          "Failed to mint invoice token: commitment submission failed after retries",
-          "INVOICE_MINT_FAILED"
+        if (!submitSuccess) {
+          throw new SphereError(
+            "Failed to mint invoice token: commitment submission failed after retries",
+            "INVOICE_MINT_FAILED"
+          );
+        }
+        if (this.config.debug) {
+          logger.debug(LOG_TAG2, "Waiting for invoice inclusion proof...");
+        }
+        const inclusionProof = await waitInclusionProof6(trustBase, stClient, commitment);
+        if (this.config.debug) {
+          logger.debug(LOG_TAG2, "Invoice inclusion proof received");
+        }
+        const genesisTransaction = commitment.toTransaction(inclusionProof);
+        const invoicePredicate = await UnmaskedPredicate5.create(
+          invoiceTokenId,
+          invoiceTokenType,
+          signingService,
+          HashAlgorithm6.SHA256,
+          salt
         );
+        const tokenState = new TokenState5(invoicePredicate, null);
+        const sdkToken = await SdkToken4.mint(trustBase, tokenState, genesisTransaction);
+        if (this.config.debug) {
+          logger.debug(LOG_TAG2, "Invoice token minted successfully");
+        }
+        sdkData = JSON.stringify(sdkToken.toJSON());
       }
-      if (this.config.debug) {
-        logger.debug(LOG_TAG2, "Waiting for invoice inclusion proof...");
-      }
-      const inclusionProof = await waitInclusionProof6(trustBase, stClient, commitment);
-      if (this.config.debug) {
-        logger.debug(LOG_TAG2, "Invoice inclusion proof received");
-      }
-      const genesisTransaction = commitment.toTransaction(inclusionProof);
-      const invoicePredicate = await UnmaskedPredicate7.create(
-        invoiceTokenId,
-        invoiceTokenType,
-        signingService,
-        HashAlgorithm8.SHA256,
-        salt
-      );
-      const tokenState = new TokenState7(invoicePredicate, null);
-      const sdkToken = await SdkToken5.mint(trustBase, tokenState, genesisTransaction);
-      if (this.config.debug) {
-        logger.debug(LOG_TAG2, "Invoice token minted successfully");
-      }
-      const sdkTokenJson = sdkToken.toJSON();
       const uiToken = {
         id: invoiceId,
         coinId: INVOICE_TOKEN_TYPE_HEX,
@@ -19598,7 +19595,7 @@ var AccountingModule = class _AccountingModule {
         status: "confirmed",
         createdAt: terms.createdAt,
         updatedAt: terms.createdAt,
-        sdkData: JSON.stringify(sdkTokenJson)
+        sdkData
       };
       await deps.payments.addToken(uiToken);
       this.invoiceTermsCache.set(invoiceId, this._normalizeInvoiceTerms(terms));
@@ -19609,17 +19606,7 @@ var AccountingModule = class _AccountingModule {
       const allTokens = deps.payments.getTokens();
       let anyScanDirty = false;
       for (const token of allTokens) {
-        if (!token.sdkData) continue;
-        let txf;
-        try {
-          txf = JSON.parse(token.sdkData);
-        } catch {
-          continue;
-        }
-        const txCount = txf.transactions?.length ?? 0;
-        if (txCount === 0) continue;
-        this._processTokenTransactions(token.id, txf, 0);
-        anyScanDirty = true;
+        if (await this._scanTokenForAttribution(token, 0)) anyScanDirty = true;
       }
       const archivedTokensForScan = deps.payments.getArchivedTokens();
       for (const [archivedId, txf] of archivedTokensForScan) {
@@ -19635,7 +19622,7 @@ var AccountingModule = class _AccountingModule {
       if (this.config.debug) {
         logger.debug(LOG_TAG2, `Invoice created and stored: ${invoiceId}`);
       }
-      const txfToken = sdkTokenJson;
+      const txfToken = engine ? sdkData : JSON.parse(sdkData);
       return {
         success: true,
         invoiceId,
@@ -19676,36 +19663,60 @@ var AccountingModule = class _AccountingModule {
     this.ensureNotDestroyed();
     this.ensureInitialized();
     const deps = this.deps;
-    const tokenType = token.genesis?.data?.tokenType;
-    if (tokenType !== INVOICE_TOKEN_TYPE_HEX) {
-      throw new SphereError(
-        `Invoice import failed: token type "${tokenType}" is not the expected invoice type.`,
-        "INVOICE_WRONG_TOKEN_TYPE"
-      );
-    }
-    const tokenData = token.genesis?.data?.tokenData;
-    if (!tokenData || typeof tokenData !== "string") {
-      throw new SphereError(
-        "Invoice import failed: missing or invalid tokenData field.",
-        "INVOICE_INVALID_DATA"
-      );
-    }
-    let jsonString = tokenData;
-    if (!/^\s*[\[{"]/.test(tokenData)) {
+    let terms;
+    let tokenId;
+    let sdkDataForStore;
+    const engine = deps.tokenEngine;
+    const isV2 = !!engine && typeof token === "string";
+    if (isV2) {
+      const sphereToken = await engine.decodeToken(decodeTokenBlob(hexToBytes(token)));
+      const verifyResult = await engine.verify(sphereToken);
+      if (!verifyResult.ok) {
+        throw new SphereError("Invoice import failed: inclusion proof is invalid.", "INVOICE_INVALID_PROOF");
+      }
+      tokenId = engine.tokenId(sphereToken);
+      const data = engine.readTokenData(sphereToken);
+      if (!data) {
+        throw new SphereError("Invoice import failed: missing or invalid tokenData field.", "INVOICE_INVALID_DATA");
+      }
       try {
-        const bytes = hexToBytes(tokenData);
-        jsonString = new TextDecoder().decode(bytes);
+        terms = JSON.parse(new TextDecoder().decode(data));
       } catch {
+        throw new SphereError("Invoice import failed: tokenData is not valid JSON.", "INVOICE_INVALID_DATA");
       }
-    }
-    let terms;
-    try {
-      terms = JSON.parse(jsonString);
-    } catch {
-      throw new SphereError(
-        "Invoice import failed: tokenData is not valid JSON.",
-        "INVOICE_INVALID_DATA"
-      );
+      sdkDataForStore = token;
+    } else {
+      const tokenType = token.genesis?.data?.tokenType;
+      if (tokenType !== INVOICE_TOKEN_TYPE_HEX) {
+        throw new SphereError(
+          `Invoice import failed: token type "${tokenType}" is not the expected invoice type.`,
+          "INVOICE_WRONG_TOKEN_TYPE"
+        );
+      }
+      const tokenData = token.genesis?.data?.tokenData;
+      if (!tokenData || typeof tokenData !== "string") {
+        throw new SphereError(
+          "Invoice import failed: missing or invalid tokenData field.",
+          "INVOICE_INVALID_DATA"
+        );
+      }
+      let jsonString = tokenData;
+      if (!/^\s*[[{"]/.test(tokenData)) {
+        try {
+          const bytes = hexToBytes(tokenData);
+          jsonString = new TextDecoder().decode(bytes);
+        } catch {
+        }
+      }
+      try {
+        terms = JSON.parse(jsonString);
+      } catch {
+        throw new SphereError(
+          "Invoice import failed: tokenData is not valid JSON.",
+          "INVOICE_INVALID_DATA"
+        );
+      }
+      sdkDataForStore = JSON.stringify(token);
     }
     if (!terms || typeof terms !== "object") {
       throw new SphereError(
@@ -19792,7 +19803,7 @@ var AccountingModule = class _AccountingModule {
         }
       }
     }
-    const tokenId = token.genesis?.data?.tokenId;
+    if (!isV2) tokenId = token.genesis?.data?.tokenId;
     if (!tokenId || typeof tokenId !== "string") {
       throw new SphereError(
         "Invoice import failed: missing tokenId in genesis data.",
@@ -19805,13 +19816,13 @@ var AccountingModule = class _AccountingModule {
         "INVOICE_ALREADY_EXISTS"
       );
     }
-    {
-      const { DataHasher } = await import("@unicitylabs/state-transition-sdk/lib/hash/DataHasher.js");
-      const { HashAlgorithm: HashAlgorithm8 } = await import("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm.js");
-      const { TokenId: TokenId5 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenId.js");
+    if (!isV2) {
+      const { DataHasher: DataHasher2 } = await import("@unicitylabs/state-transition-sdk/lib/hash/DataHasher.js");
+      const { HashAlgorithm: HashAlgorithm6 } = await import("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm.js");
+      const { TokenId: TokenId4 } = await import("@unicitylabs/state-transition-sdk/lib/token/TokenId.js");
       const reSerializedBytes = new TextEncoder().encode(canonicalSerialize(terms));
-      const hash = await new DataHasher(HashAlgorithm8.SHA256).update(reSerializedBytes).digest();
-      const reTokenId = new TokenId5(hash.imprint).toJSON();
+      const hash = await new DataHasher2(HashAlgorithm6.SHA256).update(reSerializedBytes).digest();
+      const reTokenId = new TokenId4(hash.imprint).toJSON();
       if (reTokenId !== tokenId) {
         throw new SphereError(
           "Invoice import failed: parsed terms do not match on-chain token ID (canonical hash mismatch).",
@@ -19819,35 +19830,37 @@ var AccountingModule = class _AccountingModule {
         );
       }
     }
-    if (!deps.trustBase || deps.trustBase instanceof Uint8Array && deps.trustBase.length === 0) {
-      throw new SphereError(
-        "Trust base unavailable \u2014 cannot verify invoice proof. Ensure oracle supports getTrustBase().",
-        "INVOICE_INVALID_PROOF"
-      );
-    }
-    try {
-      const sdkToken = await import_Token8.Token.fromJSON(token);
-      const verifyResult = await sdkToken.verify(deps.trustBase);
-      const verifyOk = verifyResult.isSuccessful === true;
-      if (!verifyOk) {
+    if (!isV2) {
+      if (!deps.trustBase || deps.trustBase instanceof Uint8Array && deps.trustBase.length === 0) {
         throw new SphereError(
-          "Invoice import failed: inclusion proof is invalid.",
+          "Trust base unavailable \u2014 cannot verify invoice proof. Ensure oracle supports getTrustBase().",
           "INVOICE_INVALID_PROOF"
         );
       }
-      const canonicalTokenId = sdkToken.id?.toJSON?.() ?? null;
-      if (!canonicalTokenId || canonicalTokenId !== tokenId) {
+      try {
+        const sdkToken = await import_Token7.Token.fromJSON(token);
+        const verifyResult = await sdkToken.verify(deps.trustBase);
+        const verifyOk = verifyResult.isSuccessful === true;
+        if (!verifyOk) {
+          throw new SphereError(
+            "Invoice import failed: inclusion proof is invalid.",
+            "INVOICE_INVALID_PROOF"
+          );
+        }
+        const canonicalTokenId = sdkToken.id?.toJSON?.() ?? null;
+        if (!canonicalTokenId || canonicalTokenId !== tokenId) {
+          throw new SphereError(
+            `Invoice import failed: tokenId mismatch or unverifiable \u2014 JSON claims ${tokenId}, cryptographic identity is ${canonicalTokenId ?? "unknown"}`,
+            "INVOICE_INVALID_DATA"
+          );
+        }
+      } catch (err) {
+        if (err instanceof SphereError) throw err;
         throw new SphereError(
-          `Invoice import failed: tokenId mismatch or unverifiable \u2014 JSON claims ${tokenId}, cryptographic identity is ${canonicalTokenId ?? "unknown"}`,
-          "INVOICE_INVALID_DATA"
+          `Invoice import failed: proof verification error \u2014 ${err instanceof Error ? err.message : String(err)}`,
+          "INVOICE_INVALID_PROOF"
         );
       }
-    } catch (err) {
-      if (err instanceof SphereError) throw err;
-      throw new SphereError(
-        `Invoice import failed: proof verification error \u2014 ${err instanceof Error ? err.message : String(err)}`,
-        "INVOICE_INVALID_PROOF"
-      );
     }
     try {
       const uiToken = {
@@ -19860,7 +19873,7 @@ var AccountingModule = class _AccountingModule {
         status: "confirmed",
         createdAt: terms.createdAt,
         updatedAt: terms.createdAt,
-        sdkData: JSON.stringify(token)
+        sdkData: sdkDataForStore
       };
       await deps.payments.addToken(uiToken);
     } catch (err) {
@@ -19915,17 +19928,8 @@ var AccountingModule = class _AccountingModule {
     const allTokens = deps.payments.getTokens();
     let anyDirty = false;
     for (const existingToken of allTokens) {
-      if (!existingToken.sdkData) continue;
-      let txf;
-      try {
-        txf = JSON.parse(existingToken.sdkData);
-      } catch {
-        continue;
-      }
-      const transactions = txf.transactions ?? [];
       const startIndex = this.tokenScanState.get(existingToken.id) ?? 0;
-      if (transactions.length > startIndex) {
-        this._processTokenTransactions(existingToken.id, txf, startIndex);
+      if (await this._scanTokenForAttribution(existingToken, startIndex)) {
         anyDirty = true;
       }
     }
@@ -21815,17 +21819,8 @@ var AccountingModule = class _AccountingModule {
     const allTokens = deps.payments.getTokens();
     let anyDirty = false;
     for (const token of allTokens) {
-      if (!token.sdkData) continue;
-      let txf;
-      try {
-        txf = JSON.parse(token.sdkData);
-      } catch {
-        continue;
-      }
-      const transactions = txf.transactions ?? [];
       const startIndex = this.tokenScanState.get(token.id) ?? 0;
-      if (transactions.length > startIndex) {
-        this._processTokenTransactions(token.id, txf, startIndex);
+      if (await this._scanTokenForAttribution(token, startIndex)) {
         anyDirty = true;
       }
     }
@@ -21880,6 +21875,53 @@ var AccountingModule = class _AccountingModule {
    * @param txf        - Parsed TxfToken.
    * @param startIndex - First unprocessed transaction index.
    */
+  /**
+   * Attribute one payment token's invoice memo(s) to the ledger.
+   *
+   * v2 (engine blob): the token carries a single on-chain memo. We decode it and
+   * shim the token into a v1-shaped `txf` (coinData ← engine.readValue, the memo
+   * ← engine.readMemo) so the battle-hardened `_processTokenTransactions` runs
+   * UNCHANGED — same dedup, direction, provisional/synthetic/orphan handling.
+   * v1 (TXF JSON): parse and scan transactions directly.
+   *
+   * `startIndex` is the per-token watermark (0 for a full retroactive scan).
+   * Returns true when the token was scanned. Async because engine.decodeToken is.
+   */
+  async _scanTokenForAttribution(token, startIndex) {
+    if (!token.sdkData) return false;
+    const engine = this.deps?.tokenEngine;
+    const isBlob = token.sdkData.length >= 2 && token.sdkData.length % 2 === 0 && token.sdkData[0] !== "{" && /^[0-9a-f]+$/i.test(token.sdkData);
+    if (engine && isBlob) {
+      let syntheticTxf;
+      try {
+        const sphereToken = await engine.decodeToken(decodeTokenBlob(hexToBytes(token.sdkData)));
+        const memo = engine.readMemo(sphereToken);
+        if (!memo) return false;
+        const coinData = (engine.readValue(sphereToken)?.assets ?? []).map(
+          (a) => [a.coinId, a.amount.toString()]
+        );
+        syntheticTxf = {
+          genesis: { data: { coinData } },
+          transactions: [{ data: { message: bytesToHex(memo) }, inclusionProof: {} }]
+        };
+      } catch {
+        return false;
+      }
+      this._processTokenTransactions(token.id, syntheticTxf, startIndex);
+      return true;
+    }
+    let txf;
+    try {
+      txf = JSON.parse(token.sdkData);
+    } catch {
+      return false;
+    }
+    if ((txf.transactions?.length ?? 0) > startIndex) {
+      this._processTokenTransactions(token.id, txf, startIndex);
+      return true;
+    }
+    return false;
+  }
   _processTokenTransactions(tokenId, txf, startIndex) {
     const transactions = txf.transactions ?? [];
     let lastSuccessIdx = startIndex;
@@ -22159,17 +22201,7 @@ var AccountingModule = class _AccountingModule {
   async _handleIncomingTransfer(transfer) {
     if (this.destroyed) return;
     for (const token of transfer.tokens) {
-      if (!token.sdkData) continue;
-      let txf;
-      try {
-        txf = JSON.parse(token.sdkData);
-      } catch {
-        continue;
-      }
-      const startIndex = this.tokenScanState.get(token.id) ?? 0;
-      if ((txf.transactions?.length ?? 0) > startIndex) {
-        this._processTokenTransactions(token.id, txf, startIndex);
-      }
+      await this._scanTokenForAttribution(token, this.tokenScanState.get(token.id) ?? 0);
     }
     if (this.destroyed) return;
     await this._flushDirtyLedgerEntries();
@@ -22307,16 +22339,7 @@ var AccountingModule = class _AccountingModule {
     if (this.destroyed) return;
     for (const token of result.tokens) {
       if (!token.sdkData) continue;
-      let txf;
-      try {
-        txf = JSON.parse(token.sdkData);
-      } catch {
-        continue;
-      }
-      const startIndex = this.tokenScanState.get(token.id) ?? 0;
-      if ((txf.transactions?.length ?? 0) > startIndex) {
-        this._processTokenTransactions(token.id, txf, startIndex);
-      }
+      await this._scanTokenForAttribution(token, this.tokenScanState.get(token.id) ?? 0);
       const relatedInvoices = this.tokenInvoiceMap.get(token.id);
       if (relatedInvoices) {
         for (const invoiceId of relatedInvoices) {
@@ -22387,15 +22410,8 @@ var AccountingModule = class _AccountingModule {
     const tokens = this.deps.payments.getTokens();
     const token = tokens.find((t) => t.id === tokenId);
     if (!token?.sdkData) return;
-    let txf;
-    try {
-      txf = JSON.parse(token.sdkData);
-    } catch {
-      return;
-    }
     const startIndex = this.tokenScanState.get(tokenId) ?? 0;
-    if ((txf.transactions?.length ?? 0) > startIndex) {
-      this._processTokenTransactions(tokenId, txf, startIndex);
+    if (await this._scanTokenForAttribution(token, startIndex)) {
       if (this.destroyed) return;
       await this._flushDirtyLedgerEntries();
     }
@@ -27828,29 +27844,421 @@ async function parseAndDecryptWalletDat(data, password, onProgress) {
   };
 }
 
+// token-engine/identity.ts
+var UNICITY_TOKEN_TYPE_HEX = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
+var SIGNING_ALGORITHM = "secp256k1";
+var EMBEDDED_PREDICATE_UNMASKED = 0;
+var HASH_ALGORITHM_SHA256 = 0n;
+var SHA256_IMPRINT_PREFIX = new Uint8Array([0, 0]);
+function hexToBytes4(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function sha2565(data) {
+  return new import_DataHasher.DataHasher(import_HashAlgorithm2.HashAlgorithm.SHA256).update(data).digest().then((h) => h.data);
+}
+async function deriveDirectAddress(publicKey) {
+  const tokenTypeCbor = import_CborSerializer.CborSerializer.encodeByteString(hexToBytes4(UNICITY_TOKEN_TYPE_HEX));
+  const reference = import_CborSerializer.CborSerializer.encodeArray(
+    import_CborSerializer.CborSerializer.encodeByteString(new Uint8Array([EMBEDDED_PREDICATE_UNMASKED])),
+    import_CborSerializer.CborSerializer.encodeByteString(tokenTypeCbor),
+    import_CborSerializer.CborSerializer.encodeTextString(SIGNING_ALGORITHM),
+    import_CborSerializer.CborSerializer.encodeUnsignedInteger(HASH_ALGORITHM_SHA256),
+    import_CborSerializer.CborSerializer.encodeByteString(publicKey)
+  );
+  const refHash = await sha2565(reference);
+  const imprint = new Uint8Array([...SHA256_IMPRINT_PREFIX, ...refHash]);
+  const checksum = (await sha2565(imprint)).slice(0, 4);
+  return `DIRECT://${import_HexConverter.HexConverter.encode(imprint)}${import_HexConverter.HexConverter.encode(checksum)}`;
+}
+
+// token-engine/factory.ts
+init_errors();
+
+// token-engine/SpherePaymentData.ts
+init_errors();
+var COIN_ID_PATTERN = /^([0-9a-f]{2})+$/;
+function assertAsset(coinId, amount) {
+  if (!COIN_ID_PATTERN.test(coinId)) {
+    throw new SphereError(`Invalid coin id (expected even-length lowercase hex): "${coinId}"`, "VALIDATION_ERROR");
+  }
+  if (amount < 0n) {
+    throw new SphereError(`Asset amount must be non-negative: ${amount.toString()}`, "VALIDATION_ERROR");
+  }
+}
+function sphereAssetToSdk(coinId, amount) {
+  assertAsset(coinId, amount);
+  return new import_Asset.Asset(new import_AssetId.AssetId(import_HexConverter.HexConverter.decode(coinId)), amount);
+}
+var SpherePaymentData = class _SpherePaymentData {
+  constructor(assets, _memo = null) {
+    this.assets = assets;
+    this._memo = _memo;
+  }
+  /** Sphere-private CBOR tag (verified free in the v2 SDK tag space). */
+  static CBOR_TAG = 39050n;
+  /** Envelope version; bump when the structure changes. */
+  static VERSION = 1n;
+  /** Opaque, app-defined memo carried alongside the value (e.g. invoice attribution). */
+  get memo() {
+    return this._memo ? new Uint8Array(this._memo) : null;
+  }
+  /** Wrap an existing SDK asset collection (+ optional opaque memo). */
+  static create(assets, memo = null) {
+    return new _SpherePaymentData(assets, memo);
+  }
+  /** Build from a sphere-domain value (hex coin id → bigint amount) + optional opaque memo. */
+  static fromValue(value, memo = null) {
+    const assets = value.assets.map((a) => sphereAssetToSdk(a.coinId, a.amount));
+    return new _SpherePaymentData(import_PaymentAssetCollection.PaymentAssetCollection.create(...assets), memo);
+  }
+  /** Decode from the CBOR envelope produced by {@link encode}. */
+  static fromCBOR(bytes) {
+    const tag = import_CborDeserializer.CborDeserializer.decodeTag(bytes);
+    if (tag.tag !== _SpherePaymentData.CBOR_TAG) {
+      throw new import_CborError.CborError(`Invalid SpherePaymentData tag: ${tag.tag}`);
+    }
+    const fields = import_CborDeserializer.CborDeserializer.decodeArray(tag.data, 3);
+    const version = import_CborDeserializer.CborDeserializer.decodeUnsignedInteger(fields[0]);
+    if (version !== _SpherePaymentData.VERSION) {
+      throw new import_CborError.CborError(`Unsupported SpherePaymentData version: ${version}`);
+    }
+    const memo = import_CborDeserializer.CborDeserializer.decodeNullable(fields[2], import_CborDeserializer.CborDeserializer.decodeByteString);
+    return new _SpherePaymentData(import_PaymentAssetCollection.PaymentAssetCollection.fromCBOR(fields[1]), memo);
+  }
+  /** Deterministic, versioned, tagged CBOR: `tag(39050)[ version, assets, memo? ]`. */
+  encode() {
+    return Promise.resolve(
+      import_CborSerializer.CborSerializer.encodeTag(
+        _SpherePaymentData.CBOR_TAG,
+        import_CborSerializer.CborSerializer.encodeArray(
+          import_CborSerializer.CborSerializer.encodeUnsignedInteger(_SpherePaymentData.VERSION),
+          this.assets.toCBOR(),
+          import_CborSerializer.CborSerializer.encodeNullable(this._memo, import_CborSerializer.CborSerializer.encodeByteString)
+        )
+      )
+    );
+  }
+  /** Project to a sphere-domain value (hex coin id + bigint amount), preserving order. */
+  toValue() {
+    return {
+      assets: this.assets.toArray().map((a) => ({
+        coinId: import_HexConverter.HexConverter.encode(a.id.bytes),
+        amount: a.value
+      }))
+    };
+  }
+  /** Balance of a single coin within this payload (0n when absent). */
+  balanceOf(coinId) {
+    if (!COIN_ID_PATTERN.test(coinId)) {
+      throw new SphereError(`Invalid coin id (expected even-length lowercase hex): "${coinId}"`, "VALIDATION_ERROR");
+    }
+    const asset = this.assets.get(new import_AssetId.AssetId(import_HexConverter.HexConverter.decode(coinId)));
+    return asset ? asset.value : 0n;
+  }
+};
+function decodeSpherePaymentData(bytes) {
+  return Promise.resolve(SpherePaymentData.fromCBOR(bytes));
+}
+
+// token-engine/SphereTokenEngine.ts
+init_errors();
+var SphereTokenEngine = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  // ── identity ────────────────────────────────────────────────────────────────
+  getIdentity() {
+    return { chainPubkey: new Uint8Array(this.deps.signingService.publicKey) };
+  }
+  /** Legacy DIRECT:// address (Path A). Async: the derivation hashes via the SDK. */
+  deriveIdentityAddress(pubkey) {
+    return deriveDirectAddress(pubkey ?? this.deps.signingService.publicKey);
+  }
+  // ── value (read) ─────────────────────────────────────────────────────────────
+  readValue(token) {
+    return token.value;
+  }
+  balanceOf(token, coinId) {
+    let sum = 0n;
+    for (const asset of token.value?.assets ?? []) {
+      if (asset.coinId === coinId) sum += asset.amount;
+    }
+    return sum;
+  }
+  tokenId(token) {
+    return token.blob.tokenId;
+  }
+  readMemo(token) {
+    const sdkToken = token.sdkToken;
+    if (sdkToken.transactions.length > 0) {
+      return sdkToken.latestTransaction.data;
+    }
+    const data = sdkToken.genesis.data;
+    if (data && this.isSpherePaymentData(data)) {
+      return SpherePaymentData.fromCBOR(data).memo;
+    }
+    return null;
+  }
+  readTokenData(token) {
+    const data = token.sdkToken.genesis.data;
+    return data ? new Uint8Array(data) : null;
+  }
+  // ── lifecycle ────────────────────────────────────────────────────────────────
+  async mint(params, options) {
+    const recipient = import_SignaturePredicate.SignaturePredicate.create(params.recipientPubkey);
+    const data = params.value ? await SpherePaymentData.fromValue(params.value).encode() : null;
+    const mintTx = await import_MintTransaction.MintTransaction.create(this.deps.networkId, recipient, data);
+    const certificationData = await import_CertificationData.CertificationData.fromMintTransaction(mintTx);
+    const response = await this.deps.client.submitCertificationRequest(certificationData);
+    if (response.status !== import_CertificationResponse.CertificationStatus.SUCCESS) {
+      throw new SphereError(`Mint certification failed: ${response.status}`, "AGGREGATOR_ERROR");
+    }
+    const proof = await (0, import_InclusionProofUtils2.waitInclusionProof)(
+      this.deps.client,
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      mintTx,
+      options?.signal
+    );
+    const certified = await mintTx.toCertifiedTransaction(this.deps.trustBase, this.deps.predicateVerifier, proof);
+    const token = await import_Token2.Token.mint(
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      this.deps.mintJustificationVerifier,
+      certified
+    );
+    return this.wrapToken(token);
+  }
+  async mintDataToken(params, options) {
+    const recipient = import_SignaturePredicate.SignaturePredicate.create(params.recipientPubkey);
+    const tokenType = params.tokenType ? new import_TokenType.TokenType(params.tokenType) : import_TokenType.TokenType.generate();
+    const salt = params.salt ? import_TokenSalt.TokenSalt.fromBytes(params.salt) : import_TokenSalt.TokenSalt.generate();
+    const mintTx = await import_MintTransaction.MintTransaction.create(this.deps.networkId, recipient, params.data, tokenType, salt);
+    const certificationData = await import_CertificationData.CertificationData.fromMintTransaction(mintTx);
+    const response = await this.deps.client.submitCertificationRequest(certificationData);
+    if (response.status !== import_CertificationResponse.CertificationStatus.SUCCESS) {
+      throw new SphereError(`Data-token mint failed: ${response.status}`, "AGGREGATOR_ERROR");
+    }
+    const proof = await (0, import_InclusionProofUtils2.waitInclusionProof)(
+      this.deps.client,
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      mintTx,
+      options?.signal
+    );
+    const certified = await mintTx.toCertifiedTransaction(this.deps.trustBase, this.deps.predicateVerifier, proof);
+    const token = await import_Token2.Token.mint(
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      this.deps.mintJustificationVerifier,
+      certified
+    );
+    return this.wrapToken(token);
+  }
+  async transfer(params, options) {
+    this.assertOwned(params.token);
+    const recipient = import_SignaturePredicate.SignaturePredicate.create(params.recipientPubkey);
+    const stateMask = crypto.getRandomValues(new Uint8Array(32));
+    const transferTx = await import_TransferTransaction.TransferTransaction.create(params.token.sdkToken, recipient, stateMask, params.data ?? null);
+    const unlockScript = await import_SignaturePredicateUnlockScript.SignaturePredicateUnlockScript.create(transferTx, this.deps.signingService);
+    const certificationData = await import_CertificationData.CertificationData.fromTransaction(transferTx, unlockScript);
+    const response = await this.deps.client.submitCertificationRequest(certificationData);
+    if (response.status !== import_CertificationResponse.CertificationStatus.SUCCESS) {
+      throw new SphereError(`Transfer certification failed: ${response.status}`, "TRANSFER_FAILED");
+    }
+    const proof = await (0, import_InclusionProofUtils2.waitInclusionProof)(
+      this.deps.client,
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      transferTx,
+      options?.signal
+    );
+    const certified = await transferTx.toCertifiedTransaction(this.deps.trustBase, this.deps.predicateVerifier, proof);
+    const transferred = await params.token.sdkToken.transfer(this.deps.trustBase, this.deps.predicateVerifier, certified);
+    return this.wrapToken(transferred);
+  }
+  async split(params, options) {
+    this.assertOwned(params.token);
+    if (params.outputs.length === 0) {
+      throw new SphereError("Split requires at least one output", "VALIDATION_ERROR");
+    }
+    const requests = params.outputs.map(
+      (o) => import_SplitTokenRequest.SplitTokenRequest.create(
+        import_SignaturePredicate.SignaturePredicate.create(o.recipientPubkey),
+        import_PaymentAssetCollection.PaymentAssetCollection.create(sphereAssetToSdk(o.coinId, o.amount))
+      )
+    );
+    const split = await import_TokenSplit.TokenSplit.split(params.token.sdkToken, decodeSpherePaymentData, requests);
+    const burnUnlock = await import_SignaturePredicateUnlockScript.SignaturePredicateUnlockScript.create(split.burn.transaction, this.deps.signingService);
+    const burnCert = await import_CertificationData.CertificationData.fromTransaction(split.burn.transaction, burnUnlock);
+    const burnResponse = await this.deps.client.submitCertificationRequest(burnCert);
+    if (burnResponse.status !== import_CertificationResponse.CertificationStatus.SUCCESS) {
+      throw new SphereError(`Split burn failed: ${burnResponse.status}`, "TRANSFER_FAILED");
+    }
+    const burnProof = await (0, import_InclusionProofUtils2.waitInclusionProof)(
+      this.deps.client,
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      split.burn.transaction,
+      options?.signal
+    );
+    const burnCertified = await split.burn.transaction.toCertifiedTransaction(
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      burnProof
+    );
+    const burntToken = await params.token.sdkToken.transfer(
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      burnCertified
+    );
+    const outputs = [];
+    for (let i = 0; i < split.tokens.length; i++) {
+      const splitToken = split.tokens[i];
+      const data = await SpherePaymentData.create(splitToken.assets, params.outputs[i].data ?? null).encode();
+      const justification = import_SplitMintJustification.SplitMintJustification.create(burntToken, splitToken.proofs).toCBOR();
+      const mintTx = await import_MintTransaction.MintTransaction.create(
+        splitToken.networkId,
+        splitToken.recipient,
+        data,
+        splitToken.tokenType,
+        splitToken.salt,
+        justification
+      );
+      const certData = await import_CertificationData.CertificationData.fromMintTransaction(mintTx);
+      const response = await this.deps.client.submitCertificationRequest(certData);
+      if (response.status !== import_CertificationResponse.CertificationStatus.SUCCESS) {
+        throw new SphereError(`Split mint failed: ${response.status}`, "AGGREGATOR_ERROR");
+      }
+      const proof = await (0, import_InclusionProofUtils2.waitInclusionProof)(
+        this.deps.client,
+        this.deps.trustBase,
+        this.deps.predicateVerifier,
+        mintTx,
+        options?.signal
+      );
+      const certified = await mintTx.toCertifiedTransaction(this.deps.trustBase, this.deps.predicateVerifier, proof);
+      const token = await import_Token2.Token.mint(
+        this.deps.trustBase,
+        this.deps.predicateVerifier,
+        this.deps.mintJustificationVerifier,
+        certified
+      );
+      outputs.push(this.wrapToken(token));
+    }
+    return { outputs };
+  }
+  // ── verification ─────────────────────────────────────────────────────────────
+  async verify(token, _options) {
+    const result = await token.sdkToken.verify(
+      this.deps.trustBase,
+      this.deps.predicateVerifier,
+      this.deps.mintJustificationVerifier
+    );
+    return result.status === import_VerificationStatus.VerificationStatus.OK ? { ok: true } : { ok: false, reason: String(result.status) };
+  }
+  async isSpent(token, _options) {
+    const probe = await import_TransferTransaction.TransferTransaction.create(
+      token.sdkToken,
+      import_SignaturePredicate.SignaturePredicate.create(this.deps.signingService.publicKey),
+      new Uint8Array(32)
+    );
+    const stateId = await import_StateId.StateId.fromTransaction(probe);
+    const response = await this.deps.client.getInclusionProof(stateId);
+    return response.inclusionProof.inclusionCertificate !== null;
+  }
+  // ── serialization ────────────────────────────────────────────────────────────
+  encodeToken(token) {
+    return token.blob;
+  }
+  async decodeToken(blob) {
+    const sdkToken = await import_Token2.Token.fromCBOR(blob.token);
+    if (sdkToken.genesis.networkId.id !== this.deps.networkId.id) {
+      throw new SphereError(
+        `Token network mismatch: token is on network ${sdkToken.genesis.networkId.id}, engine on ${this.deps.networkId.id}`,
+        "VALIDATION_ERROR"
+      );
+    }
+    return this.wrapToken(sdkToken);
+  }
+  // ── internals ────────────────────────────────────────────────────────────────
+  /** Fail fast if this engine's key does not own the token's current state. */
+  assertOwned(token) {
+    const owner = token.sdkToken.latestTransaction.recipient;
+    const mine = import_EncodedPredicate.EncodedPredicate.fromPredicate(import_SignaturePredicate.SignaturePredicate.create(this.deps.signingService.publicKey));
+    if (!import_EncodedPredicate.EncodedPredicate.equals(owner, mine)) {
+      throw new SphereError("Cannot transfer a token not owned by this engine identity", "VALIDATION_ERROR");
+    }
+  }
+  /** Wrap an SDK token into a SphereToken: cache its blob (incl. stable tokenId) + decoded value. */
+  wrapToken(sdkToken) {
+    const data = sdkToken.genesis.data;
+    let value = null;
+    if (data && this.isSpherePaymentData(data)) {
+      try {
+        value = SpherePaymentData.fromCBOR(data).toValue();
+      } catch (err) {
+        throw new SphereError(
+          `Failed to decode token payment data: ${err instanceof Error ? err.message : String(err)}`,
+          "VALIDATION_ERROR"
+        );
+      }
+    }
+    const blob = {
+      v: TOKEN_BLOB_VERSION,
+      network: sdkToken.genesis.networkId.id,
+      tokenId: import_HexConverter.HexConverter.encode(sdkToken.id.bytes),
+      token: sdkToken.toCBOR()
+    };
+    return { sdkToken, blob, value };
+  }
+  /** True if the bytes are a SpherePaymentData envelope (value token) vs a raw data token. */
+  isSpherePaymentData(data) {
+    try {
+      return import_CborDeserializer.CborDeserializer.decodeTag(data).tag === SpherePaymentData.CBOR_TAG;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// token-engine/factory.ts
+async function createSphereTokenEngine(config) {
+  if (config.trustBaseJson == null) {
+    throw new SphereError("Engine config requires a trust base (trustBaseJson)", "INVALID_CONFIG");
+  }
+  const trustBase = import_RootTrustBase.RootTrustBase.fromJSON(config.trustBaseJson);
+  const predicateVerifier = import_PredicateVerifierService.PredicateVerifierService.create();
+  const mintJustificationVerifier = new import_MintJustificationVerifierService.MintJustificationVerifierService();
+  mintJustificationVerifier.register(
+    new import_SplitMintJustificationVerifier.SplitMintJustificationVerifier(trustBase, predicateVerifier, decodeSpherePaymentData)
+  );
+  const deps = {
+    client: new import_StateTransitionClient.StateTransitionClient(new import_AggregatorClient.AggregatorClient(config.aggregatorUrl, config.apiKey ?? null)),
+    trustBase,
+    predicateVerifier,
+    mintJustificationVerifier,
+    signingService: new import_SigningService.SigningService(config.privateKey),
+    // The trust base is the single source of truth for the network id (it carries
+    // NetworkId.fromId, so any id works — e.g. testnet2 = 4 — with no enum entry).
+    networkId: trustBase.networkId
+  };
+  return new SphereTokenEngine(deps);
+}
+
 // core/Sphere.ts
-var import_SigningService2 = require("@unicitylabs/state-transition-sdk/lib/sign/SigningService");
-var import_TokenType5 = require("@unicitylabs/state-transition-sdk/lib/token/TokenType");
-var import_HashAlgorithm7 = require("@unicitylabs/state-transition-sdk/lib/hash/HashAlgorithm");
-var import_UnmaskedPredicateReference3 = require("@unicitylabs/state-transition-sdk/lib/predicate/embedded/UnmaskedPredicateReference");
-var import_nostr_js_sdk5 = require("@unicitylabs/nostr-js-sdk");
+var import_nostr_js_sdk4 = require("@unicitylabs/nostr-js-sdk");
 function isValidNametag2(nametag) {
-  if ((0, import_nostr_js_sdk5.isPhoneNumber)(nametag)) return true;
+  if ((0, import_nostr_js_sdk4.isPhoneNumber)(nametag)) return true;
   return /^[a-z0-9_-]{3,20}$/.test(nametag);
 }
-var UNICITY_TOKEN_TYPE_HEX2 = "f8aa13834268d29355ff12183066f0cb902003629bbc5eb9ef0efbe397867509";
 async function deriveL3PredicateAddress(privateKey) {
-  const secret = Buffer.from(privateKey, "hex");
-  const signingService = await import_SigningService2.SigningService.createFromSecret(secret);
-  const tokenTypeBytes = Buffer.from(UNICITY_TOKEN_TYPE_HEX2, "hex");
-  const tokenType = new import_TokenType5.TokenType(tokenTypeBytes);
-  const predicateRef = import_UnmaskedPredicateReference3.UnmaskedPredicateReference.create(
-    tokenType,
-    signingService.algorithm,
-    signingService.publicKey,
-    import_HashAlgorithm7.HashAlgorithm.SHA256
-  );
-  return (await (await predicateRef).toAddress()).toString();
+  const prehashedPublicKey = getPublicKey(sha2562(privateKey, "hex"));
+  return deriveDirectAddress(hexToBytes2(prehashedPublicKey));
 }
 var Sphere = class _Sphere {
   // Singleton
@@ -27872,14 +28280,14 @@ var Sphere = class _Sphere {
   _addressIdToIndex = /* @__PURE__ */ new Map();
   /** Nametag cache: addressId -> (nametagIndex -> nametag). Separate from tracked addresses. */
   _addressNametags = /* @__PURE__ */ new Map();
-  /** Cached PROXY address (computed once when nametag is set) */
-  _cachedProxyAddress = void 0;
   // Providers
   _storage;
   _tokenStorageProviders = /* @__PURE__ */ new Map();
   _transport;
   _oracle;
   _priceProvider;
+  /** v2 token engine (built per active address from the oracle); injected into modules. */
+  _tokenEngine;
   // Modules (single-instance — backward compat, delegates to active address)
   _payments;
   _communications;
@@ -28220,20 +28628,6 @@ var Sphere = class _Sphere {
     await sphere.syncIdentityWithTransport();
     sphere._initialized = true;
     _Sphere.instance = sphere;
-    if (sphere._identity?.nametag && !sphere._payments.hasNametag()) {
-      progress?.({ step: "registering_nametag", message: "Restoring nametag token..." });
-      logger.debug("Sphere", `Unicity ID @${sphere._identity.nametag} has no token, attempting to mint...`);
-      try {
-        const result = await sphere.mintNametag(sphere._identity.nametag);
-        if (result.success) {
-          logger.debug("Sphere", `Nametag token minted successfully on load`);
-        } else {
-          logger.warn("Sphere", `Could not mint nametag token: ${result.error}`);
-        }
-      } catch (err) {
-        logger.warn("Sphere", `Nametag token mint failed:`, err);
-      }
-    }
     if (options.discoverAddresses !== false && sphere._transport.discoverAddresses && sphere._masterKey) {
       progress?.({ step: "discovering_addresses", message: "Discovering addresses..." });
       try {
@@ -29285,13 +29679,13 @@ var Sphere = class _Sphere {
           oracle: this._oracle,
           emitEvent: this.emitEvent.bind(this),
           chainCode: this._masterKey?.chainCode || void 0,
-          price: this._priceProvider ?? void 0
+          price: this._priceProvider ?? void 0,
+          tokenEngine: moduleSet.tokenEngine
         });
       }
     }
     this._identity = newIdentity;
     this._currentAddressIndex = index;
-    await this._updateCachedProxyAddress();
     const activeModules = this._addressModules.get(index);
     this._payments = activeModules.payments;
     this._communications = activeModules.communications;
@@ -29329,35 +29723,10 @@ var Sphere = class _Sphere {
     }
     if (newNametag) {
       await this.persistAddressNametags();
-      if (!this._payments.hasNametag()) {
-        logger.debug("Sphere", `Minting nametag token for @${newNametag}...`);
-        try {
-          const result = await this.mintNametag(newNametag);
-          if (result.success) {
-            logger.debug("Sphere", `Nametag token minted successfully`);
-          } else {
-            logger.warn("Sphere", `Could not mint nametag token: ${result.error}`);
-          }
-        } catch (err) {
-          logger.warn("Sphere", `Nametag token mint failed:`, err);
-        }
-      }
       this.emitEvent("nametag:registered", {
         nametag: newNametag,
         addressIndex: index
       });
-    } else if (this._identity?.nametag && !this._payments.hasNametag()) {
-      logger.debug("Sphere", `Unicity ID @${this._identity.nametag} has no token after switch, minting...`);
-      try {
-        const result = await this.mintNametag(this._identity.nametag);
-        if (result.success) {
-          logger.debug("Sphere", `Nametag token minted successfully after switch`);
-        } else {
-          logger.warn("Sphere", `Could not mint nametag token after switch: ${result.error}`);
-        }
-      } catch (err) {
-        logger.warn("Sphere", `Nametag token mint failed after switch:`, err);
-      }
     }
   }
   /**
@@ -29387,6 +29756,7 @@ var Sphere = class _Sphere {
     const communications = createCommunicationsModule(this._communicationsConfig);
     const groupChat = this._groupChatConfig ? createGroupChatModule(this._groupChatConfig) : null;
     const market = this._marketConfig ? createMarketModule(this._marketConfig) : null;
+    const tokenEngine = await this.buildTokenEngine(identity);
     payments.initialize({
       identity,
       storage: this._storage,
@@ -29395,7 +29765,8 @@ var Sphere = class _Sphere {
       oracle: this._oracle,
       emitEvent,
       chainCode: this._masterKey?.chainCode || void 0,
-      price: this._priceProvider ?? void 0
+      price: this._priceProvider ?? void 0,
+      tokenEngine
     });
     communications.initialize({
       identity,
@@ -29431,7 +29802,8 @@ var Sphere = class _Sphere {
           emitEvent,
           on: this.on.bind(this),
           storage: this._storage,
-          communications
+          communications,
+          tokenEngine
         });
       } else {
         logger.warn("Sphere", "Accounting module enabled but no token storage available \u2014 disabling");
@@ -29491,6 +29863,7 @@ var Sphere = class _Sphere {
       market,
       transportAdapter: adapter,
       tokenStorageProviders: new Map(tokenStorageProviders),
+      tokenEngine,
       initialized: true
     };
     this._addressModules.set(index, moduleSet);
@@ -30046,15 +30419,6 @@ var Sphere = class _Sphere {
   hasNametag() {
     return !!this._identity?.nametag;
   }
-  /**
-   * Get the PROXY address for the current nametag
-   * PROXY addresses are derived from the nametag hash and require
-   * the nametag token to claim funds sent to them
-   * @returns PROXY address string or undefined if no nametag
-   */
-  getProxyAddress() {
-    return this._cachedProxyAddress;
-  }
   /**
    * Resolve any identifier to full peer information.
    * Accepts @nametag, bare nametag, DIRECT://, PROXY://, L1 address, or transport pubkey.
@@ -30089,17 +30453,6 @@ var Sphere = class _Sphere {
       throw new SphereError(`Cannot resolve address: ${address.slice(0, 30)}`, "INVALID_RECIPIENT");
     }
   }
-  /** Compute and cache the PROXY address from the current nametag */
-  async _updateCachedProxyAddress() {
-    const nametag = this._identity?.nametag;
-    if (!nametag) {
-      this._cachedProxyAddress = void 0;
-      return;
-    }
-    const { ProxyAddress } = await import("@unicitylabs/state-transition-sdk/lib/address/ProxyAddress");
-    const proxyAddr = await ProxyAddress.fromNameTag(nametag);
-    this._cachedProxyAddress = proxyAddr.toString();
-  }
   /**
    * Register a nametag for the current active address
    * Each address can have its own independent nametag
@@ -30127,17 +30480,6 @@ var Sphere = class _Sphere {
     if (this._identity?.nametag) {
       throw new SphereError(`Unicity ID already registered for address ${this._currentAddressIndex}: @${this._identity.nametag}`, "ALREADY_INITIALIZED");
     }
-    if (!this._payments.hasNametag()) {
-      logger.debug("Sphere", `Minting nametag token for @${cleanNametag}...`);
-      const result = await this.mintNametag(cleanNametag);
-      if (!result.success) {
-        throw new SphereError(
-          `Failed to mint nametag token: ${result.error}`,
-          "AGGREGATOR_ERROR"
-        );
-      }
-      logger.debug("Sphere", `Nametag token minted successfully`);
-    }
     if (this._transport.publishIdentityBinding) {
       const success = await this._transport.publishIdentityBinding(
         this._identity.chainPubkey,
@@ -30150,7 +30492,6 @@ var Sphere = class _Sphere {
       }
     }
     this._identity.nametag = cleanNametag;
-    await this._updateCachedProxyAddress();
     const currentAddressId = this._trackedAddresses.get(this._currentAddressIndex)?.addressId;
     if (currentAddressId) {
       let nametags = this._addressNametags.get(currentAddressId);
@@ -30183,35 +30524,19 @@ var Sphere = class _Sphere {
     await this._storage.saveTrackedAddresses(entries);
   }
   /**
-   * Mint a nametag token on-chain (like Sphere wallet and lottery)
-   * This creates the nametag token required for receiving tokens via PROXY addresses (@nametag)
+   * Check whether a nametag is available to register.
    *
-   * @param nametag - The nametag to mint (e.g., "alice" or "@alice")
-   * @returns MintNametagResult with success status and token if successful
+   * D5: nametags are Nostr bindings (name ↔ chainPubkey), not on-chain tokens. Availability is
+   * first-seen-wins — a name is available iff no binding resolves for it.
    *
-   * @example
-   * ```typescript
-   * // Mint nametag token for receiving via @alice
-   * const result = await sphere.mintNametag('alice');
-   * if (result.success) {
-   *   console.log('Nametag minted:', result.nametagData?.name);
-   * } else {
-   *   console.error('Mint failed:', result.error);
-   * }
-   * ```
-   */
-  async mintNametag(nametag) {
-    this.ensureReady();
-    return this._payments.mintNametag(nametag);
-  }
-  /**
-   * Check if a nametag is available for minting
    * @param nametag - The nametag to check (e.g., "alice" or "@alice")
-   * @returns true if available, false if taken or error
+   * @returns true if available, false if already taken
    */
   async isNametagAvailable(nametag) {
     this.ensureReady();
-    return this._payments.isNametagAvailable(nametag);
+    if (!this._transport.resolveNametag) return true;
+    const bound = await this._transport.resolveNametag(this.cleanNametag(nametag));
+    return bound == null;
   }
   /**
    * Load tracked addresses from storage.
@@ -30386,7 +30711,6 @@ var Sphere = class _Sphere {
             }
             if (recoveredNametag && !this._identity?.nametag) {
               this._identity.nametag = recoveredNametag;
-              await this._updateCachedProxyAddress();
               const entry = await this.ensureAddressTracked(this._currentAddressIndex);
               let nametags = this._addressNametags.get(entry.addressId);
               if (!nametags) {
@@ -30475,7 +30799,6 @@ var Sphere = class _Sphere {
     try {
       if (this._identity) {
         this._identity.nametag = recoveredNametag;
-        await this._updateCachedProxyAddress();
       }
       const entry = await this.ensureAddressTracked(this._currentAddressIndex);
       let nametags = this._addressNametags.get(entry.addressId);
@@ -30495,7 +30818,7 @@ var Sphere = class _Sphere {
    */
   cleanNametag(raw) {
     const stripped = raw.startsWith("@") ? raw.slice(1) : raw;
-    return (0, import_nostr_js_sdk5.normalizeNametag)(stripped);
+    return (0, import_nostr_js_sdk4.normalizeNametag)(stripped);
   }
   // ===========================================================================
   // Public Methods - Lifecycle
@@ -30675,7 +30998,6 @@ var Sphere = class _Sphere {
     } else if (this._identity && nametag) {
       this._identity.nametag = nametag;
     }
-    await this._updateCachedProxyAddress();
   }
   async initializeIdentityFromMnemonic(mnemonic, derivationPath) {
     const basePath = derivationPath ?? DEFAULT_BASE_PATH;
@@ -30826,10 +31148,45 @@ var Sphere = class _Sphere {
     this._providerEventCleanups = [];
     this._lastProviderConnected.clear();
   }
+  /**
+   * Construct the v2 token engine for a given address identity (defaults to the
+   * active one) from the oracle's gateway URL + trust base and that address's
+   * signing key. The engine is per-address — each address signs with its own key.
+   * The trust base is the single source of truth for the network id (so any id
+   * works — e.g. testnet2 = 4 — with no enum entry). Returns undefined (modules
+   * keep their legacy path) when the oracle can't supply a trust base / url, or
+   * construction fails — a misconfigured oracle never breaks initialization.
+   */
+  async buildTokenEngine(identity) {
+    const oracle = this._oracle;
+    const privateKey = (identity ?? this._identity)?.privateKey;
+    const trustBaseJson = oracle.getTrustBaseJson?.() ?? null;
+    const aggregatorUrl = oracle.getAggregatorUrl?.();
+    if (!trustBaseJson || !aggregatorUrl || !privateKey) {
+      logger.warn("Sphere", "v2 token engine not constructed (oracle has no trust base / url, or no identity) \u2014 legacy path");
+      return void 0;
+    }
+    try {
+      return await createSphereTokenEngine({
+        aggregatorUrl,
+        apiKey: oracle.getApiKey?.(),
+        privateKey: hexToBytes2(privateKey),
+        trustBaseJson
+      });
+    } catch (err) {
+      logger.warn(
+        "Sphere",
+        `Failed to construct v2 token engine \u2014 modules use the legacy path: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return void 0;
+    }
+  }
   async initializeModules() {
     const emitEvent = this.emitEvent.bind(this);
     const adapter = await this.ensureTransportMux(this._currentAddressIndex, this._identity);
     const moduleTransport = adapter ?? this._transport;
+    this._tokenEngine = await this.buildTokenEngine();
+    const tokenEngine = this._tokenEngine;
     this._payments.initialize({
       identity: this._identity,
       storage: this._storage,
@@ -30840,7 +31197,8 @@ var Sphere = class _Sphere {
       // Pass chain code for L1 HD derivation
       chainCode: this._masterKey?.chainCode || void 0,
       price: this._priceProvider ?? void 0,
-      disabledProviderIds: this._disabledProviders
+      disabledProviderIds: this._disabledProviders,
+      tokenEngine
     });
     this._communications.initialize({
       identity: this._identity,
@@ -30876,7 +31234,8 @@ var Sphere = class _Sphere {
           emitEvent,
           on: this.on.bind(this),
           storage: this._storage,
-          communications: this._communications
+          communications: this._communications,
+          tokenEngine
         });
       } else {
         logger.warn("Sphere", "Accounting module enabled but no token storage available \u2014 disabling");
@@ -30938,6 +31297,7 @@ var Sphere = class _Sphere {
       market: this._market,
       transportAdapter: adapter,
       tokenStorageProviders: new Map(this._tokenStorageProviders),
+      tokenEngine: this._tokenEngine,
       initialized: true
     });
   }
@@ -31288,37 +31648,22 @@ init_constants();
 
 // validation/token-validator.ts
 init_logger();
+function stateIdOf(token) {
+  return sha2562(bytesToHex3(token.blob.token), "hex");
+}
 var TokenValidator = class {
-  aggregatorClient = null;
-  trustBase = null;
-  skipVerification;
-  // Cache for spent state verification
+  engine;
+  // Spent-status cache: SPENT is permanent (immutable), UNSPENT expires after a TTL.
   spentStateCache = /* @__PURE__ */ new Map();
   UNSPENT_CACHE_TTL_MS = 5 * 60 * 1e3;
   // 5 minutes
-  constructor(options = {}) {
-    this.aggregatorClient = options.aggregatorClient || null;
-    this.trustBase = options.trustBase || null;
-    this.skipVerification = options.skipVerification || false;
+  constructor(engine) {
+    this.engine = engine;
   }
-  /**
-   * Set the aggregator client
-   */
-  setAggregatorClient(client) {
-    this.aggregatorClient = client;
-  }
-  /**
-   * Set the trust base
-   */
-  setTrustBase(trustBase) {
-    this.trustBase = trustBase;
-  }
-  // =============================================================================
+  // ===========================================================================
   // Public API
-  // =============================================================================
-  /**
-   * Validate all tokens (parallel with batch limit)
-   */
+  // ===========================================================================
+  /** Validate all tokens (parallel, with a batch limit). */
   async validateAllTokens(tokens, options) {
     const validTokens = [];
     const issues = [];
@@ -31327,293 +31672,88 @@ var TokenValidator = class {
     let completed = 0;
     for (let i = 0; i < tokens.length; i += batchSize) {
       const batch = tokens.slice(i, i + batchSize);
-      const batchResults = await Promise.allSettled(
-        batch.map(async (token) => {
-          try {
-            const result = await this.validateToken(token);
-            return { token, result };
-          } catch (err) {
-            return {
-              token,
-              result: {
-                isValid: false,
-                reason: err instanceof Error ? err.message : String(err)
-              }
-            };
-          }
-        })
+      const batchResults = await Promise.all(
+        batch.map(async (token) => ({ token, result: await this.validateToken(token) }))
       );
-      for (const settledResult of batchResults) {
+      for (const { token, result } of batchResults) {
         completed++;
-        if (settledResult.status === "fulfilled") {
-          const { token, result } = settledResult.value;
-          if (result.isValid) {
-            validTokens.push(token);
-          } else {
-            issues.push({
-              tokenId: token.id,
-              reason: result.reason || "Unknown validation error",
-              recoverable: false
-            });
-          }
+        if (result.isValid) {
+          validTokens.push(token);
         } else {
           issues.push({
-            tokenId: batch[batchResults.indexOf(settledResult)]?.id || "unknown",
-            reason: String(settledResult.reason),
+            tokenId: stateIdOf(token),
+            reason: result.reason || "Unknown validation error",
             recoverable: false
           });
         }
       }
-      if (options?.onProgress) {
-        options.onProgress(completed, total);
-      }
+      options?.onProgress?.(completed, total);
     }
     return { validTokens, issues };
   }
-  /**
-   * Validate a single token
-   */
+  /** Validate a single token's structural integrity against the trust base. */
   async validateToken(token) {
-    if (!token.sdkData) {
-      return {
-        isValid: false,
-        reason: "Token has no SDK data"
-      };
-    }
-    let txfToken;
-    try {
-      txfToken = JSON.parse(token.sdkData);
-    } catch {
-      return {
-        isValid: false,
-        reason: "Failed to parse token SDK data as JSON"
-      };
-    }
-    if (!this.hasValidTxfStructure(txfToken)) {
-      return {
-        isValid: false,
-        reason: "Token data missing required TXF fields (genesis, state)"
-      };
-    }
-    const uncommitted = this.getUncommittedTransactions(txfToken);
-    if (uncommitted.length > 0) {
-      return {
-        isValid: false,
-        reason: `${uncommitted.length} uncommitted transaction(s)`
-      };
-    }
-    if (this.trustBase && !this.skipVerification) {
-      try {
-        const verificationResult = await this.verifyWithSdk(txfToken);
-        if (!verificationResult.success) {
-          return {
-            isValid: false,
-            reason: verificationResult.error || "SDK verification failed"
-          };
-        }
-      } catch (err) {
-        logger.warn("Validation", "SDK verification skipped:", err instanceof Error ? err.message : err);
-      }
-    }
-    return { isValid: true };
+    const result = await this.engine.verify(token);
+    return result.ok ? { isValid: true } : { isValid: false, reason: result.reason || "Verification failed" };
   }
   /**
-   * Check if a token state is spent on the aggregator
+   * Whether a token's current state has been spent on the network. Cached:
+   * SPENT permanently, UNSPENT for `UNSPENT_CACHE_TTL_MS`. Graceful — an engine
+   * error is treated as unspent (and not cached).
    */
-  async isTokenStateSpent(tokenId, stateHash, publicKey) {
-    if (!this.aggregatorClient) {
-      return false;
-    }
-    const cacheKey = `${tokenId}:${stateHash}:${publicKey}`;
-    const cached = this.spentStateCache.get(cacheKey);
-    if (cached !== void 0) {
-      if (cached.isSpent) {
-        return true;
-      }
-      if (Date.now() - cached.timestamp < this.UNSPENT_CACHE_TTL_MS) {
-        return false;
-      }
+  async isSpent(token) {
+    const key = stateIdOf(token);
+    const cached = this.spentStateCache.get(key);
+    if (cached) {
+      if (cached.isSpent) return true;
+      if (Date.now() - cached.timestamp < this.UNSPENT_CACHE_TTL_MS) return false;
     }
+    let spent;
     try {
-      const { RequestId } = await import("@unicitylabs/state-transition-sdk/lib/api/RequestId");
-      const { DataHash } = await import("@unicitylabs/state-transition-sdk/lib/hash/DataHash");
-      const pubKeyBytes = Buffer.from(publicKey, "hex");
-      const stateHashObj = DataHash.fromJSON(stateHash);
-      const requestId2 = await RequestId.create(pubKeyBytes, stateHashObj);
-      const response = await this.aggregatorClient.getInclusionProof(requestId2);
-      let isSpent = false;
-      if (response.inclusionProof) {
-        const proof = response.inclusionProof;
-        const pathResult = await proof.merkleTreePath.verify(
-          requestId2.toBitString().toBigInt()
-        );
-        if (pathResult.isPathValid && pathResult.isPathIncluded && proof.authenticator !== null) {
-          isSpent = true;
-        }
-      }
-      this.spentStateCache.set(cacheKey, {
-        isSpent,
-        timestamp: Date.now()
-      });
-      return isSpent;
+      spent = await this.engine.isSpent(token);
     } catch (err) {
-      logger.warn("Validation", "Error checking token state:", err);
+      logger.warn("Validation", "Error checking spent status:", err);
       return false;
     }
+    this.spentStateCache.set(key, { isSpent: spent, timestamp: Date.now() });
+    return spent;
   }
-  /**
-   * Check which tokens are spent using SDK Token object to calculate state hash.
-   *
-   * Follows the same approach as the Sphere webgui TokenValidationService:
-   * 1. Parse TXF using SDK's Token.fromJSON()
-   * 2. Calculate CURRENT state hash via sdkToken.state.calculateHash()
-   * 3. Create RequestId via RequestId.create(walletPubKey, calculatedHash)
-   *
-   * Uses wallet's own pubkey (not source state predicate key) because "spent" means
-   * the CURRENT OWNER committed this state. Using the source state key would falsely
-   * detect received tokens as "spent" (sender's commitment matches source state).
-   */
-  async checkSpentTokens(tokens, publicKey, options) {
+  /** Check which of the given tokens are spent, returning them by per-state id. */
+  async checkSpentTokens(tokens, options) {
     const spentTokens = [];
     const errors = [];
-    if (!this.aggregatorClient) {
-      errors.push("Aggregator client not available");
-      return { spentTokens, errors };
-    }
     const batchSize = options?.batchSize ?? 3;
     const total = tokens.length;
     let completed = 0;
-    const { Token: SdkToken5 } = await import("@unicitylabs/state-transition-sdk/lib/token/Token");
-    const { RequestId } = await import("@unicitylabs/state-transition-sdk/lib/api/RequestId");
-    const pubKeyBytes = Buffer.from(publicKey, "hex");
     for (let i = 0; i < tokens.length; i += batchSize) {
       const batch = tokens.slice(i, i + batchSize);
       const batchResults = await Promise.allSettled(
-        batch.map(async (token) => {
-          try {
-            const txf = tokenToTxf(token);
-            if (!txf) {
-              return { tokenId: token.id, localId: token.id, stateHash: "", spent: false, error: "Invalid TXF" };
-            }
-            const tokenId = txf.genesis?.data?.tokenId || token.id;
-            const sdkToken = await SdkToken5.fromJSON(txf);
-            const calculatedStateHash = await sdkToken.state.calculateHash();
-            const calculatedStateHashStr = calculatedStateHash.toJSON();
-            const cacheKey = `${tokenId}:${calculatedStateHashStr}:${publicKey}`;
-            const cached = this.spentStateCache.get(cacheKey);
-            if (cached !== void 0) {
-              if (cached.isSpent) {
-                return { tokenId, localId: token.id, stateHash: calculatedStateHashStr, spent: true };
-              }
-              if (Date.now() - cached.timestamp < this.UNSPENT_CACHE_TTL_MS) {
-                return { tokenId, localId: token.id, stateHash: calculatedStateHashStr, spent: false };
-              }
-            }
-            const { DataHash } = await import("@unicitylabs/state-transition-sdk/lib/hash/DataHash");
-            const stateHashObj = DataHash.fromJSON(calculatedStateHashStr);
-            const requestId2 = await RequestId.create(pubKeyBytes, stateHashObj);
-            const response = await this.aggregatorClient.getInclusionProof(requestId2);
-            let isSpent = false;
-            if (response.inclusionProof) {
-              const proof = response.inclusionProof;
-              const pathResult = await proof.merkleTreePath.verify(
-                requestId2.toBitString().toBigInt()
-              );
-              if (pathResult.isPathValid && pathResult.isPathIncluded && proof.authenticator !== null) {
-                isSpent = true;
-              }
-            }
-            this.spentStateCache.set(cacheKey, {
-              isSpent,
-              timestamp: Date.now()
-            });
-            return { tokenId, localId: token.id, stateHash: calculatedStateHashStr, spent: isSpent };
-          } catch (err) {
-            return {
-              tokenId: token.id,
-              localId: token.id,
-              stateHash: "",
-              spent: false,
-              error: err instanceof Error ? err.message : String(err)
-            };
-          }
-        })
+        batch.map(async (token) => ({ stateId: stateIdOf(token), spent: await this.isSpent(token) }))
       );
       for (const result of batchResults) {
         completed++;
         if (result.status === "fulfilled") {
-          if (result.value.spent) {
-            spentTokens.push({
-              tokenId: result.value.tokenId,
-              localId: result.value.localId,
-              stateHash: result.value.stateHash
-            });
-          }
-          if (result.value.error) {
-            errors.push(`Token ${result.value.tokenId}: ${result.value.error}`);
-          }
+          if (result.value.spent) spentTokens.push({ stateId: result.value.stateId });
         } else {
           errors.push(String(result.reason));
         }
       }
-      if (options?.onProgress) {
-        options.onProgress(completed, total);
-      }
+      options?.onProgress?.(completed, total);
     }
     return { spentTokens, errors };
   }
-  /**
-   * Clear the spent state cache
-   */
+  /** Clear the spent-status cache. */
   clearSpentStateCache() {
     this.spentStateCache.clear();
   }
-  // =============================================================================
-  // Private Helpers
-  // =============================================================================
-  hasValidTxfStructure(obj) {
-    if (!obj || typeof obj !== "object") return false;
-    const txf = obj;
-    return !!(txf.genesis && typeof txf.genesis === "object" && txf.state && typeof txf.state === "object");
-  }
-  getUncommittedTransactions(txfToken) {
-    const txf = txfToken;
-    const transactions = txf.transactions;
-    if (!transactions || !Array.isArray(transactions)) {
-      return [];
-    }
-    return transactions.filter((tx) => tx.inclusionProof === null);
-  }
-  async verifyWithSdk(txfToken) {
-    try {
-      const { Token: Token5 } = await import("@unicitylabs/state-transition-sdk/lib/token/Token");
-      const sdkToken = await Token5.fromJSON(txfToken);
-      if (!this.trustBase) {
-        return { success: true };
-      }
-      const result = await sdkToken.verify(this.trustBase);
-      if (!result.isSuccessful) {
-        return {
-          success: false,
-          error: String(result) || "Verification failed"
-        };
-      }
-      return { success: true };
-    } catch (err) {
-      return {
-        success: false,
-        error: err instanceof Error ? err.message : String(err)
-      };
-    }
-  }
 };
-function createTokenValidator(options) {
-  return new TokenValidator(options);
+function createTokenValidator(engine) {
+  return new TokenValidator(engine);
 }
 
 // index.ts
+var import_nostr_js_sdk5 = require("@unicitylabs/nostr-js-sdk");
 var import_nostr_js_sdk6 = require("@unicitylabs/nostr-js-sdk");
-var import_nostr_js_sdk7 = require("@unicitylabs/nostr-js-sdk");
 
 // price/CoinGeckoPriceProvider.ts
 init_logger();