@wishknish/knishio-client-ts 0.8.3 → 0.9.0

package/dist/index.iife.js

@@ -5053,9 +5053,19 @@ var KnishIO = (function (exports) {
   });
 
   // src/exception/StackableUnitDecimalsException.ts
+  var StackableUnitDecimalsException, StackableUnitDecimalsException_default;
   var init_StackableUnitDecimalsException = __esm({
     "src/exception/StackableUnitDecimalsException.ts"() {
       init_BaseException();
+      StackableUnitDecimalsException = class extends exports.BaseException {
+        /**
+         * Constructor using proper error type
+         */
+        constructor(message = "Stackable tokens with unit IDs cannot have decimal places!") {
+          super("STACKABLE_UNIT_DECIMALS_ERROR", message);
+        }
+      };
+      StackableUnitDecimalsException_default = StackableUnitDecimalsException;
     }
   });
 
@@ -21334,9 +21344,6 @@ ${operationTypes.join("\n")}
     }
   }
   function generateBundleHash(secret, _source = null) {
-    if (!secret || secret.length === 0) {
-      throw new Error("Secret is required for bundle hash generation");
-    }
     const hash = shake256(secret, CRYPTO_CONSTANTS.BUNDLE_HASH_LENGTH * 4);
     return hash;
   }
@@ -22749,8 +22756,7 @@ ${operationTypes.join("\n")}
     "Batch",
     "ActiveSession",
     "Policy",
