@wishknish/knishio-client-js 0.8.2 → 0.9.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wishknish/knishio-client-js",
-  "version": "0.8.2",
+  "version": "0.9.2",
   "type": "module",
   "productName": "Knish.IO Javascript SDK Client",
   "description": "JavaScript implementation of the Knish.IO SDK to consume Knish.IO GraphQL APIs.",
@@ -65,22 +65,18 @@
     "wonka": "^6.3.5"
   },
   "devDependencies": {
-    "@jest/globals": "^29.7.0",
+    "@jest/globals": "^30.4.1",
     "@rollup/plugin-babel": "^6.1.0",
     "@rollup/plugin-commonjs": "^28.0.9",
     "@rollup/plugin-node-resolve": "^16.0.3",
+    "@swc/core": "^1.15.43",
+    "@swc/jest": "^0.2.39",
     "buffer": "^6.0.3",
-    "esbuild-jest": "^0.5.0",
-    "eslint": "^8.57.1",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-n": "^16.6.2",
-    "eslint-plugin-promise": "^6.6.0",
-    "eslint-plugin-vue": "^9.33.0",
-    "esmock": "^2.7.3",
-    "jest": "^29.7.0",
+    "eslint": "^9.39.0",
+    "jest": "^30.4.2",
+    "neostandard": "^0.13.0",
     "rollup": "^4.57.1",
-    "vite": "^6.4.1"
+    "vite": "^7.3.5"
   },
   "browserslist": [
     "> 1%",
@@ -89,7 +85,7 @@
   ],
   "scripts": {
     "build": "vite build --config build/vite.config.mjs",
-    "lint": "eslint --ext .js src",
+    "lint": "eslint src",
     "test": "jest",
     "test:coverage": "jest --coverage",
     "selftest": "npm run build && node tests/scripts/self-test.js",

package/src/KnishIOClient.js

@@ -88,7 +88,6 @@ import ActiveWalletSubscribe from './subscribe/ActiveWalletSubscribe.js'
 import ActiveSessionSubscribe from './subscribe/ActiveSessionSubscribe.js'
 import MutationActiveSession from './mutation/MutationActiveSession.js'
 import QueryActiveSession from './query/QueryActiveSession.js'
-import QueryUserActivity from './query/QueryUserActivity.js'
 import QueryToken from './query/QueryToken.js'
 import BatchIdException from './exception/BatchIdException.js'
 import AuthorizationRejectedException from './exception/AuthorizationRejectedException.js'
@@ -1216,50 +1215,6 @@ export default class KnishIOClient {
     })
   }
 
