@wishknish/knishio-client-ts 0.8.3 → 0.9.0

package/dist/index.cjs

@@ -945,9 +945,19 @@ var init_StackableUnitAmountException = __esm({
 });
 
 // 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;
   }
 });
 
@@ -1929,9 +1939,6 @@ function generateSecret(seed = null, length = CRYPTO_CONSTANTS.SECRET_LENGTH) {
   }
 }
 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;
 }
@@ -3342,8 +3349,7 @@ var QUERY_TYPES = [
   "Batch",
   "ActiveSession",
   "Policy",
-  "Token",
-  "UserActivity"
+  "Token"
 ];
 function createLookup(values) {
   return values.reduce((acc, value) => {
@@ -3602,6 +3608,29 @@ var Wallet = class _Wallet {
     }
     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, i) => {
+      const ids = recipientUnitLists[i] ?? [];
+      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
@@ -3648,6 +3677,15 @@ var Wallet = 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.
+   */
+  async _mlkemDecryptToString(encryptedData) {
     const { cipherText, encryptedMessage } = encryptedData;
     let sharedSecret;
     try {
@@ -3676,9 +3714,8 @@ var Wallet = class _Wallet {
       console.info("Wallet::decryptMessage() - deserialized encrypted message", deserializedEncryptedMessage);
       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);
@@ -3687,7 +3724,40 @@ var Wallet = class _Wallet {
       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 i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(hex.substr(i * 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(map) {
+    const envelope = map[this.hashShare(this.pubkey)];
+    if (!envelope) {
+      return null;
+    }
+    return this._mlkemDecryptToString(envelope);
   }
   // =============================================================================
   // SYMMETRIC ENCRYPTION HELPERS (AES-GCM with shared secret)
@@ -4986,6 +5056,46 @@ var Molecule = class _Molecule {
     }));
     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, i) => {
+      this.addAtom(Atom.create({
+        isotope: "V",
+        wallet: recipientWallet,
+        value: amounts[i],
+        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
@@ -5743,7 +5853,7 @@ var Decimal = class _Decimal {
    * @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) {
@@ -5758,6 +5868,14 @@ var Decimal = class _Decimal {
     return _Decimal.cmp(value1, value2) === 0;
   }
 };
+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 type = 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?.[0] ?? "" };
+}
 var GraphQLClient = class {
   $__client;
   $__authToken = "";
@@ -5803,6 +5921,10 @@ var GraphQLClient = class {
     return core.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).
+      // Omitted → urql uses the global fetch (plaintext).
+      ...this.cipherLink ? { fetch: ((input, init) => this.cipherFetch(input, init)) } : {},
       fetchOptions: () => ({
         headers: {
           "X-Auth-Token": this.$__authToken
@@ -5812,6 +5934,62 @@ var GraphQLClient = class {
       })
     });
   }
+  /**
+   * 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 (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?.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 (e) {
+      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,
@@ -6106,8 +6284,8 @@ var Query = class {
    * 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
     });
@@ -6177,8 +6355,8 @@ var Query = class {
     } catch (error) {
       if (error.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" }] }
         });
@@ -6222,8 +6400,8 @@ var Mutation = class extends Query {
     } catch (error) {
       if (error.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" }] }
         });
@@ -7159,6 +7337,89 @@ var ConfigValidator = class _ConfigValidator {
 
 // 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, name, metas) {
+    this.id = id;
+    this.name = name;
+    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 (error) {
+        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
@@ -7221,6 +7482,11 @@ var ResponseBalance = class _ResponseBalance extends exports.Response {
       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;
@@ -7278,89 +7544,6 @@ var QueryBalance = class extends Query {
 
 // 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, name, metas) {
-    this.id = id;
-    this.name = name;
-    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 (error) {
-        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
@@ -8284,131 +8467,6 @@ var QueryActiveSession = class extends Query {
   }
 };
 
-// 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;
-  }
-};
-var QueryUserActivity = class extends Query {
-  /**
-   * Constructor
-   */
-  constructor(graphQLClient, knishIOClient) {
-    super(graphQLClient, knishIOClient);
-    this.$__query = core.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 {
@@ -9242,6 +9300,20 @@ var MutationTransferTokens = class extends MutationProposeMolecule {
     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
@@ -9302,7 +9374,8 @@ var MutationClaimShadowWallet = class extends MutationProposeMolecule {
       bundle: this.$__molecule.bundle,
       token,
       batchId
-    })(this.$__molecule).initShadowWalletClaim(wallet);
+    });
+    this.$__molecule.initShadowWalletClaim(wallet);
     this.$__molecule.sign({});
     this.$__molecule.check();
   }
@@ -10548,6 +10621,75 @@ var KnishIOClient = class {
     });
     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)
    *
@@ -11004,36 +11146,6 @@ var KnishIOClient = class {
       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
    */
@@ -11142,9 +11254,27 @@ var KnishIOClient = class {
     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(),
@@ -11154,8 +11284,8 @@ var KnishIOClient = class {
     });
     await mutation.fillMolecule({
       recipientWallet,
-      amount: amount ?? 0,
-      meta
+      amount: resolvedAmount,
+      meta: tokenMeta
     });
     const response = await this.executeQuery(mutation);
     if (!response) {
@@ -11596,8 +11726,12 @@ var KnishIOClient = class {
       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) {