-    "Token",
-    "UserActivity"
+    "Token"
   ];
   function createLookup(values) {
     return values.reduce((acc, value2) => {
@@ -23832,6 +23838,29 @@ ${operationTypes.join("\n")}
       }
       remainderWallet.tokenUnits = remainderTokenUnits;
     }
+    /**
+     * Split token units across MULTIPLE recipients (N-way sibling of splitUnits).
+     *
+     * The source retains the SENT union (all units leaving), each recipient gets its own
+     * subset, and the remainder keeps the KEPT units (those not assigned to any recipient).
+     * recipientUnitLists is parallel to recipientWallets. No-op when no units are sent.
+     *
+     * @param recipientUnitLists - per-recipient arrays of token unit IDs (parallel to recipientWallets)
+     * @param recipientWallets - destination wallets
+     * @param remainderWallet - wallet to receive the KEPT units
+     */
+    splitUnitsMulti(recipientUnitLists, recipientWallets, remainderWallet) {
+      const sentIds = new Set(recipientUnitLists.flat());
+      if (sentIds.size === 0) {
+        return;
+      }
+      recipientWallets.forEach((recipientWallet, i4) => {
+        const ids = recipientUnitLists[i4] ?? [];
+        recipientWallet.tokenUnits = this.tokenUnits.filter((tokenUnit) => ids.includes(tokenUnit.id));
+      });
+      remainderWallet.tokenUnits = this.tokenUnits.filter((tokenUnit) => !sentIds.has(tokenUnit.id));
+      this.tokenUnits = this.tokenUnits.filter((tokenUnit) => sentIds.has(tokenUnit.id));
+    }
     /**
      * Get token units data
      * Stub for compatibility
@@ -23878,6 +23907,15 @@ ${operationTypes.join("\n")}
       };
     }
     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.
+     */
+    async _mlkemDecryptToString(encryptedData) {
       const { cipherText, encryptedMessage } = encryptedData;
       let sharedSecret;
       try {
@@ -23906,9 +23944,8 @@ ${operationTypes.join("\n")}
         console.info("Wallet::decryptMessage() - deserialized encrypted message", deserializedEncryptedMessage);
         return null;
       }
-      let decryptedString;
       try {
-        decryptedString = new TextDecoder().decode(decryptedUint8);
+        return new TextDecoder().decode(decryptedUint8);
       } catch (e4) {
         console.warn("Wallet::decryptMessage() - Decoding failed", e4);
         console.info("Wallet::decryptMessage() - my public key", this.pubkey);
@@ -23917,7 +23954,40 @@ ${operationTypes.join("\n")}
         console.info("Wallet::decryptMessage() - decrypted Uint8Array", decryptedUint8);
         return null;
       }
-      return JSON.parse(decryptedString);
+    }
+    /**
+     * Canonical cross-SDK hashShare for a public key: standard base64 of SHAKE256(pubkey_utf8, 8 bytes)
+     * — byte-matches the validator's hash_share and the JS/Kotlin/PHP hashShare. `shake256(pubkey, 64)`
+     * = 64 bits = 8 bytes (hex) → hex-decode → standard base64 via serializeKey. PQ-transport Phase E.
+     */
+    hashShare(pubkey) {
+      const hex = shake256(pubkey, 64);
+      const bytes = new Uint8Array(hex.length / 2);
+      for (let i4 = 0; i4 < bytes.length; i4++) {
+        bytes[i4] = parseInt(hex.substr(i4 * 2, 2), 16);
+      }
+      return this.serializeKey(bytes);
+    }
+    /**
+     * 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-transport 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(map2) {
+      const envelope = map2[this.hashShare(this.pubkey)];
+      if (!envelope) {
+        return null;
+      }
+      return this._mlkemDecryptToString(envelope);
     }
     // =============================================================================
     // SYMMETRIC ENCRYPTION HELPERS (AES-GCM with shared secret)
@@ -25220,6 +25290,46 @@ ${operationTypes.join("\n")}
       }));
       return this;
     }
+    /**
+     * Initialize a MULTI-recipient V-type molecule: one source debits its FULL balance to fund
+     * N recipients (each its own amount + stackable units) plus a remainder back to the sender.
+     * Multi-recipient sibling of initValue (WP line 544: fund multiple recipients with one
+     * transaction). recipientWallets is parallel to amounts.
+     */
+    initValues({
+      recipientWallets,
+      amounts
+    }) {
+      if (!this.sourceWallet) {
+        throw new Error("Source wallet required for value transfer");
+      }
+      const total = amounts.reduce((sum, amount) => sum + amount, 0);
+      if (Number(this.sourceWallet.balance) - total < 0) {
+        throw new BalanceInsufficientException();
+      }
+      this.addAtom(Atom.create({
+        isotope: "V",
+        wallet: this.sourceWallet,
+        value: -Number(this.sourceWallet.balance)
+      }));
+      recipientWallets.forEach((recipientWallet, i4) => {
+        this.addAtom(Atom.create({
+          isotope: "V",
+          wallet: recipientWallet,
+          value: amounts[i4],
+          metaType: "walletBundle",
+          metaId: recipientWallet.bundle
+        }));
+      });
+      this.addAtom(Atom.create({
+        isotope: "V",
+        wallet: this.remainderWallet,
+        value: Number(this.sourceWallet.balance) - total,
+        metaType: "walletBundle",
+        metaId: this.remainderWallet.bundle
+      }));
+      return this;
+    }
     /**
      * Sign the molecule with one-time signature
      * Matches JavaScript SDK sign method
@@ -25977,7 +26087,7 @@ ${operationTypes.join("\n")}
      * @param debug Enable debug logging
      * @returns 0 if equal, 1 if value1 > value2, -1 if value1 < value2
      */
-    static cmp(value1, value2, debug = false) {
+    static cmp(value1, value2, _debug = false) {
       const val1 = _Decimal.val(value1) * MULTIPLIER;
       const val2 = _Decimal.val(value2) * MULTIPLIER;
       if (Math.abs(val1 - val2) < 1) {
@@ -28418,6 +28528,14 @@ ${operationTypes.join("\n")}
 
   // src/libraries/GraphQLClient.ts
   var import_graphql_ws = __toESM(require_dist());
+  var CIPHER_HASH_QUERY = "query ( $Hash: String! ) { CipherHash ( Hash: $Hash ) { hash } }";
+  function parseOperation(query) {
+    const typeMatch = (query || "").match(/\b(query|mutation|subscription)\b/i);
+    const type2 = 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: type2, name: nameMatch?.[0] ?? "" };
+  }
   var GraphQLClient = class {
     $__client;
     $__authToken = "";
@@ -28463,6 +28581,10 @@ ${operationTypes.join("\n")}
       return Q3({
         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).
+        // Omitted → urql uses the global fetch (plaintext).
+        ...this.cipherLink ? { fetch: ((input, init) => this.cipherFetch(input, init)) } : {},
         fetchOptions: () => ({
           headers: {
             "X-Auth-Token": this.$__authToken
@@ -28472,6 +28594,62 @@ ${operationTypes.join("\n")}
         })
       });
     }
+    /**
+     * 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/PHP/validator bypass set.
+     */
+    shouldEncrypt(body) {
+      let parsed;
+      try {
+        parsed = JSON.parse(body);
+      } catch (e4) {
+        return false;
+      }
+      const { type: type2, name: name2 } = parseOperation(parsed.query);
+      if (type2 === "query" && (name2 === "__schema" || name2 === "ContinuId")) return false;
+      if (type2 === "mutation" && name2 === "AccessToken") return false;
+      if (type2 === "mutation" && name2 === "ProposeMolecule") {
+        const isotope = 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 the JS/Kotlin transform).
+     * Reads the CURRENT client wallet + validator pubkey from auth.
+     */
+    async cipherFetch(input, init) {
+      const wallet = this.$__wallet;
+      const serverPubkey = this.$__pubkey;
+      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;
+      }
+      const text = await response.text();
+      const init2 = { status: response.status, statusText: response.statusText, headers: response.headers };
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch (e4) {
+        return new Response(text, init2);
+      }
+      const hash = parsed?.data?.CipherHash?.hash;
+      if (typeof hash !== "string") {
+        return new Response(text, init2);
+      }
+      const decrypted = await wallet.decryptMyMessageML768(JSON.parse(hash));
+      return new Response(decrypted != null ? decrypted : text, init2);
+    }
     setAuthData({
       token,
       pubkey,
@@ -28766,8 +28944,8 @@ ${operationTypes.join("\n")}
      * Returns a Response object
      */
     createResponse(json) {
-      const Response2 = (init_Response(), __toCommonJS(Response_exports)).default;
-      return new Response2({
+      const Response3 = (init_Response(), __toCommonJS(Response_exports)).default;
+      return new Response3({
         query: this,
         json
       });
@@ -28837,8 +29015,8 @@ ${operationTypes.join("\n")}
       } catch (error2) {
         if (error2.name === "AbortError") {
           this.knishIOClient.log("warn", "Query was cancelled");
-          const Response2 = (init_Response(), __toCommonJS(Response_exports)).default;
-          return new Response2({
+          const Response3 = (init_Response(), __toCommonJS(Response_exports)).default;
+          return new Response3({
             query: this,
             json: { data: null, errors: [{ message: "Query was cancelled" }] }
           });
@@ -28882,8 +29060,8 @@ ${operationTypes.join("\n")}
       } catch (error2) {
         if (error2.name === "AbortError") {
           this.knishIOClient.log("warn", "Mutation was cancelled");
-          const Response2 = (init_Response(), __toCommonJS(Response_exports)).default;
-          return new Response2({
+          const Response3 = (init_Response(), __toCommonJS(Response_exports)).default;
+          return new Response3({
             query: this,
             json: { data: null, errors: [{ message: "Mutation was cancelled" }] }
           });
@@ -29822,6 +30000,89 @@ ${operationTypes.join("\n")}
 
   // src/response/ResponseBalance.ts
   init_Response();
+
+  // src/core/TokenUnit.ts
+  var TokenUnit = class _TokenUnit {
+    id;
+    name;
+    metas;
+    /**
+     * Create new TokenUnit instance
+     * Matches JavaScript SDK constructor signature exactly
+     */
+    constructor(id, name2, metas) {
+      this.id = id;
+      this.name = name2;
+      this.metas = metas || {};
+    }
+    /**
+     * Create TokenUnit from GraphQL response data
+     * Matches JavaScript SDK createFromGraphQL method exactly
+     */
+    static createFromGraphQL(data) {
+      let metas = data.metas || {};
+      if (Array.isArray(metas) && metas.length) {
+        try {
+          metas = JSON.parse(metas);
+          if (!metas) {
+            metas = {};
+          }
+        } catch (error2) {
+          metas = {};
+        }
+      }
+      return new _TokenUnit(
+        data.id,
+        data.name,
+        metas
+      );
+    }
+    /**
+     * Create TokenUnit from database array data
+     * Matches JavaScript SDK createFromDB method exactly
+     */
+    static createFromDB(data) {
+      return new _TokenUnit(
+        data[0],
+        data[1],
+        data.length > 2 ? data[2] : {}
+      );
+    }
+    /**
+     * Get fragment zone from metadata
+     * Matches JavaScript SDK getFragmentZone method exactly
+     */
+    getFragmentZone() {
+      return this.metas.fragmentZone || null;
+    }
+    /**
+     * Get fused token units from metadata
+     * Matches JavaScript SDK getFusedTokenUnits method exactly
+     */
+    getFusedTokenUnits() {
+      return this.metas.fusedTokenUnits || null;
+    }
+    /**
+     * Convert to data array format
+     * Matches JavaScript SDK toData method exactly
+     */
+    toData() {
+      return [this.id, this.name, this.metas];
+    }
+    /**
+     * Convert to GraphQL response format
+     * Matches JavaScript SDK toGraphQLResponse method exactly
+     */
+    toGraphQLResponse() {
+      return {
+        id: this.id,
+        name: this.name,
+        metas: JSON.stringify(this.metas)
+      };
+    }
+  };
+
+  // src/response/ResponseBalance.ts
   var ResponseBalance = class _ResponseBalance extends exports.Response {
     /**
      * Class constructor
@@ -29884,6 +30145,11 @@ ${operationTypes.join("\n")}
         wallet.tokenSupply = data.token.supply;
         wallet.tokenFungibility = data.token.fungibility;
       }
+      if (data.tokenUnits && data.tokenUnits.length) {
+        for (const tokenUnitData of data.tokenUnits) {
+          wallet.tokenUnits.push(TokenUnit.createFromGraphQL(tokenUnitData));
+        }
+      }
       if (data.tradeRates && data.tradeRates.length) {
         for (const tradeRate of data.tradeRates) {
           wallet.tradeRates[tradeRate.tokenSlug] = tradeRate.amount;
@@ -29943,89 +30209,6 @@ ${operationTypes.join("\n")}
 
   // src/response/ResponseWalletList.ts
   init_Response();
-
-  // src/core/TokenUnit.ts
-  var TokenUnit = class _TokenUnit {
-    id;
-    name;
-    metas;
-    /**
-     * Create new TokenUnit instance
-     * Matches JavaScript SDK constructor signature exactly
-     */
-    constructor(id, name2, metas) {
-      this.id = id;
-      this.name = name2;
-      this.metas = metas || {};
-    }
-    /**
-     * Create TokenUnit from GraphQL response data
-     * Matches JavaScript SDK createFromGraphQL method exactly
-     */
-    static createFromGraphQL(data) {
-      let metas = data.metas || {};
-      if (Array.isArray(metas) && metas.length) {
-        try {
-          metas = JSON.parse(metas);
-          if (!metas) {
-            metas = {};
-          }
-        } catch (error2) {
-          metas = {};
-        }
-      }
-      return new _TokenUnit(
-        data.id,
-        data.name,
-        metas
-      );
-    }
-    /**
-     * Create TokenUnit from database array data
-     * Matches JavaScript SDK createFromDB method exactly
-     */
-    static createFromDB(data) {
-      return new _TokenUnit(
-        data[0],
-        data[1],
-        data.length > 2 ? data[2] : {}
-      );
-    }
-    /**
-     * Get fragment zone from metadata
-     * Matches JavaScript SDK getFragmentZone method exactly
-     */
-    getFragmentZone() {
-      return this.metas.fragmentZone || null;
-    }
-    /**
-     * Get fused token units from metadata
-     * Matches JavaScript SDK getFusedTokenUnits method exactly
-     */
-    getFusedTokenUnits() {
-      return this.metas.fusedTokenUnits || null;
-    }
-    /**
-     * Convert to data array format
-     * Matches JavaScript SDK toData method exactly
-     */
-    toData() {
-      return [this.id, this.name, this.metas];
-    }
-    /**
-     * Convert to GraphQL response format
-     * Matches JavaScript SDK toGraphQLResponse method exactly
-     */
-    toGraphQLResponse() {
-      return {
-        id: this.id,
-        name: this.name,
-        metas: JSON.stringify(this.metas)
-      };
-    }
-  };
-
-  // src/response/ResponseWalletList.ts
   var ResponseWalletList = class _ResponseWalletList extends exports.Response {
     /**
      * Class constructor
@@ -30963,133 +31146,6 @@ ${operationTypes.join("\n")}
     }
   };
 
-  // src/response/ResponseQueryUserActivity.ts
-  init_Response();
-  var ResponseQueryUserActivity = class extends exports.Response {
-    /**
-     * Constructor
-     */
-    constructor({
-      query,
-      json
-    }) {
-      super({
-        query,
-        json,
-        dataKey: "data.UserActivity"
-      });
-    }
-    /**
-     * Returns processed user activity data
-     */
-    payload() {
-      const data = JSON.parse(JSON.stringify(this.data()));
-      if (data.instances) {
-        for (const datum of data.instances) {
-          if (datum.jsonData) {
-            datum.jsonData = JSON.parse(datum.jsonData);
-          }
-        }
-      }
-      return data;
-    }
-  };
-
-  // src/query/QueryUserActivity.ts
-  var QueryUserActivity = class extends Query {
-    /**
-     * Constructor
-     */
-    constructor(graphQLClient, knishIOClient) {
-      super(graphQLClient, knishIOClient);
-      this.$__query = gql`
-      query UserActivity(
-        $bundleHash: String
-        $metaType: String
-        $metaId: String
-        $ipAddress: String
-        $browser: String
-        $osCpu: String
-        $resolution: String
-        $timeZone: String
-        $countBy: [CountByUserActivity]
-        $interval: span
-      ) {
-        UserActivity(
-          bundleHash: $bundleHash
-          metaType: $metaType
-          metaId: $metaId
-          ipAddress: $ipAddress
-          browser: $browser
-          osCpu: $osCpu
-          resolution: $resolution
-          timeZone: $timeZone
-          countBy: $countBy
-          interval: $interval
-        ) {
-          createdAt
-          bundleHash
-          metaType
-          metaId
-          instances {
-            bundleHash
-            metaType
-            metaId
-            jsonData
-            createdAt
-            updatedAt
-          }
-          instanceCount {
-            ...SubFields
-            ...Recursive
-          }
-        }
-      }
-
-      fragment SubFields on InstanceCountType {
-        id
-        count
-      }
-
-      fragment Recursive on InstanceCountType {
-        instances {
-          ...SubFields
-          instances {
-            ...SubFields
-            instances {
-              ...SubFields
-              instances {
-                ...SubFields
-                instances {
-                  ...SubFields
-                  instances {
-                    ...SubFields
-                    instances {
-                      ...SubFields
-                      instances {
-                        ...SubFields
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    `;
-    }
-    /**
-     * Returns a Response object
-     */
-    createResponse(json) {
-      return new ResponseQueryUserActivity({
-        query: this,
-        json
-      });
-    }
-  };
-
   // src/query/QueryToken.ts
   init_Response();
   var QueryToken = class extends Query {
@@ -31931,6 +31987,20 @@ ${operationTypes.join("\n")}
       this.$__molecule.sign({});
       this.$__molecule.check(this.$__molecule.sourceWallet);
     }
+    /**
+     * Fills the Molecule for a MULTI-recipient transfer (one source funds N recipients)
+     */
+    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 object
      * Matches JavaScript SDK createResponse method signature exactly
@@ -31991,7 +32061,8 @@ ${operationTypes.join("\n")}
         bundle: this.$__molecule.bundle,
         token,
         batchId
-      })(this.$__molecule).initShadowWalletClaim(wallet);
+      });
+      this.$__molecule.initShadowWalletClaim(wallet);
       this.$__molecule.sign({});
       this.$__molecule.check();
     }
@@ -33251,6 +33322,75 @@ ${operationTypes.join("\n")}
       });
       return await this.executeQuery(query);
     }
+    /**
+     * Fund N recipients from a single source in ONE molecule (multi-recipient sibling of
+     * transferToken). Each recipient gets its own subset of stackable units (or a fungible
+     * amount); a remainder returns the rest to the sender. Conserves:
+     * -balance + Σamounts + (balance - Σ) === 0.
+     *
+     * @param token - token slug
+     * @param recipients - destinations (bundleHash + units OR amount + optional batchId)
+     * @param sourceWallet - optional pre-resolved source (defaults to the client's own wallet)
+     */
+    async transferTokens({
+      token,
+      recipients,
+      sourceWallet = null
+    }) {
+      const amounts = recipients.map((recipient) => {
+        const unitCount = recipient.units ? recipient.units.length : 0;
+        if (unitCount > 0) {
+          if (recipient.amount !== null && recipient.amount !== void 0 && recipient.amount > 0) {
+            throw new StackableUnitAmountException_default();
+          }
+          return unitCount;
+        }
+        return recipient.amount ?? 0;
+      });
+      const total = amounts.reduce((sum, amount) => sum + amount, 0);
+      if (sourceWallet === null) {
+        sourceWallet = await this.querySourceWallet({
+          token,
+          amount: total
+        });
+      }
+      if (sourceWallet === null || Decimal.cmp(Number(sourceWallet.balance), total) < 0) {
+        throw new exports.TransferBalanceException();
+      }
+      const recipientWallets = recipients.map((recipient) => {
+        const recipientWallet = Wallet.create({
+          bundle: recipient.bundleHash,
+          token
+        });
+        if (recipient.batchId !== null && recipient.batchId !== void 0) {
+          recipientWallet.batchId = recipient.batchId;
+        } else {
+          recipientWallet.initBatchId({ sourceWallet });
+        }
+        return recipientWallet;
+      });
+      const remainderWallet = sourceWallet.createRemainder(this.getSecret());
+      if (recipients.some((recipient) => recipient.units && recipient.units.length > 0)) {
+        sourceWallet.splitUnitsMulti(
+          recipients.map((recipient) => recipient.units ?? []),
+          recipientWallets,
+          remainderWallet
+        );
+      }
+      const molecule = await this.createMolecule({
+        sourceWallet,
+        remainderWallet
+      });
+      const query = await this.createMoleculeMutation({
+        mutationClass: MutationTransferTokens,
+        molecule
+      });
+      query.fillMoleculeMulti({
+        recipientWallets,
+        amounts
+      });
+      return await this.executeQuery(query);
+    }
     /**
      * Request authorization token (guest or profile)
      *
@@ -33707,36 +33847,6 @@ ${operationTypes.join("\n")}
         metaId
       });
     }
-    /**
-     * Query user activity
-     */
-    async queryUserActivity({
-      bundleHash,
-      metaType,
-      metaId,
-      ipAddress = null,
-      browser = null,
-      osCpu = null,
-      resolution = null,
-      timeZone = null,
-      countBy = null,
-      interval = null
-    }) {
-      const query = this.createQuery(QueryUserActivity);
-      const variables = {
-        bundleHash,
-        metaType,
-        metaId
-      };
-      if (ipAddress !== null) variables.ipAddress = ipAddress;
-      if (browser !== null) variables.browser = browser;
-      if (osCpu !== null) variables.osCpu = osCpu;
-      if (resolution !== null) variables.resolution = resolution;
-      if (timeZone !== null) variables.timeZone = timeZone;
-      if (countBy !== null) variables.countBy = countBy;
-      if (interval !== null) variables.interval = interval;
-      return this.executeQuery(query, variables);
-    }
     /**
      * Query token information
      */
@@ -33845,9 +33955,27 @@ ${operationTypes.join("\n")}
       amount = null,
       meta = null,
       batchId = null,
-      units: _units = null
+      units = null
     }) {
       this.log("info", `KnishIOClient::createToken() - Creating token ${token}...`);
+      const tokenMeta = meta || {};
+      const fungibility = tokenMeta.fungibility;
+      let resolvedAmount = amount ?? 0;
+      if (fungibility === "stackable") {
+        tokenMeta.batchId = batchId || generateBatchId({});
+      }
+      if ((fungibility === "stackable" || fungibility === "nonfungible" || fungibility === "non-fungible") && units && units.length > 0) {
+        if (Number(tokenMeta.decimals ?? 0) > 0) {
+          throw new StackableUnitDecimalsException_default();
+        }
+        if (Number(amount ?? 0) > 0) {
+          throw new StackableUnitAmountException_default();
+        }
+        resolvedAmount = units.length;
+        tokenMeta.splittable = "1";
+        tokenMeta.decimals = "0";
+        tokenMeta.tokenUnits = JSON.stringify(units);
+      }
       const mutation = await this.createMoleculeMutation({ mutationClass: MutationCreateToken });
       const recipientWallet = new Wallet({
         secret: this.getSecret(),
@@ -33857,8 +33985,8 @@ ${operationTypes.join("\n")}
       });
       await mutation.fillMolecule({
         recipientWallet,
-        amount: amount ?? 0,
-        meta
+        amount: resolvedAmount,
+        meta: tokenMeta
       });
       const response = await this.executeQuery(mutation);
       if (!response) {
@@ -34299,8 +34427,12 @@ ${operationTypes.join("\n")}
         mutationClass: MutationRequestAuthorization,
         molecule
       });
+      const authMeta = { encrypt: encrypt ? "true" : "false" };
+      if (wallet.pubkey) {
+        authMeta.walletPubkey = wallet.pubkey;
+      }
       mutation.fillMolecule({
-        meta: { encrypt: encrypt ? "true" : "false" }
+        meta: authMeta
       });
       const response = await this.executeQuery(mutation);
       if (!response) {