-  /**
-   * Queries user activity based on the provided parameters.
-   *
-   * @param {string} bundleHash - The bundle hash.
-   * @param {string} metaType - The meta type.
-   * @param {string} metaId - The meta ID.
-   * @param {string} ipAddress - The IP address.
-   * @param {string} browser - The browser.
-   * @param {string} osCpu - The operating system and CPU.
-   * @param {string} resolution - The screen resolution.
-   * @param {string} timeZone - The time zone.
-   * @param {string} countBy - The count by parameter.
-   * @param {string} interval - The interval parameter.
-   *
-   * @returns {Promise<ResponseQueryUserActivity>} The result of the query.
-   */
-  async queryUserActivity ({
-    bundleHash,
-    metaType,
-    metaId,
-    ipAddress,
-    browser,
-    osCpu,
-    resolution,
-    timeZone,
-    countBy,
-    interval
-  }) {
-    const query = this.createQuery(QueryUserActivity)
-
-    return await this.executeQuery(query, {
-      bundleHash,
-      metaType,
-      metaId,
-      ipAddress,
-      browser,
-      osCpu,
-      resolution,
-      timeZone,
-      countBy,
-      interval
-    })
-  }
-
   /**
    * Builds and executes a molecule to declare an active session for the given MetaType
    *
@@ -1966,6 +1921,109 @@ export default class KnishIOClient {
     return await this.executeQuery(query)
   }
 
+  /**
+   * Transfers tokens from one source wallet to MULTIPLE recipients in a single molecule.
+   *
+   * One molecule funds N recipients (WP line 544: "utilizing the sender's Wallet to fund multiple
+   * recipients with one transaction"). Each recipient receives its own amount and, for stackable
+   * tokens, its own subset of token units. The source is fully drained and the unsent change
+   * returns via the remainder atom (UTXO), so the V-atoms conserve. Single-recipient transfers
+   * should keep using transferToken(); this is its N-recipient generalization.
+   *
+   * @param {Object} options - The transfer options.
+   * @param {string} options.token - The token to transfer.
+   * @param {Array} options.recipients - [{ bundleHash, amount?, units?, batchId? }] per recipient.
+   * @param {Object} [options.sourceWallet=null] - The source wallet; queried if not provided.
+   *
+   * @returns {Promise} - A Promise that resolves to the transaction result.
+   *
+   * @throws {StackableUnitAmountException} - If a recipient provides both amount and units.
+   * @throws {TransferBalanceException} - If the source wallet does not have enough balance.
+   */
+  async transferTokens ({
+    token,
+    recipients,
+    sourceWallet = null
+  }) {
+    // Per-recipient amount: units.length for stackable, else the explicit amount
+    const amounts = recipients.map(recipient => {
+      const units = recipient.units || []
+      if (units.length > 0) {
+        // Can't move stackable units AND provide amount
+        if (recipient.amount > 0) {
+          throw new StackableUnitAmountException()
+        }
+        return units.length
+      }
+      return recipient.amount || 0
+    })
+    const total = amounts.reduce((sum, value) => sum + value, 0)
+
+    // Get a source wallet (loads its token units)
+    if (sourceWallet === null) {
+      sourceWallet = await this.querySourceWallet({
+        token,
+        amount: total
+      })
+    }
+
+    // Do you have enough tokens?
+    if (sourceWallet === null || Decimal.cmp(sourceWallet.balance, total) < 0) {
+      throw new TransferBalanceException()
+    }
+
+    // Build a shadow recipient wallet per recipient, each with its own batch ID
+    const recipientWallets = recipients.map(recipient => {
+      const recipientWallet = Wallet.create({
+        bundle: recipient.bundleHash,
+        token
+      })
+
+      // Compute the batch ID for the recipient (typically used by stackable tokens)
+      if (recipient.batchId !== undefined && recipient.batchId !== null) {
+        recipientWallet.batchId = recipient.batchId
+      } else {
+        recipientWallet.initBatchId({
+          sourceWallet
+        })
+      }
+
+      return recipientWallet
+    })
+
+    // Create a remainder from the source wallet
+    const remainderWallet = sourceWallet.createRemainder(this.getSecret())
+
+    // --- Token units splitting (N-way): source keeps the union, each recipient its subset,
+    //     remainder the kept units
+    sourceWallet.splitUnitsMulti(
+      recipients.map(recipient => recipient.units || []),
+      recipientWallets,
+      remainderWallet
+    )
+    // ---
+
+    // Build the molecule itself
+    const molecule = await this.createMolecule({
+      sourceWallet,
+      remainderWallet
+    })
+    /**
+     * @type {MutationTransferTokens}
+     */
+    const query = await this.createMoleculeMutation({
+      mutationClass: MutationTransferTokens,
+      molecule
+    })
+
+    query.fillMoleculeMulti({
+      recipientWallets,
+      amounts
+    })
+
+    return await this.executeQuery(query)
+  }
+
   /**
    * Deposits buffer token into the source wallet.
    *
@@ -2343,7 +2401,15 @@ export default class KnishIOClient {
       molecule
     })
 
-    query.fillMolecule({ meta: { encrypt: (encrypt ? 'true' : 'false') } })
+    // PQ-transport Phase E (cycle 163): convey the AUTH source wallet's ML-KEM768 public key as a
+    // SIGNED `walletPubkey` meta on the U-atom (fillMolecule → initAuthorization → sign), so the
+    // validator can encrypt CipherHash responses back to THIS wallet (the one that decrypts them).
+    // Signed → tamper-proof. Only when present (PQ-capable wallet).
+    const authMeta = { encrypt: (encrypt ? 'true' : 'false') }
+    if (wallet.pubkey) {
+      authMeta.walletPubkey = wallet.pubkey
+    }
+    query.fillMolecule({ meta: authMeta })
     /**
      * @type {ResponseRequestAuthorization}
      */

package/src/Molecule.js

@@ -577,6 +577,11 @@ export default class Molecule {
     recipientWallet,
     amount
   }) {
+    // Canonical token transfer (incl. stackable): a UTXO-style FULL-balance debit + remainder.
+    // The source wallet is fully drained (-balance) and the change returns via the remainder atom,
+    // so the 3 V-atoms conserve (sum == 0) and the validator's stackable full-drain guard accepts.
+    // Per-unit (stackable) movement is layered by calling Wallet.splitUnits(units, remainder,
+    // recipient) BEFORE this — there is no separate partial-debit transfer mode.
     if (this.sourceWallet.balance - amount < 0) {
       throw new BalanceInsufficientException()
     }
@@ -608,54 +613,55 @@ export default class Molecule {
   }
 
   /**
-   * Creates a stackable V-isotope transfer with 3 atoms:
-   * source debit, recipient credit, remainder.
-   * Propagates batchId from source wallet.
+   * Multi-recipient value transfer (WP line 544: one molecule funds N recipients).
    *
-   * @param {Wallet} recipientWallet - wallet receiving the tokens
-   * @param {number} amount - amount to transfer
+   * Builds 1 source atom (full-balance debit, carrying the SENT union of all units) + one atom
+   * per recipient (its amount + its own units, walletBundle-bonded) + 1 remainder atom (the KEPT
+   * change). Conservation: -balance + Σ amounts + (balance - Σ amounts) == 0.
+   *
+   * Per-unit (stackable) routing is layered by calling Wallet.splitUnitsMulti(...) BEFORE this —
+   * it sets the source's tokenUnits to the union, each recipient's to its subset, and the
+   * remainder's to the kept units. The single-recipient initValue() is the N=1 special case.
+   *
+   * @param {Wallet[]} recipientWallets
+   * @param {number[]} amounts - parallel to recipientWallets
    * @return {Molecule}
    */
-  addStackableTransfer ({
-    recipientWallet,
-    amount
+  initValues ({
+    recipientWallets,
+    amounts
   }) {
-    if (amount <= 0) {
-      throw new NegativeAmountException('Molecule::addStackableTransfer() - Amount must be positive!')
-    }
+    const total = amounts.reduce((sum, value) => sum + Number(value), 0)
 
-    if (this.sourceWallet.balance - amount < 0) {
+    if (this.sourceWallet.balance - total < 0) {
       throw new BalanceInsufficientException()
     }
 
-    const batchId = this.sourceWallet.batchId || generateBatchId({})
-
-    // Source debit atom
+    // Source atom: debit the full balance (UTXO); carries the SENT union of all units
     this.addAtom(Atom.create({
       isotope: 'V',
       wallet: this.sourceWallet,
-      value: -amount,
-      batchId
+      value: -this.sourceWallet.balance
     }))
 
-    // Recipient credit atom
-    this.addAtom(Atom.create({
-      isotope: 'V',
-      wallet: recipientWallet,
-      value: amount,
-      metaType: 'walletBundle',
-      metaId: recipientWallet.bundle,
-      batchId: generateBatchId({})
-    }))
+    // One atom per recipient: its amount + its own units, bonded to the recipient bundle
+    recipientWallets.forEach((recipientWallet, index) => {
+      this.addAtom(Atom.create({
+        isotope: 'V',
+        wallet: recipientWallet,
+        value: amounts[index],
+        metaType: 'walletBundle',
+        metaId: recipientWallet.bundle
+      }))
+    })
 
-    // Remainder atom
+    // Remainder atom: the change back to the sender; carries the KEPT units
     this.addAtom(Atom.create({
       isotope: 'V',
       wallet: this.remainderWallet,
-      value: this.sourceWallet.balance - amount,
+      value: this.sourceWallet.balance - total,
       metaType: 'walletBundle',
-      metaId: this.remainderWallet.bundle,
-      batchId
+      metaId: this.remainderWallet.bundle
     }))
 
     return this

package/src/Wallet.js

@@ -398,6 +398,47 @@ export default class Wallet {
     remainderWallet.tokenUnits = remainderTokenUnits
   }
 
+  /**
+   * Split token units across MULTIPLE recipients (WP line 544).
+   *
+   * The source retains the SENT union (all units leaving), each recipient gets its own subset,
+   * and the remainder gets the KEPT units (those not assigned to any recipient). Mirrors
+   * splitUnits() but N-way: the source's tokenUnits become the union (not a single recipient's
+   * subset) so the source atom carries the full SENT set the validator reads as the authority.
+   *
+   * @param {array[]} recipientUnitLists - array of unit-id arrays, parallel to recipientWallets
+   * @param {Wallet[]} recipientWallets
+   * @param {Wallet} remainderWallet
+   */
+  splitUnitsMulti (
+    recipientUnitLists,
+    recipientWallets,
+    remainderWallet
+  ) {
+    // The union of all unit ids leaving the source
+    const sentIds = new Set()
+    recipientUnitLists.forEach(unitList => {
+      unitList.forEach(id => sentIds.add(id))
+    })
+
+    // Nothing to split (fungible transfer) — leave token units untouched
+    if (sentIds.size === 0) {
+      return
+    }
+
+    // Each recipient gets its own subset of the source's token units
+    recipientWallets.forEach((recipientWallet, index) => {
+      const ids = recipientUnitLists[index]
+      recipientWallet.tokenUnits = this.tokenUnits.filter(tokenUnit => ids.includes(tokenUnit.id))
+    })
+
+    // The remainder keeps everything not sent to any recipient
+    remainderWallet.tokenUnits = this.tokenUnits.filter(tokenUnit => !sentIds.has(tokenUnit.id))
+
+    // The source carries the SENT union (the ownership authority the validator reads)
+    this.tokenUnits = this.tokenUnits.filter(tokenUnit => sentIds.has(tokenUnit.id))
+  }
+
   /**
    * Create a remainder wallet from the source one
    *
@@ -445,6 +486,18 @@ export default class Wallet {
     const messageString = JSON.stringify(message)
     const messageUint8 = new TextEncoder().encode(messageString)
     const deserializedPubkey = this.deserializeKey(recipientPubkey)
+    // ML-KEM-768 public keys are exactly 1184 bytes. A wrong-length key here almost always means the
+    // node did not advertise an ML-KEM public key in its auth `key` field (e.g. a validator predating
+    // the PQ-transport build). Fail with an actionable message rather than the crypto lib's cryptic
+    // `"publicKey" expected Uint8Array of length 1184, got length=N` assertion.
+    const ML_KEM_768_PUBLIC_KEY_BYTES = 1184
+    if (deserializedPubkey.length !== ML_KEM_768_PUBLIC_KEY_BYTES) {
+      throw new Error(
+        `KnishIO: cannot ML-KEM-encrypt — recipient public key is ${deserializedPubkey.length} bytes, ` +
+        `expected ${ML_KEM_768_PUBLIC_KEY_BYTES} (ML-KEM-768). The node likely did not advertise an ML-KEM ` +
+        'public key (upgrade the validator to a PQ-transport build), or authenticate with { encrypt: false }.'
+      )
+    }
     const { cipherText, sharedSecret } = MlKEM768.encapsulate(deserializedPubkey)
     const encryptedMessage = await this.encryptWithSharedSecret(messageUint8, sharedSecret)
     return {
@@ -454,6 +507,17 @@ export default class Wallet {
   }
 
   async decryptMessage (encryptedData) {
+    const decryptedString = await this._mlkemDecryptToString(encryptedData)
+    return decryptedString === null ? null : JSON.parse(decryptedString)
+  }
+
+  /**
+   * ML-KEM768 decapsulate + AES-256-GCM decrypt → the RAW decrypted UTF-8 string
+   * (no JSON.parse). Shared by {@link decryptMessage} (which JSON.parses the result)
+   * and the PQ CipherHash transport ({@link decryptMyMessageML768}, which needs the raw
+   * response JSON text). PQ-transport Phase E (cycle 163).
+   */
+  async _mlkemDecryptToString (encryptedData) {
     const { cipherText, encryptedMessage } = encryptedData
 
     let sharedSecret
@@ -486,9 +550,8 @@ export default class Wallet {
       return null
     }
 
-    let decryptedString
     try {
-      decryptedString = new TextDecoder().decode(decryptedUint8)
+      return new TextDecoder().decode(decryptedUint8)
     } catch (e) {
       console.warn('Wallet::decryptMessage() - Decoding failed', e)
       console.info('Wallet::decryptMessage() - my public key', this.pubkey)
@@ -497,8 +560,40 @@ export default class Wallet {
       console.info('Wallet::decryptMessage() - decrypted Uint8Array', decryptedUint8)
       return null
     }
+  }
+
+  /**
+   * Multi-recipient map key for a public key: `Base64_standard(SHAKE256(pubkey_utf8, 8 bytes))`
+   * — matches the validator's `hash_share` and the other SDKs' `hashShare`/`shortHash`.
+   * `shake256(pubkey, 64)` = 64 bits = 8 bytes, hex; hex-decode → standard base64. PQ Phase E.
+   */
+  hashShare (pubkey) {
+    const hex = shake256(pubkey, 64)
+    const bytes = Uint8Array.from(hex.match(/.{2}/g).map(b => parseInt(b, 16)))
+    return this.serializeKey(bytes)
+  }
 
-    return JSON.parse(decryptedString)
+  /**
+   * Post-quantum (ML-KEM768) `CipherHash` request envelope: a stringified single-recipient
+   * map `{ "<hashShare(recipientPubkey)>": {cipherText, encryptedMessage} }` (object-valued,
+   * via {@link encryptMessage}). Matches the Rust validator's CipherHash handler. PQ Phase E.
+   */
+  async encryptStringML768 (message, recipientPubkey) {
+    const envelope = await this.encryptMessage(message, recipientPubkey)
+    return JSON.stringify({ [this.hashShare(recipientPubkey)]: envelope })
+  }
+
+  /**
+   * Decrypt a `CipherHash` response map addressed to THIS wallet's ML-KEM pubkey
+   * (`hashShare(this.pubkey)`) → the RAW decrypted GraphQL response JSON text (NOT JSON.parsed;
+   * it replaces the HTTP response body for the normal parser). `null` if no entry / decrypt fails.
+   */
+  async decryptMyMessageML768 (map) {
+    const envelope = map[this.hashShare(this.pubkey)]
+    if (!envelope) {
+      return null
+    }
+    return this._mlkemDecryptToString(envelope)
   }
 
   async encryptWithSharedSecret (message, sharedSecret) {

package/src/index.js

@@ -91,7 +91,6 @@ import QueryMetaTypeViaAtom from './query/QueryMetaTypeViaAtom.js'
 import QueryMetaTypeViaMolecule from './query/QueryMetaTypeViaMolecule.js'
 import QueryPolicy from './query/QueryPolicy.js'
 import QueryToken from './query/QueryToken.js'
-import QueryUserActivity from './query/QueryUserActivity.js'
 import QueryWalletBundle from './query/QueryWalletBundle.js'
 import QueryWalletList from './query/QueryWalletList.js'
 
@@ -142,7 +141,6 @@ import ResponsePeering from './response/ResponsePeering.js'
 import ResponsePolicy from './response/ResponsePolicy.js'
 import ResponseProposeMolecule from './response/ResponseProposeMolecule.js'
 import ResponseQueryActiveSession from './response/ResponseQueryActiveSession.js'
-import ResponseQueryUserActivity from './response/ResponseQueryUserActivity.js'
 import ResponseRequestAuthorization from './response/ResponseRequestAuthorization.js'
 import ResponseRequestAuthorizationGuest from './response/ResponseRequestAuthorizationGuest.js'
 import ResponseRequestTokens from './response/ResponseRequestTokens.js'
@@ -253,7 +251,6 @@ export {
   QueryMetaTypeViaMolecule,
   QueryPolicy,
   QueryToken,
-  QueryUserActivity,
   QueryWalletBundle,
   QueryWalletList,
 
@@ -298,7 +295,6 @@ export {
   ResponsePolicy,
   ResponseProposeMolecule,
   ResponseQueryActiveSession,
-  ResponseQueryUserActivity,
   ResponseRequestAuthorization,
   ResponseRequestAuthorizationGuest,
   ResponseRequestTokens,

package/src/libraries/urql/UrqlClientWrapper.js

@@ -7,6 +7,25 @@ import {
 import { createClient as createWSClient } from 'graphql-ws'
 import { pipe, map, subscribe } from 'wonka'
 
+// PQ-transport Phase E (cycle 163): the post-quantum CipherHash wrapper query. The validator
+// intercepts the `CipherHash` op, decrypts `$Hash`, executes the inner request, and returns the
+// encrypted response in `{ data: { CipherHash: { hash } } }`.
+const CIPHER_HASH_QUERY = 'query ( $Hash: String! ) { CipherHash ( Hash: $Hash ) { hash } }'
+
+/**
+ * Light parse of a GraphQL request body's operation type + root field name, for the CipherHash
+ * bypass decision (no full GraphQL parse needed). Operation type = the first query/mutation/
+ * subscription keyword (default 'query' for an anonymous `{ ... }`); root field = the first
+ * identifier inside the top-level selection set.
+ */
+function parseOperation (query) {
+  const typeMatch = (query || '').match(/\b(query|mutation|subscription)\b/i)
+  const type = typeMatch ? typeMatch[1].toLowerCase() : 'query'
+  const braceIdx = (query || '').indexOf('{')
+  const nameMatch = braceIdx >= 0 ? query.slice(braceIdx + 1).match(/[A-Za-z_][A-Za-z0-9_]*/) : null
+  return { type, name: nameMatch ? nameMatch[0] : '' }
+}
+
 class UrqlClientWrapper {
   constructor ({ serverUri, socket = null, encrypt = false }) {
     this.$__client = this.createUrqlClient({ serverUri, socket, encrypt })
@@ -44,6 +63,10 @@ class UrqlClientWrapper {
     return createClient({
       url: serverUri,
       exchanges,
+      // PQ-transport Phase E: when encryption is on, route fetch through the CipherHash
+      // wrapper (encrypt the request body to the validator's ML-KEM pubkey, decrypt the
+      // response). Undefined → urql uses the global fetch (plaintext).
+      ...(encrypt ? { fetch: (input, init) => this.cipherFetch(input, init) } : {}),
       fetchOptions: () => ({
         headers: {
           'X-Auth-Token': this.$__authToken
@@ -54,6 +77,71 @@ class UrqlClientWrapper {
     })
   }
 
+  /**
+   * Whether an outgoing GraphQL request body should be wrapped in CipherHash. Bypass (plaintext):
+   * introspection `__schema`, `ContinuId`, the `AccessToken` mutation, and the U-isotope
+   * `ProposeMolecule` (auth bootstrap — the key exchange itself can't be encrypted). Mirrors the
+   * Kotlin/validator bypass set.
+   */
+  shouldEncrypt (body) {
+    let parsed
+    try {
+      parsed = JSON.parse(body)
+    } catch (e) {
+      return false
+    }
+    const { type, name } = parseOperation(parsed.query)
+    if (type === 'query' && (name === '__schema' || name === 'ContinuId')) return false
+    if (type === 'mutation' && name === 'AccessToken') return false
+    if (type === 'mutation' && name === 'ProposeMolecule') {
+      const isotope = parsed.variables && parsed.variables.molecule &&
+        parsed.variables.molecule.atoms && parsed.variables.molecule.atoms[0] &&
+        parsed.variables.molecule.atoms[0].isotope
+      if (isotope === 'U') return false
+    }
+    return true
+  }
+
+  /**
+   * Custom `fetch` that wraps a GraphQL request in the ML-KEM CipherHash envelope and decrypts the
+   * response (PQ-transport Phase E). Operates on the raw POST body (mirrors Kotlin's
+   * encryptBody/decryptBody). Reads the CURRENT client wallet + validator pubkey from auth.
+   */
+  async cipherFetch (input, init) {
+    const wallet = this.getWallet()
+    const serverPubkey = this.getPubKey()
+    let encryptedRequest = false
+    let requestInit = init
+
+    if (wallet && serverPubkey && init && typeof init.body === 'string' && this.shouldEncrypt(init.body)) {
+      const hashVar = await wallet.encryptStringML768(init.body, serverPubkey)
+      requestInit = { ...init, body: JSON.stringify({ query: CIPHER_HASH_QUERY, variables: { Hash: hashVar } }) }
+      encryptedRequest = true
+    }
+
+    const response = await fetch(input, requestInit)
+    if (!encryptedRequest) {
+      return response
+    }
+
+    // Decrypt the CipherHash response back to the inner GraphQL response JSON.
+    const text = await response.text()
+    const init2 = { status: response.status, statusText: response.statusText, headers: response.headers }
+    let parsed
+    try {
+      parsed = JSON.parse(text)
+    } catch (e) {
+      return new Response(text, init2)
+    }
+    const hash = parsed && parsed.data && parsed.data.CipherHash && parsed.data.CipherHash.hash
+    if (typeof hash !== 'string') {
+      // Plaintext (e.g. a validator-side error response) — pass through unchanged.
+      return new Response(text, init2)
+    }
+    const decrypted = await wallet.decryptMyMessageML768(JSON.parse(hash))
+    return new Response(decrypted != null ? decrypted : text, init2)
+  }
+
   setAuthData ({ token, pubkey, wallet }) {
     this.$__authToken = token
     this.$__pubkey = pubkey

package/src/mutation/MutationTransferTokens.js

@@ -70,6 +70,24 @@ export default class MutationTransferTokens extends MutationProposeMolecule {
     this.$__molecule.check(this.$__molecule.sourceWallet)
   }
 
+  /**
+   * Fills the Molecule for a MULTI-recipient transfer (WP line 544)
+   *
+   * @param {Wallet[]} recipientWallets
+   * @param {number[]} amounts - parallel to recipientWallets
+   */
+  fillMoleculeMulti ({
+    recipientWallets,
+    amounts
+  }) {
+    this.$__molecule.initValues({
+      recipientWallets,
+      amounts
+    })
+    this.$__molecule.sign({})
+    this.$__molecule.check(this.$__molecule.sourceWallet)
+  }
+
   /**
    * Builds a Response object out of a JSON string
    *