@wishknish/knishio-client-ts 0.7.4 → 0.7.7

package/dist/index.cjs

@@ -904,9 +904,19 @@ var init_UnauthenticatedException = __esm({
 });
 
 // src/exception/AuthorizationRejectedException.ts
+var AuthorizationRejectedException, AuthorizationRejectedException_default;
 var init_AuthorizationRejectedException = __esm({
   "src/exception/AuthorizationRejectedException.ts"() {
     init_BaseException();
+    AuthorizationRejectedException = class extends exports.BaseException {
+      /**
+       * Constructor
+       */
+      constructor(message = "Authorization attempt rejected by ledger.") {
+        super("AUTHORIZATION_REJECTED_ERROR", message);
+      }
+    };
+    AuthorizationRejectedException_default = AuthorizationRejectedException;
   }
 });
 
@@ -1301,7 +1311,7 @@ var init_Dot = __esm({
     };
   }
 });
-var ResponseErrorSchema, ValidationResultSchema;
+var ResponseErrorSchema, ValidationResultSchema2;
 var init_response = __esm({
   "src/types/response.ts"() {
     ResponseErrorSchema = zod.z.object({
@@ -1312,7 +1322,7 @@ var init_response = __esm({
       timestamp: zod.z.string().optional(),
       operation: zod.z.string().optional()
     });
-    ValidationResultSchema = zod.z.object({
+    ValidationResultSchema2 = zod.z.object({
       success: zod.z.boolean(),
       data: zod.z.any().optional(),
       error: ResponseErrorSchema.optional(),
@@ -1502,7 +1512,7 @@ var init_EnhancedResponse = __esm({
       // Enhanced response validation
       validate() {
         try {
-          ValidationResultSchema.parse(this.toValidationResult());
+          ValidationResultSchema2.parse(this.toValidationResult());
           return {
             success: true,
             data: this._payload,
@@ -1753,7 +1763,7 @@ function chunkSubstr(str, size) {
   }
   return chunks;
 }
-function randomString(length = 32, alphabet = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") {
+function randomString(length = 32, alphabet = "abcdef0123456789") {
   if (length <= 0) return "";
   let result = "";
   if (typeof crypto !== "undefined" && crypto.getRandomValues) {
@@ -1774,26 +1784,26 @@ function charsetBaseConvert(src, fromBase, toBase, srcSymbolTable = "0123456789a
     return false;
   }
   try {
-    let decimalValue = 0;
-    const srcLength = src.length;
-    for (let i = 0; i < srcLength; i++) {
-      const char = src.charAt(srcLength - 1 - i);
-      const charIndex = srcSymbolTable.indexOf(char);
-      if (charIndex === -1) {
+    let val = BigInt(0);
+    const bigFromBase = BigInt(fromBase);
+    for (let charIndex = 0; charIndex < src.length; charIndex++) {
+      const symbolIndex = srcSymbolTable.indexOf(src.charAt(charIndex));
+      if (symbolIndex === -1) {
         return false;
       }
-      decimalValue += charIndex * Math.pow(fromBase, i);
+      val = val * bigFromBase + BigInt(symbolIndex);
     }
-    if (decimalValue === 0) {
+    if (val === BigInt(0)) {
       return destSymbolTable.charAt(0);
     }
+    const bigToBase = BigInt(toBase);
     let result = "";
-    while (decimalValue > 0) {
-      const remainder = decimalValue % toBase;
-      result = destSymbolTable.charAt(remainder) + result;
-      decimalValue = Math.floor(decimalValue / toBase);
+    while (val > BigInt(0)) {
+      const remainder = val % bigToBase;
+      result = destSymbolTable.charAt(Number(remainder)) + result;
+      val = val / bigToBase;
     }
-    return result;
+    return result || "0";
   } catch (error) {
     return false;
   }
@@ -1918,15 +1928,11 @@ function generateSecret(seed = null, length = CRYPTO_CONSTANTS.SECRET_LENGTH) {
     return randomString(length);
   }
 }
-function generateBundleHash(secret, source = null) {
+function generateBundleHash(secret, _source = null) {
   if (!secret || secret.length === 0) {
     throw new Error("Secret is required for bundle hash generation");
   }
-  let input = secret;
-  if (source) {
-    input = secret + source;
-  }
-  const hash = shake256(input, CRYPTO_CONSTANTS.BUNDLE_HASH_LENGTH * 4);
+  const hash = shake256(secret, CRYPTO_CONSTANTS.BUNDLE_HASH_LENGTH * 4);
   return hash;
 }
 function generatePosition() {
@@ -1937,17 +1943,10 @@ function generateBatchId({
   molecularHash = null,
   index = null
 } = {}) {
-  let input = "";
-  if (molecularHash) {
-    input += molecularHash;
-  }
-  if (index !== null) {
-    input += index.toString();
-  }
-  if (input === "") {
-    input = randomString(32);
+  if (molecularHash && index !== null) {
+    return shake256(molecularHash + index, 256);
   }
-  return shake256(input, 64);
+  return randomString(64);
 }
 function generateWalletKey({
   secret,
@@ -2255,63 +2254,134 @@ function runExtendedCompatibilityTests() {
   return { passed: allPassed, results };
 }
 
-// src/constants.ts
-var ISOTOPES = ["C", "V", "U", "T", "M", "I", "R", "B", "F"];
-var ERROR_TYPES = [
-  "ATOM_INDEX_ERROR",
-  "ATOMS_MISSING_ERROR",
-  "AUTHORIZATION_REJECTED_ERROR",
-  "BALANCE_INSUFFICIENT_ERROR",
-  "BATCH_ID_ERROR",
-  "CODE_ERROR",
-  "DECRYPTION_KEY_ERROR",
-  "INVALID_RESPONSE_ERROR",
-  "META_MISSING_ERROR",
-  "MOLECULAR_HASH_MISMATCH_ERROR",
-  "MOLECULAR_HASH_MISSING_ERROR",
-  "NEGATIVE_AMOUNT_ERROR",
-  "POLICY_INVALID_ERROR",
-  "RULE_ARGUMENT_ERROR",
-  "SIGNATURE_MALFORMED_ERROR",
-  "SIGNATURE_MISMATCH_ERROR",
-  "STACKABLE_UNIT_AMOUNT_ERROR",
-  "STACKABLE_UNIT_DECIMALS_ERROR",
-  "TRANSFER_BALANCE_ERROR",
-  "TRANSFER_MALFORMED_ERROR",
-  "TRANSFER_MISMATCHED_ERROR",
-  "TRANSFER_REMAINDER_ERROR",
-  "TRANSFER_TO_SELF_ERROR",
-  "TRANSFER_UNBALANCED_ERROR",
-  "UNAUTHENTICATED_ERROR",
-  "WALLET_CREDENTIAL_ERROR",
-  "WALLET_SHADOW_ERROR",
-  "WRONG_TOKEN_TYPE_ERROR"
-];
-var PROTOCOL_CONFIG = {
-  DEFAULT_SDK_VERSION: 4};
-var QUERY_TYPES = [
-  "Balance",
-  "WalletBundle",
-  "WalletList",
-  "Atom",
-  "MetaType",
-  "MetaTypeViaAtom",
-  "ContinuId",
-  "Batch",
-  "ActiveSession",
-  "Policy",
-  "Token",
-  "UserActivity"
-];
-function createLookup(values) {
-  return values.reduce((acc, value) => {
-    acc[value] = value;
-    return acc;
-  }, {});
+// src/versions/HashAtom.ts
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-var ISOTOPE_LOOKUP = createLookup(ISOTOPES);
-createLookup(ERROR_TYPES);
-createLookup(QUERY_TYPES);
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isPrimitive(value) {
+  return value === null || value === void 0 || ["string", "number", "boolean"].includes(typeof value);
+}
+var HashAtom = class _HashAtom {
+  /**
+   * Creates a HashAtom instance from an Atom with proper typing
+   */
+  static create(atom) {
+    const parameters = {};
+    for (const key of Object.keys(atom)) {
+      if (Object.prototype.hasOwnProperty.call(atom, key)) {
+        parameters[key] = atom[key];
+      }
+    }
+    return new this(parameters);
+  }
+  /**
+   * Recursively structures an object or array for hashing consistency
+   * Eliminates any types with proper generic constraints
+   */
+  static structure(object) {
+    if (isPrimitive(object)) {
+      return object;
+    }
+    if (isArray(object)) {
+      const result = [];
+      for (const value of object) {
+        result.push(_HashAtom.isStructure(value) ? _HashAtom.structure(value) : value);
+      }
+      return result;
+    }
+    if (isObject(object)) {
+      const result = [];
+      const keys = Object.keys(object).sort((first, second) => {
+        if (first === second) {
+          return 0;
+        }
+        return first < second ? -1 : 1;
+      });
+      for (const key of keys) {
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+          const item = {};
+          const value = object[key];
+          item[key] = _HashAtom.isStructure(value) ? _HashAtom.structure(value) : value;
+          result.push(item);
+        }
+      }
+      if (result.length > 0) {
+        return result;
+      }
+    }
+    return object;
+  }
+  /**
+   * Type guard to determine if a value needs recursive structure processing
+   */
+  static isStructure(structure) {
+    return isObject(structure) || isArray(structure);
+  }
+  /**
+   * Returns the structured view of this HashAtom instance
+   */
+  view() {
+    return _HashAtom.structure(this);
+  }
+  /**
+   * Protected constructor to support subclass instantiation
+   */
+  constructor(params = {}) {
+    Object.assign(this, params);
+  }
+};
+
+// src/versions/Version4.ts
+var Version4 = class extends HashAtom {
+  position;
+  walletAddress;
+  isotope;
+  token;
+  value;
+  batchId;
+  metaType;
+  metaId;
+  meta;
+  index;
+  createdAt;
+  version;
+  constructor({
+    position = null,
+    walletAddress = null,
+    isotope = null,
+    token = null,
+    value = null,
+    batchId = null,
+    metaType = null,
+    metaId = null,
+    meta = null,
+    index = null,
+    createdAt = null,
+    version = null
+  } = {}) {
+    super();
+    this.position = position;
+    this.walletAddress = walletAddress;
+    this.isotope = isotope;
+    this.token = token;
+    this.value = value;
+    this.batchId = batchId;
+    this.metaType = metaType;
+    this.metaId = metaId;
+    this.meta = meta;
+    this.index = index;
+    this.createdAt = createdAt;
+    this.version = version;
+  }
+};
+
+// src/versions/index.ts
+var versions_default = {
+  4: Version4
+};
 
 // src/types/guards.ts
 function assertNever(value) {
@@ -2337,6 +2407,10 @@ function handleIsotope(isotope, handlers) {
       return handlers.B();
     case "F":
       return handlers.F();
+    case "P":
+      return handlers.P();
+    case "A":
+      return handlers.A();
     default:
       return assertNever(isotope);
   }
@@ -2348,126 +2422,537 @@ function isPosition(value) {
   return typeof value === "string" && value.length === 64 && /^[0-9a-fA-F]{64}$/.test(value);
 }
 
-// src/core/Atom.ts
-var ATOM_DEFAULTS = {
-  POSITION: "",
-  WALLET_ADDRESS: "",
-  ISOTOPE: "C",
-  TOKEN: "USER",
-  VALUE: null,
-  BATCH_ID: null,
-  META_TYPE: null,
-  META_ID: null,
-  META: [],
-  OTS_FRAGMENT: null,
-  INDEX: null,
-  VERSION: PROTOCOL_CONFIG.DEFAULT_SDK_VERSION
-};
-var Atom = class _Atom {
-  // Core properties matching JS SDK exactly
-  position;
-  walletAddress;
-  isotope;
-  token;
-  value;
-  batchId;
-  metaType;
-  metaId;
-  meta;
-  otsFragment;
-  index;
-  createdAt;
-  version;
+// src/core/Meta.ts
+var Meta = class {
+  // No instance properties - this class only provides static methods
   /**
-   * Create a new Atom instance
-   * Constructor signature matches JavaScript SDK exactly
+   * Normalize metadata to consistent format
+   * Matches JavaScript SDK Meta.normalizeMeta exactly
    */
-  constructor({
-    position = ATOM_DEFAULTS.POSITION,
-    walletAddress = ATOM_DEFAULTS.WALLET_ADDRESS,
-    isotope = ATOM_DEFAULTS.ISOTOPE,
-    token = ATOM_DEFAULTS.TOKEN,
-    value = ATOM_DEFAULTS.VALUE,
-    batchId = ATOM_DEFAULTS.BATCH_ID,
-    metaType = ATOM_DEFAULTS.META_TYPE,
-    metaId = ATOM_DEFAULTS.META_ID,
-    meta = null,
-    otsFragment = ATOM_DEFAULTS.OTS_FRAGMENT,
-    index = ATOM_DEFAULTS.INDEX,
-    createdAt = null,
-    version = ATOM_DEFAULTS.VERSION
-  } = {}) {
-    this.position = position ?? ATOM_DEFAULTS.POSITION;
-    this.walletAddress = walletAddress ?? ATOM_DEFAULTS.WALLET_ADDRESS;
-    this.isotope = isotope ?? ATOM_DEFAULTS.ISOTOPE;
-    this.token = token ?? ATOM_DEFAULTS.TOKEN;
-    this.value = value;
-    this.batchId = batchId;
-    this.metaType = metaType;
-    this.metaId = metaId;
-    this.meta = meta ? [...meta] : [...ATOM_DEFAULTS.META];
-    this.otsFragment = otsFragment;
-    this.index = index;
-    this.version = version ?? ATOM_DEFAULTS.VERSION;
-    this.createdAt = createdAt || String(+/* @__PURE__ */ new Date());
+  static normalizeMeta(meta) {
+    if (!meta) {
+      return [];
+    }
+    if (Array.isArray(meta)) {
+      return meta.map((item) => {
+        if (typeof item === "object" && item !== null && "key" in item) {
+          return {
+            key: String(item.key),
+            value: item.value == null ? null : String(item.value)
+          };
+        }
+        return {
+          key: "unknown",
+          value: String(item)
+        };
+      });
+    }
+    if (typeof meta === "object" && meta !== null) {
+      const target = [];
+      for (const property in meta) {
+        if (Object.prototype.hasOwnProperty.call(meta, property)) {
+          const raw = meta[property];
+          target.push({ key: property, value: raw == null ? null : String(raw) });
+        }
+      }
+      return target;
+    }
+    return [{
+      key: "value",
+      value: String(meta)
+    }];
   }
-  // =============================================================================
-  // INSTANCE METHODS - MATCH JAVASCRIPT SDK
-  // =============================================================================
   /**
-   * Get aggregated metadata for this atom
-   * Matches JavaScript SDK Meta.aggregateMeta functionality
+   * Aggregate metadata into single object
+   * Matches JavaScript SDK Meta.aggregateMeta exactly  
    */
-  aggregatedMeta() {
+  static aggregateMeta(metaItems) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return {};
+    }
     const aggregated = {};
-    for (const metaItem of this.meta) {
-      if (metaItem && typeof metaItem === "object" && "key" in metaItem) {
-        aggregated[metaItem.key] = metaItem.value;
+    for (const item of metaItems) {
+      if (item && typeof item === "object" && "key" in item) {
+        const key = String(item.key);
+        if ("value" in item) {
+          aggregated[key] = item.value;
+        } else {
+          const { key: itemKey, ...restOfItem } = item;
+          aggregated[key] = Object.keys(restOfItem).length === 1 && "value" in restOfItem ? restOfItem.value : restOfItem;
+        }
       }
     }
     return aggregated;
   }
   /**
-   * Get values that will be used for hashing
-   * Must match JavaScript SDK getHashableValues exactly - returns array of strings!
+   * Merge multiple metadata arrays
+   * Combines arrays while preserving order and handling duplicates
    */
-  getHashableValues() {
-    const hashableValues = [];
-    for (const property of _Atom.getHashableProps()) {
-      const value = this[property];
-      if (value === null && !["position", "walletAddress"].includes(property)) {
+  static mergeMeta(...metaArrays) {
+    const merged = [];
+    const keysSeen = /* @__PURE__ */ new Set();
+    for (const metaArray of metaArrays) {
+      if (!metaArray || !Array.isArray(metaArray)) {
         continue;
       }
-      if (property === "meta") {
-        for (const meta of value) {
-          if (typeof meta.value !== "undefined" && meta.value !== null) {
-            hashableValues.push(String(meta.key));
-            hashableValues.push(String(meta.value));
-          }
+      const normalized = this.normalizeMeta(metaArray);
+      for (const item of normalized) {
+        let finalKey = item.key;
+        let counter = 1;
+        while (keysSeen.has(finalKey)) {
+          finalKey = `${item.key}_${counter}`;
+          counter++;
         }
-      } else {
-        hashableValues.push(value === null ? "" : String(value));
+        keysSeen.add(finalKey);
+        merged.push({
+          ...item,
+          key: finalKey
+        });
       }
     }
-    return hashableValues;
+    return merged;
   }
   /**
-   * Get structured data for JSON serialization
-   * Separate from hashable values to maintain proper typing
+   * Filter metadata by key pattern or predicate
    */
-  getStructuredData() {
-    return {
-      position: this.position || "",
-      walletAddress: this.walletAddress?.toString() || "",
-      isotope: this.isotope,
-      token: this.token?.toString() || "",
-      value: this.value !== null ? this.value.toString() : null,
+  static filterMeta(metaItems, filter) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return [];
+    }
+    const normalized = this.normalizeMeta(metaItems);
+    if (typeof filter === "string") {
+      return normalized.filter((item) => item.key.includes(filter));
+    }
+    if (filter instanceof RegExp) {
+      return normalized.filter((item) => filter.test(item.key));
+    }
+    if (typeof filter === "function") {
+      return normalized.filter(filter);
+    }
+    return normalized;
+  }
+  /**
+   * Find metadata item by key
+   */
+  static findMeta(metaItems, key) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return null;
+    }
+    const normalized = this.normalizeMeta(metaItems);
+    return normalized.find((item) => item.key === key) || null;
+  }
+  /**
+   * Get metadata value by key
+   */
+  static getMetaValue(metaItems, key, defaultValue = null) {
+    const item = this.findMeta(metaItems, key);
+    return item ? item.value : defaultValue;
+  }
+  /**
+   * Set or update metadata item by key
+   */
+  static setMeta(metaItems, key, value) {
+    const normalized = this.normalizeMeta(metaItems);
+    const existingIndex = normalized.findIndex((item) => item.key === key);
+    const newItem = {
+      key,
+      value: value == null ? null : String(value)
+    };
+    if (existingIndex >= 0) {
+      normalized[existingIndex] = newItem;
+    } else {
+      normalized.push(newItem);
+    }
+    return normalized;
+  }
+  /**
+   * Remove metadata item by key
+   */
+  static removeMeta(metaItems, key) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return [];
+    }
+    const normalized = this.normalizeMeta(metaItems);
+    return normalized.filter((item) => item.key !== key);
+  }
+  /**
+   * Convert metadata to JSON-serializable format
+   */
+  static toJSON(metaItems) {
+    return this.aggregateMeta(this.normalizeMeta(metaItems));
+  }
+  /**
+   * Create metadata from JSON object
+   */
+  static fromJSON(jsonData) {
+    if (!jsonData || typeof jsonData !== "object") {
+      return [];
+    }
+    return Object.entries(jsonData).map(([key, value]) => ({
+      key,
+      value: value == null ? null : String(value)
+    }));
+  }
+  /**
+   * Validate metadata structure
+   */
+  static validateMeta(metaItems) {
+    if (!Array.isArray(metaItems)) {
+      return false;
+    }
+    return metaItems.every(
+      (item) => item && typeof item === "object" && "key" in item && typeof item.key === "string"
+    );
+  }
+  /**
+   * Get all unique keys from metadata
+   */
+  static getKeys(metaItems) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return [];
+    }
+    const normalized = this.normalizeMeta(metaItems);
+    const keys = /* @__PURE__ */ new Set();
+    for (const item of normalized) {
+      keys.add(item.key);
+    }
+    return Array.from(keys);
+  }
+  /**
+   * Check if metadata contains specific key
+   */
+  static hasKey(metaItems, key) {
+    return this.getKeys(metaItems).includes(key);
+  }
+  /**
+   * Get metadata statistics
+   */
+  static getStats(metaItems) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return {
+        totalItems: 0,
+        uniqueKeys: 0,
+        keys: [],
+        valueTypes: {}
+      };
+    }
+    const normalized = this.normalizeMeta(metaItems);
+    const keys = this.getKeys(normalized);
+    const valueTypes = {};
+    for (const item of normalized) {
+      const type = item.value === null ? "null" : typeof item.value;
+      valueTypes[type] = (valueTypes[type] || 0) + 1;
+    }
+    return {
+      totalItems: normalized.length,
+      uniqueKeys: keys.length,
+      keys,
+      valueTypes
+    };
+  }
+  /**
+   * Deep clone metadata array
+   */
+  static clone(metaItems) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return [];
+    }
+    const normalized = this.normalizeMeta(metaItems);
+    return normalized.map((item) => ({ ...item }));
+  }
+  /**
+   * Sort metadata by key
+   */
+  static sort(metaItems, descending = false) {
+    if (!metaItems || !Array.isArray(metaItems)) {
+      return [];
+    }
+    const normalized = this.normalizeMeta(metaItems);
+    return normalized.sort((a, b) => {
+      const comparison = a.key.localeCompare(b.key);
+      return descending ? -comparison : comparison;
+    });
+  }
+};
+var AtomMeta = class _AtomMeta {
+  meta;
+  /**
+   * Create new AtomMeta instance
+   * @param meta - Initial metadata (object or array)
+   */
+  constructor(meta = null) {
+    this.meta = Meta.normalizeMeta(meta);
+  }
+  /**
+   * Merge additional metadata
+   * @param meta - Metadata to merge
+   * @return This instance for chaining
+   */
+  merge(meta) {
+    this.meta = [...this.meta, ...Meta.normalizeMeta(meta)];
+    return this;
+  }
+  /**
+   * Add context metadata if enabled
+   * @param context - Context URL or null for default
+   * @return This instance for chaining
+   */
+  addContext(context = null) {
+    return this;
+  }
+  /**
+   * Set atom wallet metadata
+   * @param wallet - Wallet to extract metadata from
+   * @return This instance for chaining
+   */
+  setAtomWallet(wallet) {
+    const walletMeta = {};
+    if (wallet.tokenUnits && wallet.tokenUnits.length) {
+      walletMeta.tokenUnits = JSON.stringify(wallet.getTokenUnitsData ? wallet.getTokenUnitsData() : wallet.tokenUnits);
+    }
+    if (wallet.tradeRates && wallet.tradeRates.length) {
+      walletMeta.tradeRates = JSON.stringify(wallet.tradeRates);
+    }
+    if (Object.keys(walletMeta).length > 0) {
+      this.merge(walletMeta);
+    }
+    return this;
+  }
+  /**
+   * Set full NEW wallet metadata
+   * Used for shadow wallet claim & wallet creation & token creation
+   * @param wallet - Wallet with full metadata
+   * @return This instance for chaining
+   */
+  setMetaWallet(wallet) {
+    this.merge({
+      walletTokenSlug: wallet.token,
+      walletBundleHash: wallet.bundle,
+      walletAddress: wallet.address,
+      walletPosition: wallet.position,
+      walletBatchId: wallet.batchId,
+      walletPubkey: wallet.pubkey,
+      walletCharacters: wallet.characters
+    });
+    return this;
+  }
+  /**
+   * Set shadow wallet claim flag
+   * @param shadowWalletClaim - Claim flag (converted to number)
+   * @return This instance for chaining
+   */
+  setShadowWalletClaim(shadowWalletClaim) {
+    this.merge({ shadowWalletClaim: Number(shadowWalletClaim) });
+    return this;
+  }
+  /**
+   * Set signing wallet metadata
+   * @param signingWallet - Wallet used for signing
+   * @return This instance for chaining
+   */
+  setSigningWallet(signingWallet) {
+    this.merge({
+      signingWallet: JSON.stringify({
+        tokenSlug: signingWallet.token,
+        bundleHash: signingWallet.bundle,
+        address: signingWallet.address,
+        position: signingWallet.position,
+        pubkey: signingWallet.pubkey,
+        characters: signingWallet.characters
+      })
+    });
+    return this;
+  }
+  /**
+   * Add policy metadata
+   * @param policy - Policy object to add
+   * @return This instance for chaining
+   */
+  addPolicy(policy) {
+    this.merge({
+      policy: JSON.stringify(policy)
+    });
+    return this;
+  }
+  /**
+   * Get the normalized metadata array
+   * @return Array of normalized metadata items
+   */
+  get() {
+    return this.meta;
+  }
+  /**
+   * Convert metadata to plain object
+   * @return Aggregated metadata object
+   */
+  toObject() {
+    return Meta.aggregateMeta(this.meta);
+  }
+  /**
+   * Convert metadata to JSON string
+   * @return JSON string representation
+   */
+  toJSON() {
+    return JSON.stringify(this.toObject());
+  }
+  /**
+   * Get metadata value by key
+   * @param key - Key to lookup
+   * @param defaultValue - Default if not found
+   * @return Value or default
+   */
+  getValue(key, defaultValue = null) {
+    return Meta.getMetaValue(this.meta, key, defaultValue);
+  }
+  /**
+   * Check if metadata has a key
+   * @param key - Key to check
+   * @return True if key exists
+   */
+  hasKey(key) {
+    return Meta.hasKey(this.meta, key);
+  }
+  /**
+   * Remove metadata by key
+   * @param key - Key to remove
+   * @return This instance for chaining
+   */
+  remove(key) {
+    this.meta = Meta.removeMeta(this.meta, key);
+    return this;
+  }
+  /**
+   * Clear all metadata
+   * @return This instance for chaining
+   */
+  clear() {
+    this.meta = [];
+    return this;
+  }
+  /**
+   * Get count of metadata items
+   * @return Number of items
+   */
+  count() {
+    return this.meta.length;
+  }
+  /**
+   * Clone this AtomMeta instance
+   * @return New AtomMeta with same data
+   */
+  clone() {
+    return new _AtomMeta(Meta.clone(this.meta));
+  }
+};
+var Atom = class _Atom {
+  // Core properties matching JS SDK exactly (all default to null)
+  position;
+  walletAddress;
+  isotope;
+  token;
+  value;
+  batchId;
+  metaType;
+  metaId;
+  meta;
+  otsFragment;
+  index;
+  createdAt;
+  version;
+  /**
+   * Create a new Atom instance
+   * Constructor signature matches JavaScript SDK exactly
+   */
+  constructor({
+    position = null,
+    walletAddress = null,
+    isotope = null,
+    token = null,
+    value = null,
+    batchId = null,
+    metaType = null,
+    metaId = null,
+    meta = null,
+    otsFragment = null,
+    index = null,
+    createdAt = null,
+    version = null
+  } = {}) {
+    this.position = position;
+    this.walletAddress = walletAddress;
+    this.isotope = isotope;
+    this.token = token;
+    this.value = value !== null && value !== void 0 ? String(value) : null;
+    this.batchId = batchId;
+    this.metaType = metaType;
+    this.metaId = metaId;
+    this.meta = meta ? Meta.normalizeMeta(meta) : [];
+    this.otsFragment = otsFragment;
+    this.index = index;
+    if (version !== null && version !== void 0 && Object.prototype.hasOwnProperty.call(versions_default, version)) {
+      this.version = String(version);
+    }
+    this.createdAt = createdAt || String(+/* @__PURE__ */ new Date());
+  }
+  // =============================================================================
+  // INSTANCE METHODS - MATCH JAVASCRIPT SDK
+  // =============================================================================
+  /**
+   * Get aggregated metadata for this atom
+   * Matches JavaScript SDK Meta.aggregateMeta functionality
+   */
+  aggregatedMeta() {
+    const aggregated = {};
+    for (const metaItem of this.meta) {
+      if (metaItem && typeof metaItem === "object" && "key" in metaItem) {
+        aggregated[metaItem.key] = metaItem.value;
+      }
+    }
+    return aggregated;
+  }
+  /**
+   * Get values that will be used for hashing
+   * Must match JavaScript SDK getHashableValues exactly - returns array of strings!
+   */
+  getHashableValues() {
+    const hashableValues = [];
+    for (const property of _Atom.getHashableProps()) {
+      const value = this[property];
+      if (value === null && !["position", "walletAddress"].includes(property)) {
+        continue;
+      }
+      if (property === "meta") {
+        for (const meta of value) {
+          if (typeof meta.value !== "undefined" && meta.value !== null) {
+            hashableValues.push(String(meta.key));
+            hashableValues.push(String(meta.value));
+          }
+        }
+      } else {
+        hashableValues.push(value === null ? "" : String(value));
+      }
+    }
+    return hashableValues;
+  }
+  /**
+   * Get structured data for JSON serialization
+   * Separate from hashable values to maintain proper typing
+   */
+  getStructuredData() {
+    return {
+      position: this.position || "",
+      walletAddress: this.walletAddress?.toString() || "",
+      isotope: this.isotope || "C",
+      token: this.token?.toString() || "",
+      value: this.value !== null ? this.value.toString() : null,
       batchId: this.batchId?.toString() || null,
       metaType: this.metaType?.toString() || null,
       metaId: this.metaId?.toString() || null,
-      meta: this.meta.length > 0 ? [...this.meta] : null,
+      // Always return array for meta (server expects Vec<MetaItemInput>, not null)
+      meta: this.meta.length > 0 ? [...this.meta] : [],
       createdAt: this.createdAt,
-      index: this.index !== null ? this.index : 0
+      index: this.index !== null ? this.index : 0,
+      version: this.version ?? null
     };
   }
   /**
@@ -2496,9 +2981,19 @@ var Atom = class _Atom {
           }
         }
       }
-      const structuredData = this.getStructuredData();
       const serialized = {
-        ...structuredData
+        position: this.position ?? "",
+        walletAddress: this.walletAddress ?? "",
+        isotope: this.isotope,
+        token: this.token ?? "",
+        value: this.value,
+        batchId: this.batchId,
+        metaType: this.metaType,
+        metaId: this.metaId,
+        meta: this.meta || [],
+        index: this.index,
+        createdAt: this.createdAt,
+        version: this.version
       };
       if (includeOtsFragments && this.otsFragment) {
         serialized.otsFragment = this.otsFragment;
@@ -2535,6 +3030,7 @@ var Atom = class _Atom {
     if (!isPosition(this.position) || !isWalletAddress(this.walletAddress)) {
       return false;
     }
+    if (!this.isotope) return false;
     return handleIsotope(this.isotope, {
       V: () => this.value !== null && !isNaN(Number(this.value)),
       // Value atoms must have numeric value
@@ -2552,8 +3048,12 @@ var Atom = class _Atom {
       // Rule atoms
       B: () => true,
       // Buffer atoms
-      F: () => true
+      F: () => true,
       // Fuse atoms
+      P: () => true,
+      // Peer atoms
+      A: () => Boolean(this.metaType && this.metaId)
+      // Append atoms must have metaType and metaId
     });
   }
   // =============================================================================
@@ -2583,24 +3083,48 @@ var Atom = class _Atom {
    */
   static getUnclaimedProps() {
     return [
-      "position",
-      "walletAddress",
-      "isotope",
-      "token",
-      "value",
-      "batchId",
-      "metaType",
-      "metaId",
-      "meta",
-      "createdAt"
+      "otsFragment"
     ];
   }
   /**
    * Create atom from parameters - factory method
-   * Matches JavaScript SDK Atom.create static method
+   * Matches JavaScript SDK Atom.create static method exactly
+   * Processes wallet meta, extracts wallet fields, normalizes meta
    */
-  static create(params) {
-    return new _Atom(params);
+  static create({
+    isotope,
+    wallet = null,
+    value = null,
+    metaType = null,
+    metaId = null,
+    meta = null,
+    batchId = null
+  }) {
+    let atomMeta;
+    if (!meta) {
+      atomMeta = new AtomMeta();
+    } else if (meta instanceof AtomMeta) {
+      atomMeta = meta;
+    } else {
+      atomMeta = new AtomMeta(meta);
+    }
+    if (wallet) {
+      atomMeta.setAtomWallet(wallet);
+      if (!batchId) {
+        batchId = wallet.batchId;
+      }
+    }
+    return new _Atom({
+      position: wallet ? wallet.position : null,
+      walletAddress: wallet ? wallet.address : null,
+      isotope,
+      token: wallet ? wallet.token : null,
+      value,
+      batchId,
+      metaType,
+      metaId,
+      meta: atomMeta.get()
+    });
   }
   /**
    * Creates an Atom instance from JSON data (2025 TS best practices)
@@ -2676,15 +3200,22 @@ var Atom = class _Atom {
       return "";
     }
     const atomList = _Atom.sortAtoms(atoms);
-    const numberOfAtoms = String(atoms.length);
-    let hashableValues = [];
-    for (const atom of atomList) {
-      hashableValues.push(numberOfAtoms);
-      hashableValues = hashableValues.concat(atom.getHashableValues());
-    }
     const molecularSponge = new JsSHA__default.default("SHAKE256", "TEXT");
-    for (const hashableValue of hashableValues) {
-      molecularSponge.update(hashableValue);
+    const versionRegistry = versions_default;
+    if (atomList.every((atom) => atom.version && Object.prototype.hasOwnProperty.call(versionRegistry, atom.version))) {
+      molecularSponge.update(JSON.stringify(
+        atomList.map((atom) => versionRegistry[atom.version].create(atom).view())
+      ));
+    } else {
+      const numberOfAtoms = String(atoms.length);
+      let hashableValues = [];
+      for (const atom of atomList) {
+        hashableValues.push(numberOfAtoms);
+        hashableValues = hashableValues.concat(atom.getHashableValues());
+      }
+      for (const hashableValue of hashableValues) {
+        molecularSponge.update(hashableValue);
+      }
     }
     const hexHash = molecularSponge.getHash("HEX", { outputLen: 256 });
     return convertToBase17(hexHash.toLowerCase());
@@ -2694,10 +3225,8 @@ var Atom = class _Atom {
    * Matches JavaScript SDK sortAtoms method
    */
   static sortAtoms(atoms) {
-    return [...atoms].sort((a, b) => {
-      const indexA = a.index !== null ? a.index : 0;
-      const indexB = b.index !== null ? b.index : 0;
-      return indexA - indexB;
+    return [...atoms].sort((first, second) => {
+      return first.index < second.index ? -1 : 1;
     });
   }
   /**
@@ -2705,11 +3234,7 @@ var Atom = class _Atom {
    * Matches JavaScript SDK generateNextAtomIndex method
    */
   static generateNextAtomIndex(atoms) {
-    if (!atoms || atoms.length === 0) {
-      return 0;
-    }
-    const indices = atoms.map((atom) => atom.index !== null ? atom.index : 0).filter((index) => typeof index === "number");
-    return indices.length > 0 ? Math.max(...indices) + 1 : 0;
+    return atoms.length;
   }
   /**
    * Filter atoms by isotope(s)
@@ -2717,7 +3242,7 @@ var Atom = class _Atom {
    */
   static isotopeFilter(isotopes, atoms) {
     const targetIsotopes = Array.isArray(isotopes) ? isotopes : [isotopes];
-    return atoms.filter((atom) => targetIsotopes.includes(atom.isotope));
+    return atoms.filter((atom) => atom.isotope !== null && targetIsotopes.includes(atom.isotope));
   }
   // =============================================================================
   // VALIDATION AND UTILITY METHODS
@@ -2744,7 +3269,9 @@ var Atom = class _Atom {
   static getUniqueIsotopes(atoms) {
     const isotopes = /* @__PURE__ */ new Set();
     for (const atom of atoms) {
-      isotopes.add(atom.isotope);
+      if (atom.isotope !== null) {
+        isotopes.add(atom.isotope);
+      }
     }
     return Array.from(isotopes);
   }
@@ -2760,16 +3287,74 @@ var Atom = class _Atom {
   static groupByIsotope(atoms) {
     const groups = {};
     for (const atom of atoms) {
-      if (!groups[atom.isotope]) {
-        groups[atom.isotope] = [];
+      const iso = atom.isotope;
+      if (iso === null) continue;
+      if (!groups[iso]) {
+        groups[iso] = [];
       }
-      groups[atom.isotope].push(atom);
+      groups[iso].push(atom);
     }
     return groups;
   }
 };
 init_WalletCredentialException();
 
+// src/constants.ts
+var ISOTOPES = ["C", "V", "U", "T", "M", "I", "R", "B", "F", "P", "A"];
+var ERROR_TYPES = [
+  "ATOM_INDEX_ERROR",
+  "ATOMS_MISSING_ERROR",
+  "AUTHORIZATION_REJECTED_ERROR",
+  "BALANCE_INSUFFICIENT_ERROR",
+  "BATCH_ID_ERROR",
+  "CODE_ERROR",
+  "DECRYPTION_KEY_ERROR",
+  "INVALID_RESPONSE_ERROR",
+  "META_MISSING_ERROR",
+  "MOLECULAR_HASH_MISMATCH_ERROR",
+  "MOLECULAR_HASH_MISSING_ERROR",
+  "NEGATIVE_AMOUNT_ERROR",
+  "POLICY_INVALID_ERROR",
+  "RULE_ARGUMENT_ERROR",
+  "SIGNATURE_MALFORMED_ERROR",
+  "SIGNATURE_MISMATCH_ERROR",
+  "STACKABLE_UNIT_AMOUNT_ERROR",
+  "STACKABLE_UNIT_DECIMALS_ERROR",
+  "TRANSFER_BALANCE_ERROR",
+  "TRANSFER_MALFORMED_ERROR",
+  "TRANSFER_MISMATCHED_ERROR",
+  "TRANSFER_REMAINDER_ERROR",
+  "TRANSFER_TO_SELF_ERROR",
+  "TRANSFER_UNBALANCED_ERROR",
+  "UNAUTHENTICATED_ERROR",
+  "WALLET_CREDENTIAL_ERROR",
+  "WALLET_SHADOW_ERROR",
+  "WRONG_TOKEN_TYPE_ERROR"
+];
+var QUERY_TYPES = [
+  "Balance",
+  "WalletBundle",
+  "WalletList",
+  "Atom",
+  "MetaType",
+  "MetaTypeViaAtom",
+  "ContinuId",
+  "Batch",
+  "ActiveSession",
+  "Policy",
+  "Token",
+  "UserActivity"
+];
+function createLookup(values) {
+  return values.reduce((acc, value) => {
+    acc[value] = value;
+    return acc;
+  }, {});
+}
+var ISOTOPE_LOOKUP = createLookup(ISOTOPES);
+createLookup(ERROR_TYPES);
+createLookup(QUERY_TYPES);
+
 // src/types/index.ts
 function isHexString(value) {
   return /^[0-9a-fA-F]+$/.test(value);
@@ -2848,17 +3433,8 @@ var Wallet = class _Wallet {
     batchId = null,
     characters = null
   } = {}) {
-    if (address !== null && !isWalletAddress2(address)) {
-      throw new exports.WalletCredentialException("Invalid wallet address format");
-    }
-    if (bundle !== null && !isBundleHash(bundle)) {
-      throw new exports.WalletCredentialException("Invalid bundle hash format");
-    }
-    if (position !== null && !isPosition2(position)) {
-      throw new exports.WalletCredentialException("Invalid position format");
-    }
     this.token = token;
-    this.balance = 0;
+    this.balance = "0";
     this.molecules = {};
     this.key = null;
     this.privkey = null;
@@ -2920,8 +3496,10 @@ var Wallet = class _Wallet {
     token,
     position
   }) {
-    const bigIntSecret = BigInt(`0x${secret}`);
-    const indexedKey = bigIntSecret + BigInt(`0x${position}`);
+    const secretHex = isHex(secret) ? secret : shake256(secret, 1024);
+    const positionHex = isHex(position) ? position : shake256(position, 256);
+    const bigIntSecret = BigInt(`0x${secretHex}`);
+    const indexedKey = bigIntSecret + BigInt(`0x${positionHex}`);
     const intermediateKeySponge = new JsSHA__default.default("SHAKE256", "TEXT");
     intermediateKeySponge.update(indexedKey.toString(16));
     if (token) {
@@ -3046,7 +3624,7 @@ var Wallet = class _Wallet {
    * Initializes the ML-KEM key pair (matches JavaScript SDK exactly)
    */
   initializeMLKEM() {
-    const seedHex = generateSecret(this.key, 64);
+    const seedHex = generateSecret(this.key, 128);
     const seed = new Uint8Array(64);
     for (let i = 0; i < 64; i++) {
       seed[i] = parseInt(seedHex.substr(i * 2, 2), 16);
@@ -3164,287 +3742,632 @@ var Wallet = class _Wallet {
     return new Uint8Array([...binaryString].map((char) => char.charCodeAt(0)));
   }
 };
+var hexStringRegex = /^[0-9a-fA-F]+$/;
+var base17HashRegex = /^[0-9a-g]+$/;
+zod.z.string().regex(hexStringRegex, "Must be a valid hexadecimal string").brand();
+var WalletAddressSchema = zod.z.string().regex(hexStringRegex, "Wallet address must be hexadecimal").length(64, "Wallet address must be exactly 64 characters").brand();
+var BundleHashSchema = zod.z.string().regex(hexStringRegex, "Bundle hash must be hexadecimal").length(64, "Bundle hash must be exactly 64 characters").brand();
+var PositionSchema = zod.z.string().regex(hexStringRegex, "Position must be hexadecimal").length(64, "Position must be exactly 64 characters").brand();
+zod.z.string().regex(base17HashRegex, "Molecular hash must be base17 format (0-9,a-g)").min(1, "Molecular hash cannot be empty").brand();
+var TokenSlugSchema = zod.z.string().min(1, "Token slug cannot be empty").max(64, "Token slug cannot exceed 64 characters").transform((val) => val.toUpperCase()).brand();
+var MetaTypeSchema = zod.z.string().min(1, "Meta type cannot be empty").max(256, "Meta type cannot exceed 256 characters").brand();
+var MetaIdSchema = zod.z.string().min(1, "Meta ID cannot be empty").brand();
+var BatchIdSchema = zod.z.string().min(1, "Batch ID cannot be empty").brand();
+var CellSlugSchema = zod.z.string().min(1, "Cell slug cannot be empty").max(64, "Cell slug cannot exceed 64 characters").brand();
+var AtomIsotopeSchema = zod.z.enum(["C", "V", "U", "T", "M", "I", "R", "B", "F"], {
+  errorMap: () => ({ message: "Invalid atom isotope. Must be one of: C, V, U, T, M, I, R, B, F" })
+});
+var MetaDataValueSchema = zod.z.union([
+  zod.z.string(),
+  zod.z.number(),
+  zod.z.boolean(),
+  zod.z.null()
+]);
+var AtomMetaDataSchema = zod.z.object({
+  key: zod.z.string().min(1, "Meta key cannot be empty"),
+  value: MetaDataValueSchema
+}).strict();
+var MetaDataSchema = zod.z.lazy(
+  () => zod.z.record(zod.z.union([
+    MetaDataValueSchema,
+    MetaDataSchema,
+    zod.z.array(MetaDataSchema)
+  ]))
+);
+zod.z.object({
+  position: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  walletAddress: zod.z.union([WalletAddressSchema, zod.z.string(), zod.z.null()]).optional(),
+  isotope: AtomIsotopeSchema.optional(),
+  token: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+  value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.null()]).optional(),
+  batchId: zod.z.union([BatchIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  metaType: zod.z.union([MetaTypeSchema, zod.z.string(), zod.z.null()]).optional(),
+  metaId: zod.z.union([MetaIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  meta: zod.z.union([zod.z.array(AtomMetaDataSchema), zod.z.null()]).optional(),
+  otsFragment: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  index: zod.z.union([zod.z.number().int().min(0), zod.z.null()]).optional(),
+  createdAt: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  version: zod.z.union([zod.z.number().int().min(1), zod.z.null()]).optional()
+}).strict();
+var WalletParamsSchema = zod.z.object({
+  secret: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  bundle: zod.z.union([BundleHashSchema, zod.z.string(), zod.z.null()]).optional(),
+  token: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+  address: zod.z.union([WalletAddressSchema, zod.z.string(), zod.z.null()]).optional(),
+  position: zod.z.union([PositionSchema, zod.z.string(), zod.z.null()]).optional(),
+  batchId: zod.z.union([BatchIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  characters: zod.z.union([zod.z.string(), zod.z.null()]).optional()
+}).strict();
+zod.z.object({
+  secret: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  bundle: zod.z.union([BundleHashSchema, zod.z.string(), zod.z.null()]).optional(),
+  sourceWallet: zod.z.union([WalletParamsSchema, zod.z.null()]).optional(),
+  remainderWallet: zod.z.union([WalletParamsSchema, zod.z.null()]).optional(),
+  cellSlug: zod.z.union([CellSlugSchema, zod.z.string(), zod.z.null()]).optional(),
+  version: zod.z.number().int().min(1).optional()
+}).strict();
+zod.z.object({
+  uri: zod.z.union([zod.z.string().url(), zod.z.array(zod.z.string().url())]).optional(),
+  cellSlug: zod.z.union([CellSlugSchema, zod.z.string(), zod.z.null()]).optional(),
+  client: zod.z.unknown().optional(),
+  socket: zod.z.unknown().optional(),
+  serverSdkVersion: zod.z.number().int().min(1).optional(),
+  logging: zod.z.boolean().optional()
+}).strict();
+zod.z.object({
+  token: zod.z.string().min(1, "Auth token cannot be empty"),
+  expiresAt: zod.z.number().int().min(0, "Expiration time must be positive"),
+  encrypt: zod.z.boolean(),
+  pubkey: zod.z.string().min(1, "Public key cannot be empty")
+}).strict();
+zod.z.object({
+  cellSlug: zod.z.union([CellSlugSchema, zod.z.string(), zod.z.null()]).optional(),
+  encrypt: zod.z.boolean().optional(),
+  callback: zod.z.function().args(zod.z.unknown()).returns(zod.z.void()).optional()
+}).strict();
+zod.z.object({
+  cellSlug: zod.z.union([CellSlugSchema, zod.z.string(), zod.z.null()]).optional()
+}).strict();
+zod.z.object({
+  recipient: zod.z.union([WalletAddressSchema, zod.z.string()]),
+  amount: zod.z.union([zod.z.number().positive(), zod.z.string().min(1)]),
+  token: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+  callbackUrl: zod.z.union([zod.z.string().url(), zod.z.null()]).optional(),
+  metaType: zod.z.union([MetaTypeSchema, zod.z.string(), zod.z.null()]).optional(),
+  metaId: zod.z.union([MetaIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  meta: zod.z.union([MetaDataSchema, zod.z.null()]).optional()
+}).strict();
+zod.z.object({
+  token: zod.z.union([TokenSlugSchema, zod.z.string()]),
+  amount: zod.z.union([zod.z.number().positive(), zod.z.string().min(1)]),
+  metaType: zod.z.union([MetaTypeSchema, zod.z.string(), zod.z.null()]).optional(),
+  metaId: zod.z.union([MetaIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  meta: zod.z.union([MetaDataSchema, zod.z.null()]).optional(),
+  fungible: zod.z.boolean().optional(),
+  splittable: zod.z.number().int().min(0).optional(),
+  supplyToken: zod.z.union([TokenSlugSchema, zod.z.string(), zod.z.null()]).optional()
+}).strict();
+zod.z.object({
+  amount: zod.z.union([zod.z.number().positive(), zod.z.string().min(1)]),
+  token: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+  metaType: zod.z.union([MetaTypeSchema, zod.z.string(), zod.z.null()]).optional(),
+  metaId: zod.z.union([MetaIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  meta: zod.z.union([MetaDataSchema, zod.z.null()]).optional()
+}).strict();
+var MetaFilterSchema = zod.z.object({
+  key: zod.z.string(),
+  value: zod.z.string(),
+  comparison: zod.z.string().optional(),
+  criterion: zod.z.string().optional()
+}).strict();
+zod.z.object({
+  address: zod.z.union([WalletAddressSchema, zod.z.string(), zod.z.null()]).optional(),
+  bundleHash: zod.z.union([BundleHashSchema, zod.z.string(), zod.z.null()]).optional(),
+  token: zod.z.union([TokenSlugSchema, zod.z.string(), zod.z.null()]).optional(),
+  type: zod.z.enum(["token", "user"]).nullable().optional()
+}).strict();
+zod.z.object({
+  metaType: zod.z.union([MetaTypeSchema, zod.z.string()]),
+  metaId: zod.z.union([MetaIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  key: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  value: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  latest: zod.z.union([zod.z.boolean(), zod.z.null()]).optional(),
+  filter: zod.z.union([zod.z.array(MetaFilterSchema), zod.z.null()]).optional(),
+  queryArgs: zod.z.union([zod.z.record(zod.z.unknown()), zod.z.null()]).optional(),
+  count: zod.z.union([zod.z.number().int().min(1), zod.z.null()]).optional(),
+  countBy: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  cellSlug: zod.z.union([CellSlugSchema, zod.z.string(), zod.z.null()]).optional()
+}).strict();
+zod.z.object({
+  bundleHash: zod.z.union([BundleHashSchema, zod.z.string(), zod.z.null()]).optional(),
+  tokenSlug: zod.z.union([TokenSlugSchema, zod.z.string(), zod.z.null()]).optional(),
+  unspent: zod.z.union([zod.z.boolean(), zod.z.null()]).optional()
+}).strict();
+zod.z.object({
+  seed: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  length: zod.z.number().int().min(1).optional(),
+  outputLength: zod.z.number().int().min(1).optional()
+}).strict();
+zod.z.object({
+  privateKey: zod.z.string().min(1, "Private key cannot be empty"),
+  publicKey: zod.z.string().min(1, "Public key cannot be empty")
+}).strict();
+zod.z.object({
+  signature: zod.z.string().min(1, "Signature cannot be empty"),
+  otsFragments: zod.z.array(zod.z.string()).optional()
+}).strict();
+zod.z.object({
+  query: zod.z.string().min(1, "GraphQL query cannot be empty"),
+  variables: zod.z.record(zod.z.unknown()).optional(),
+  operationName: zod.z.union([zod.z.string(), zod.z.null()]).optional()
+}).strict();
+var GraphQLErrorSchema = zod.z.object({
+  message: zod.z.string(),
+  locations: zod.z.array(zod.z.object({
+    line: zod.z.number().int().min(1),
+    column: zod.z.number().int().min(1)
+  })).optional(),
+  path: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).optional(),
+  extensions: zod.z.record(zod.z.unknown()).optional()
+}).strict();
+zod.z.object({
+  data: zod.z.unknown().optional(),
+  errors: zod.z.array(GraphQLErrorSchema).nullable().optional(),
+  extensions: zod.z.record(zod.z.unknown()).optional()
+}).strict();
+zod.z.object({
+  operationName: zod.z.string().optional(),
+  query: zod.z.string().optional(),
+  variables: zod.z.record(zod.z.unknown()).optional(),
+  callback: zod.z.function().args(zod.z.unknown()).returns(zod.z.void()).optional()
+}).strict();
+zod.z.object({
+  valid: zod.z.boolean(),
+  error: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  expected: zod.z.string().optional(),
+  actual: zod.z.unknown().optional()
+}).strict();
+zod.z.object({
+  operation: zod.z.string().optional(),
+  parameters: zod.z.record(zod.z.unknown()).optional(),
+  timestamp: zod.z.number().int().min(0).optional(),
+  stack: zod.z.string().optional()
+}).strict();
+zod.z.enum([
+  "ATOM_INDEX_ERROR",
+  "ATOMS_MISSING_ERROR",
+  "AUTHORIZATION_REJECTED_ERROR",
+  "BALANCE_INSUFFICIENT_ERROR",
+  "BATCH_ID_ERROR",
+  "CODE_ERROR",
+  "DECRYPTION_KEY_ERROR",
+  "INVALID_RESPONSE_ERROR",
+  "META_MISSING_ERROR",
+  "MOLECULAR_HASH_MISMATCH_ERROR",
+  "MOLECULAR_HASH_MISSING_ERROR",
+  "NEGATIVE_AMOUNT_ERROR",
+  "POLICY_INVALID_ERROR",
+  "SIGNATURE_MALFORMED_ERROR",
+  "SIGNATURE_MISMATCH_ERROR",
+  "STACKABLE_UNIT_AMOUNT_ERROR",
+  "STACKABLE_UNIT_DECIMALS_ERROR",
+  "TRANSFER_BALANCE_ERROR",
+  "TRANSFER_MALFORMED_ERROR",
+  "TRANSFER_MISMATCHED_ERROR",
+  "TRANSFER_REMAINDER_ERROR",
+  "TRANSFER_TO_SELF_ERROR",
+  "TRANSFER_UNBALANCED_ERROR",
+  "UNAUTHENTICATED_ERROR",
+  "WALLET_CREDENTIAL_ERROR",
+  "WALLET_SHADOW_ERROR",
+  "WRONG_TOKEN_TYPE_ERROR"
+]);
+function parseWithSchema(schema, data, context) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    const errorMessage = context ? `${context}: ${result.error.message}` : result.error.message;
+    throw new Error(errorMessage);
+  }
+  return result.data;
+}
 
-// src/libraries/CheckMolecule.ts
-init_exception();
-
-// src/core/Meta.ts
-var Meta = class {
-  // No instance properties - this class only provides static methods
+// src/instance/rules/Meta.ts
+var Meta2 = class _Meta {
+  __data = /* @__PURE__ */ new Map();
+  constructor(args = {}) {
+    const validatedArgs = parseWithSchema(MetaDataSchema, args, "Meta constructor");
+    for (const [key, value] of Object.entries(validatedArgs)) {
+      this.__data.set(`__${key}`, value);
+    }
+  }
   /**
-   * Normalize metadata to consistent format
-   * Matches JavaScript SDK Meta.normalizeMeta exactly
+   * Creates a Meta object from a plain object with runtime validation
    */
-  static normalizeMeta(meta) {
-    if (!meta) {
-      return [];
-    }
-    if (Array.isArray(meta)) {
-      return meta.map((item) => {
-        if (typeof item === "object" && item !== null && "key" in item) {
-          return {
-            ...item,
-            key: String(item.key),
-            value: item.value
-          };
-        }
-        return {
-          key: "unknown",
-          value: String(item)
-        };
-      });
-    }
-    if (typeof meta === "object" && meta !== null) {
-      return Object.entries(meta).map(([key, value]) => ({
-        key,
-        value
-      }));
-    }
-    return [{
-      key: "value",
-      value: meta
-    }];
+  static toObject(object) {
+    return new _Meta(object);
   }
   /**
-   * Aggregate metadata into single object
-   * Matches JavaScript SDK Meta.aggregateMeta exactly  
+   * Gets a metadata value by key
    */
-  static aggregateMeta(metaItems) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return {};
-    }
-    const aggregated = {};
-    for (const item of metaItems) {
-      if (item && typeof item === "object" && "key" in item) {
-        const key = String(item.key);
-        if ("value" in item) {
-          aggregated[key] = item.value;
-        } else {
-          const { key: itemKey, ...restOfItem } = item;
-          aggregated[key] = Object.keys(restOfItem).length === 1 && "value" in restOfItem ? restOfItem.value : restOfItem;
-        }
-      }
-    }
-    return aggregated;
+  get(key) {
+    return this.__data.get(`__${String(key)}`);
   }
   /**
-   * Merge multiple metadata arrays
-   * Combines arrays while preserving order and handling duplicates
+   * Sets a metadata value by key
    */
-  static mergeMeta(...metaArrays) {
-    const merged = [];
-    const keysSeen = /* @__PURE__ */ new Set();
-    for (const metaArray of metaArrays) {
-      if (!metaArray || !Array.isArray(metaArray)) {
-        continue;
-      }
-      const normalized = this.normalizeMeta(metaArray);
-      for (const item of normalized) {
-        let finalKey = item.key;
-        let counter = 1;
-        while (keysSeen.has(finalKey)) {
-          finalKey = `${item.key}_${counter}`;
-          counter++;
-        }
-        keysSeen.add(finalKey);
-        merged.push({
-          ...item,
-          key: finalKey
-        });
-      }
-    }
-    return merged;
+  set(key, value) {
+    this.__data.set(`__${String(key)}`, value);
   }
   /**
-   * Filter metadata by key pattern or predicate
+   * Checks if a key exists
    */
-  static filterMeta(metaItems, filter) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return [];
-    }
-    const normalized = this.normalizeMeta(metaItems);
-    if (typeof filter === "string") {
-      return normalized.filter((item) => item.key.includes(filter));
-    }
-    if (filter instanceof RegExp) {
-      return normalized.filter((item) => filter.test(item.key));
-    }
-    if (typeof filter === "function") {
-      return normalized.filter(filter);
-    }
-    return normalized;
+  has(key) {
+    return this.__data.has(`__${String(key)}`);
+  }
+  /**
+   * Gets all keys
+   */
+  keys() {
+    return Array.from(this.__data.keys()).map(
+      (key) => key.startsWith("__") ? key.substring(2) : key
+    );
   }
   /**
-   * Find metadata item by key
+   * Converts Meta object back to plain object
    */
-  static findMeta(metaItems, key) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return null;
+  toJSON() {
+    const object = {};
+    for (const [key, value] of this.__data.entries()) {
+      if (key.startsWith("__")) {
+        const plainKey = key.substring(2);
+        object[plainKey] = value;
+      }
     }
-    const normalized = this.normalizeMeta(metaItems);
-    return normalized.find((item) => item.key === key) || null;
+    return object;
   }
   /**
-   * Get metadata value by key
+   * Creates a typed copy of this Meta object
    */
-  static getMetaValue(metaItems, key, defaultValue = null) {
-    const item = this.findMeta(metaItems, key);
-    return item ? item.value : defaultValue;
+  clone() {
+    return new _Meta(this.toJSON());
   }
   /**
-   * Set or update metadata item by key
+   * Merges another Meta object into this one
    */
-  static setMeta(metaItems, key, value) {
-    const normalized = this.normalizeMeta(metaItems);
-    const existingIndex = normalized.findIndex((item) => item.key === key);
-    const newItem = {
-      key,
-      value
-    };
-    if (existingIndex >= 0) {
-      normalized[existingIndex] = newItem;
-    } else {
-      normalized.push(newItem);
-    }
-    return normalized;
+  merge(other) {
+    const combined = { ...this.toJSON(), ...other.toJSON() };
+    return new _Meta(combined);
   }
   /**
-   * Remove metadata item by key
+   * Type-safe iteration over metadata entries
    */
-  static removeMeta(metaItems, key) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return [];
+  forEach(callback) {
+    for (const [key, value] of this.__data.entries()) {
+      if (key.startsWith("__")) {
+        const plainKey = key.substring(2);
+        callback(value, plainKey);
+      }
     }
-    const normalized = this.normalizeMeta(metaItems);
-    return normalized.filter((item) => item.key !== key);
   }
   /**
-   * Convert metadata to JSON-serializable format
+   * Returns the size of the metadata object
    */
-  static toJSON(metaItems) {
-    return this.aggregateMeta(this.normalizeMeta(metaItems));
+  get size() {
+    return this.__data.size;
   }
   /**
-   * Create metadata from JSON object
+   * Clears all metadata
    */
-  static fromJSON(jsonData) {
-    if (!jsonData || typeof jsonData !== "object") {
-      return [];
-    }
-    return Object.entries(jsonData).map(([key, value]) => ({
-      key,
-      value
-    }));
+  clear() {
+    this.__data.clear();
   }
+};
+
+// src/instance/rules/exception/RuleArgumentException.ts
+init_BaseException();
+var RuleArgumentException = class extends exports.BaseException {
   /**
-   * Validate metadata structure
+   * Constructor
    */
-  static validateMeta(metaItems) {
-    if (!Array.isArray(metaItems)) {
-      return false;
+  constructor(message = "An incorrect argument!") {
+    super("RULE_ARGUMENT_ERROR", message);
+  }
+};
+var RuleArgumentException_default = RuleArgumentException;
+
+// src/libraries/array.ts
+function deepCloning(o, h) {
+  let i;
+  let r;
+  let x;
+  const t = [Array, Date, Number, String, Boolean];
+  const s = Object.prototype.toString;
+  h = h || [];
+  for (i = 0; i < h.length; i += 2) {
+    if (o === h[i]) {
+      return h[i + 1];
     }
-    return metaItems.every(
-      (item) => item && typeof item === "object" && "key" in item && typeof item.key === "string"
-    );
   }
-  /**
-   * Get all unique keys from metadata
-   */
-  static getKeys(metaItems) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return [];
+  if (!r && o && typeof o === "object") {
+    r = {};
+    for (i = 0; i < t.length; i++) {
+      if (s.call(o) === s.call(x = new t[i](o))) {
+        r = i ? x : [];
+      }
     }
-    const normalized = this.normalizeMeta(metaItems);
-    const keys = /* @__PURE__ */ new Set();
-    for (const item of normalized) {
-      keys.add(item.key);
+    h.push(o, r);
+    for (i in o) {
+      if (Object.prototype.hasOwnProperty.call(o, i)) {
+        r[i] = deepCloning(o[i], h);
+      }
     }
-    return Array.from(keys);
+  }
+  return r || o;
+}
+function chunkArray(arr, size) {
+  if (!arr.length) {
+    return [];
+  }
+  return [arr.slice(0, size)].concat(chunkArray(arr.slice(size), size));
+}
+function diff(...arrays) {
+  return [].concat(...arrays.map((arr, i) => {
+    const others = arrays.slice(0);
+    others.splice(i, 1);
+    const unique = [...new Set([].concat(...others))];
+    return arr.filter((item) => !unique.includes(item));
+  }));
+}
+function intersect(...arrays) {
+  if (arrays.length === 0) return [];
+  if (arrays.length === 1) return arrays[0];
+  return arrays.reduce(
+    (first, second) => first.filter((item) => second.includes(item))
+  );
+}
+
+// src/instance/rules/Callback.ts
+init_exception();
+var CallbackParamsSchema = zod.z.object({
+  action: zod.z.string().min(1, "Action cannot be empty"),
+  metaType: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  metaId: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  meta: zod.z.union([zod.z.instanceof(Meta2), zod.z.record(zod.z.unknown()), zod.z.null()]).optional(),
+  address: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  token: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  amount: zod.z.union([zod.z.string(), zod.z.null()]).optional(),
+  comparison: zod.z.union([zod.z.string(), zod.z.null()]).optional()
+}).strict();
+var Callback = class _Callback {
+  __action;
+  __metaType;
+  __metaId;
+  __meta;
+  __address;
+  __token;
+  __amount;
+  __comparison;
+  constructor(params) {
+    const validatedParams = parseWithSchema(CallbackParamsSchema, params, "Callback constructor");
+    if (!validatedParams.action) {
+      throw new RuleArgumentException_default('Callback structure violated, missing mandatory "action" parameter.');
+    }
+    this.__action = validatedParams.action;
+    this.__metaType = validatedParams.metaType ?? null;
+    this.__metaId = validatedParams.metaId ?? null;
+    this.__address = validatedParams.address ?? null;
+    this.__token = validatedParams.token ?? null;
+    this.__amount = validatedParams.amount ?? null;
+    this.__comparison = validatedParams.comparison ?? null;
+    if (validatedParams.meta) {
+      this.__meta = validatedParams.meta instanceof Meta2 ? validatedParams.meta : Meta2.toObject(validatedParams.meta);
+    }
+  }
+  // Setters
+  set comparison(comparison) {
+    this.__comparison = comparison;
+  }
+  set amount(amount) {
+    if (!isNumeric(amount)) {
+      throw new CodeException("Parameter amount should be a string containing numbers");
+    }
+    this.__amount = amount;
+  }
+  set token(token) {
+    this.__token = token;
+  }
+  set address(address) {
+    this.__address = address;
+  }
+  set meta(meta) {
+    this.__meta = meta instanceof Meta2 ? meta : Meta2.toObject(meta);
+  }
+  set metaType(metaType) {
+    this.__metaType = metaType;
+  }
+  set metaId(metaId) {
+    this.__metaId = metaId;
   }
   /**
-   * Check if metadata contains specific key
+   * Creates a Callback from a plain object with validation
    */
-  static hasKey(metaItems, key) {
-    return this.getKeys(metaItems).includes(key);
+  static toObject(object) {
+    return new _Callback(object);
   }
   /**
-   * Get metadata statistics
+   * Converts to JSON representation
    */
-  static getStats(metaItems) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return {
-        totalItems: 0,
-        uniqueKeys: 0,
-        keys: [],
-        valueTypes: {}
-      };
+  toJSON() {
+    const meta = {
+      action: this.__action
+    };
+    if (this.__metaType) {
+      meta.metaType = this.__metaType;
     }
-    const normalized = this.normalizeMeta(metaItems);
-    const keys = this.getKeys(normalized);
-    const valueTypes = {};
-    for (const item of normalized) {
-      const type = item.value === null ? "null" : typeof item.value;
-      valueTypes[type] = (valueTypes[type] || 0) + 1;
+    if (this.__metaId) {
+      meta.metaId = this.__metaId;
     }
-    return {
-      totalItems: normalized.length,
-      uniqueKeys: keys.length,
-      keys,
-      valueTypes
-    };
+    if (this.__meta) {
+      meta.meta = this.__meta.toJSON();
+    }
+    if (this.__address) {
+      meta.address = this.__address;
+    }
+    if (this.__token) {
+      meta.token = this.__token;
+    }
+    if (this.__amount) {
+      meta.amount = this.__amount;
+    }
+    if (this.__comparison) {
+      meta.comparison = this.__comparison;
+    }
+    return meta;
+  }
+  // Action type checkers using discriminated unions
+  isReject() {
+    return this._is("reject");
+  }
+  isMeta() {
+    const prop = intersect(Object.keys(this.toJSON()), ["action", "metaId", "metaType", "meta"]);
+    return prop.length === 4 && this._is("meta");
+  }
+  isCollect() {
+    const prop = intersect(Object.keys(this.toJSON()), ["action", "address", "token", "amount", "comparison"]);
+    return prop.length === 5 && this._is("collect");
+  }
+  isBuffer() {
+    const prop = intersect(Object.keys(this.toJSON()), ["action", "address", "token", "amount", "comparison"]);
+    return prop.length === 5 && this._is("buffer");
+  }
+  isRemit() {
+    const prop = intersect(Object.keys(this.toJSON()), ["action", "token", "amount"]);
+    return prop.length === 3 && this._is("remit");
+  }
+  isBurn() {
+    const prop = intersect(Object.keys(this.toJSON()), ["action", "token", "amount", "comparison"]);
+    return prop.length === 4 && this._is("burn");
   }
   /**
-   * Deep clone metadata array
+   * Private helper to check action type with type narrowing
    */
-  static clone(metaItems) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return [];
-    }
-    const normalized = this.normalizeMeta(metaItems);
-    return normalized.map((item) => ({ ...item }));
+  _is(type) {
+    return this.__action.toLowerCase() === type.toLowerCase();
   }
   /**
-   * Sort metadata by key
+   * Type-safe getter for action
    */
-  static sort(metaItems, descending = false) {
-    if (!metaItems || !Array.isArray(metaItems)) {
-      return [];
-    }
-    const normalized = this.normalizeMeta(metaItems);
-    return normalized.sort((a, b) => {
-      const comparison = a.key.localeCompare(b.key);
-      return descending ? -comparison : comparison;
+  get action() {
+    return this.__action;
+  }
+};
+
+// src/instance/rules/Condition.ts
+var Condition = class {
+  __key;
+  __value;
+  __comparison;
+  constructor({ key, value, comparison }) {
+    if ([key, value, comparison].some((item) => !item)) {
+      throw new RuleArgumentException_default("Condition::constructor( { key, value, comparison } ) - not all class parameters are initialised!");
+    }
+    this.__key = key;
+    this.__value = value;
+    this.__comparison = comparison;
+  }
+  /**
+   * Creates a Condition from a plain object
+   */
+  static toObject(object) {
+    return new this({
+      key: object.key,
+      value: object.value,
+      comparison: object.comparison
     });
   }
+  /**
+   * Converts to JSON representation
+   */
+  toJSON() {
+    return {
+      key: this.__key,
+      value: this.__value,
+      comparison: this.__comparison
+    };
+  }
 };
 
 // src/instance/rules/Rule.ts
+init_exception();
 var Rule = class _Rule {
-  name;
-  conditions;
-  actions;
-  constructor(data = {}) {
-    this.name = data.name || "";
-    this.conditions = data.conditions || [];
-    this.actions = data.actions || [];
+  __condition;
+  __callback;
+  constructor({ condition = [], callback = [] }) {
+    for (const element of condition) {
+      if (!(element instanceof Condition)) {
+        throw new RuleArgumentException_default();
+      }
+    }
+    for (const element of callback) {
+      if (!(element instanceof Callback)) {
+        throw new RuleArgumentException_default();
+      }
+    }
+    this.__condition = condition;
+    this.__callback = callback;
+  }
+  /**
+   * Adds a condition to this rule
+   */
+  set comparison(condition) {
+    this.__condition.push(
+      condition instanceof Condition ? condition : Condition.toObject(condition)
+    );
+  }
+  /**
+   * Adds a callback to this rule
+   */
+  set callback(callback) {
+    this.__callback.push(
+      callback instanceof Callback ? callback : Callback.toObject(callback)
+    );
   }
   /**
    * Convert rule data to Rule object
-   * @param data - Rule data to convert
+   * @param object - Rule data to convert
    * @return Rule instance
    */
-  static toObject(data) {
-    if (data instanceof _Rule) {
-      return data;
+  static toObject(object) {
+    if (!object.condition) {
+      throw new MetaMissingException("Rule::toObject() - Incorrect rule format! There is no condition field.");
     }
-    return new _Rule(data);
+    if (!object.callback) {
+      throw new MetaMissingException("Rule::toObject() - Incorrect rule format! There is no callback field.");
+    }
+    const rule = new _Rule({});
+    for (const condition of object.condition) {
+      rule.comparison = condition;
+    }
+    for (const callback of object.callback) {
+      rule.callback = callback;
+    }
+    return rule;
+  }
+  /**
+   * Converts to JSON representation
+   */
+  toJSON() {
+    return {
+      condition: this.__condition,
+      callback: this.__callback
+    };
   }
-  // TODO: Implement remaining Rule methods
 };
 
 // src/libraries/CheckMolecule.ts
+init_exception();
 init_Dot();
-var CheckMolecule = class {
+var CheckMolecule = class _CheckMolecule {
   molecule;
   /**
    * Initialize CheckMolecule with a molecule to validate
@@ -3724,7 +4647,7 @@ var CheckMolecule = class {
       if (Number.isNaN(firstValue)) {
         throw new TypeError('Invalid isotope "V" values');
       }
-      const remainder = senderWallet.balance + firstValue;
+      const remainder = Number(senderWallet.balance) + firstValue;
       if (remainder < 0) {
         throw new exports.TransferBalanceException();
       }
@@ -3799,6 +4722,77 @@ var CheckMolecule = class {
     }
     return true;
   }
+  /**
+   * Reconstructs a Molecule instance from server-side GraphQL data.
+   * Maps server atom field names to SDK-expected format and parses metasJson.
+   */
+  static fromServerData({
+    molecularHash,
+    bundleHash,
+    cellSlug = null,
+    status = null,
+    createdAt = null,
+    atoms = []
+  }) {
+    const mappedAtoms = atoms.map((serverAtom) => {
+      let meta = [];
+      if (serverAtom.metasJson) {
+        try {
+          const parsed = JSON.parse(serverAtom.metasJson);
+          if (Array.isArray(parsed)) {
+            meta = parsed;
+          } else if (parsed && typeof parsed === "object") {
+            meta = Object.entries(parsed).map(([key, value]) => ({ key, value: String(value) }));
+          }
+        } catch (e) {
+          meta = [];
+        }
+      }
+      return {
+        position: serverAtom.position || null,
+        walletAddress: serverAtom.walletAddress || null,
+        isotope: serverAtom.isotope || null,
+        token: serverAtom.tokenSlug || serverAtom.token || null,
+        value: serverAtom.value != null ? String(serverAtom.value) : null,
+        batchId: serverAtom.batchId || null,
+        metaType: serverAtom.metaType || null,
+        metaId: serverAtom.metaId || null,
+        meta,
+        index: serverAtom.index != null ? serverAtom.index : null,
+        otsFragment: serverAtom.otsFragment || null,
+        createdAt: serverAtom.createdAt || null
+      };
+    });
+    return Molecule.fromJSON({
+      molecularHash,
+      bundle: bundleHash,
+      cellSlug,
+      status,
+      createdAt,
+      atoms: mappedAtoms
+    });
+  }
+  /**
+   * Verifies a molecule reconstructed from server-side GraphQL data.
+   * Returns an object with verification result and any error details.
+   */
+  static verifyFromServerData(moleculeData) {
+    try {
+      const molecule = _CheckMolecule.fromServerData(moleculeData);
+      new _CheckMolecule(molecule).verify();
+      return {
+        molecularHash: moleculeData.molecularHash,
+        verified: true,
+        error: null
+      };
+    } catch (error) {
+      return {
+        molecularHash: moleculeData.molecularHash || null,
+        verified: false,
+        error: error.message || String(error)
+      };
+    }
+  }
 };
 
 // src/core/Molecule.ts
@@ -3815,6 +4809,8 @@ var Molecule = class _Molecule {
   remainderWallet;
   atoms;
   version;
+  continuIdPosition;
+  parentHashes;
   local;
   /**
    * Create new Molecule instance
@@ -3826,7 +4822,8 @@ var Molecule = class _Molecule {
     sourceWallet = null,
     remainderWallet = null,
     cellSlug = null,
-    version = null
+    version = null,
+    continuIdPosition = null
   } = {}) {
     this.status = null;
     this.molecularHash = null;
@@ -3835,11 +4832,12 @@ var Molecule = class _Molecule {
     this.secret = secret;
     this.bundle = bundle;
     this.sourceWallet = sourceWallet;
+    this.continuIdPosition = continuIdPosition;
     this.atoms = [];
-    if (version !== null) {
+    this.parentHashes = [];
+    const versionRegistry = versions_default;
+    if (version !== null && Object.prototype.hasOwnProperty.call(versionRegistry, version)) {
       this.version = String(version);
-    } else {
-      this.version = null;
     }
     if (remainderWallet || sourceWallet) {
       this.remainderWallet = remainderWallet || Wallet.create({
@@ -3874,7 +4872,7 @@ var Molecule = class _Molecule {
     if (!Array.isArray(isotopes)) {
       isotopes = [isotopes];
     }
-    return atoms.filter((atom) => isotopes.includes(atom.isotope));
+    return atoms.filter((atom) => atom.isotope !== null && isotopes.includes(atom.isotope));
   }
   /**
    * Generates the next atomic index
@@ -3895,25 +4893,65 @@ var Molecule = class _Molecule {
   addAtom(atom) {
     this.molecularHash = null;
     atom.index = this.generateIndex();
-    atom.version = this.version ? Number(this.version) : 4;
+    atom.version = this.version ?? void 0;
     this.atoms.push(atom);
     this.atoms = Atom.sortAtoms(this.atoms);
     return this;
   }
   /**
-   * Add user remainder atom for ContinuID
+   * Add user remainder atom for ContinuID
+   * Matches JavaScript SDK addContinuIdAtom exactly
+   */
+  addContinuIdAtom() {
+    if (!this.remainderWallet || this.remainderWallet.token !== "USER") {
+      this.remainderWallet = Wallet.create({
+        secret: this.secret,
+        bundle: this.bundle
+      });
+    }
+    const continuIdMeta = {};
+    if (this.continuIdPosition) {
+      continuIdMeta.previousPosition = this.continuIdPosition;
+    } else if (this.sourceWallet && this.sourceWallet.position) {
+      continuIdMeta.previousPosition = this.sourceWallet.position;
+    }
+    if (this.remainderWallet.pubkey) {
+      continuIdMeta.pubkey = this.remainderWallet.pubkey;
+    }
+    if (this.remainderWallet.characters) {
+      continuIdMeta.characters = this.remainderWallet.characters;
+    }
+    this.addAtom(Atom.create({
+      isotope: "I",
+      wallet: this.remainderWallet,
+      metaType: "walletBundle",
+      metaId: this.remainderWallet.bundle,
+      meta: new AtomMeta(continuIdMeta)
+    }));
+    return this;
+  }
+  /**
+   * Add a policy R-isotope atom (matching JS SDK)
    */
-  addContinuIdAtom() {
-    if (!this.remainderWallet) {
-      throw new Error("Remainder wallet required for ContinuID atom");
-    }
-    this.addAtom(new Atom({
-      isotope: "I",
-      position: this.remainderWallet.position,
-      walletAddress: this.remainderWallet.address,
-      token: "USER",
-      metaType: "walletBundle",
-      metaId: this.remainderWallet.bundle
+  addPolicyAtom({
+    metaType,
+    metaId,
+    meta = {},
+    policy = {}
+  }) {
+    const atomMeta = new AtomMeta(meta);
+    atomMeta.addPolicy(policy);
+    const wallet = Wallet.create({
+      secret: this.secret,
+      bundle: this.sourceWallet.bundle,
+      token: "USER"
+    });
+    this.addAtom(Atom.create({
+      wallet,
+      isotope: "R",
+      metaType,
+      metaId,
+      meta: atomMeta
     }));
     return this;
   }
@@ -3928,34 +4966,25 @@ var Molecule = class _Molecule {
     if (!this.sourceWallet) {
       throw new Error("Source wallet required for value transfer");
     }
-    if (this.sourceWallet.balance - amount < 0) {
+    if (Number(this.sourceWallet.balance) - amount < 0) {
       throw new BalanceInsufficientException();
     }
-    this.addAtom(new Atom({
+    this.addAtom(Atom.create({
       isotope: "V",
-      position: this.sourceWallet.position,
-      walletAddress: this.sourceWallet.address,
-      token: this.sourceWallet.token,
-      value: -this.sourceWallet.balance
+      wallet: this.sourceWallet,
+      value: -Number(this.sourceWallet.balance)
     }));
-    this.addAtom(new Atom({
+    this.addAtom(Atom.create({
       isotope: "V",
-      position: recipientWallet.position,
-      walletAddress: recipientWallet.address,
-      token: recipientWallet.token,
+      wallet: recipientWallet,
       value: amount,
       metaType: "walletBundle",
       metaId: recipientWallet.bundle
     }));
-    if (!this.remainderWallet) {
-      throw new Error("Remainder wallet required for value transfer");
-    }
-    this.addAtom(new Atom({
+    this.addAtom(Atom.create({
       isotope: "V",
-      position: this.remainderWallet.position,
-      walletAddress: this.remainderWallet.address,
-      token: this.remainderWallet.token,
-      value: this.sourceWallet.balance - amount,
+      wallet: this.remainderWallet,
+      value: Number(this.sourceWallet.balance) - amount,
       metaType: "walletBundle",
       metaId: this.remainderWallet.bundle
     }));
@@ -3984,6 +5013,17 @@ var Molecule = class _Molecule {
       throw new SignatureMalformedException("No atoms available for signing!");
     }
     let signingPosition = signingAtom.position;
+    const signingWalletMeta = signingAtom.aggregatedMeta ? signingAtom.aggregatedMeta() : null;
+    const signingWalletJson = signingWalletMeta?.signingWallet;
+    if (signingWalletJson) {
+      try {
+        const parsedSigningWallet = JSON.parse(signingWalletJson);
+        if (parsedSigningWallet.position) {
+          signingPosition = parsedSigningWallet.position;
+        }
+      } catch {
+      }
+    }
     if (!signingPosition) {
       throw new SignatureMalformedException("Signing wallet must have a position!");
     }
@@ -4102,7 +5142,7 @@ var Molecule = class _Molecule {
    */
   toJSON(options = {}) {
     const {
-      includeValidationContext = true,
+      includeValidationContext = false,
       includeOtsFragments = true,
       secureMode = false
     } = options;
@@ -4115,21 +5155,24 @@ var Molecule = class _Molecule {
         molecularHash: this.molecularHash,
         createdAt: this.createdAt,
         cellSlug: this.cellSlug,
-        cellSlugOrigin: this.cellSlugOrigin,
-        version: this.version,
         bundle: this.bundle,
         // Serialized atoms array with optional OTS fragments
         atoms: this.atoms.map((atom) => atom.toJSON({
           includeOtsFragments
         }))
       };
+      if (this.parentHashes && this.parentHashes.length > 0) {
+        serialized.parentHashes = this.parentHashes;
+      }
       if (includeValidationContext) {
+        serialized.cellSlugOrigin = this.cellSlugOrigin;
+        serialized.version = this.version;
         if (this.sourceWallet) {
           serialized.sourceWallet = {
             address: this.sourceWallet.address,
             position: this.sourceWallet.position,
             token: this.sourceWallet.token,
-            balance: this.sourceWallet.balance || 0,
+            balance: this.sourceWallet.balance || "0",
             bundle: this.sourceWallet.bundle,
             batchId: this.sourceWallet.batchId || null,
             characters: this.sourceWallet.characters || "BASE64",
@@ -4145,7 +5188,7 @@ var Molecule = class _Molecule {
             address: this.remainderWallet.address,
             position: this.remainderWallet.position,
             token: this.remainderWallet.token,
-            balance: this.remainderWallet.balance || 0,
+            balance: this.remainderWallet.balance || "0",
             bundle: this.remainderWallet.bundle,
             batchId: this.remainderWallet.batchId || null,
             characters: this.remainderWallet.characters || "BASE64",
@@ -4173,30 +5216,26 @@ var Molecule = class _Molecule {
   // =============================================================================
   /**
    * Initialize token creation
+   * Matches JavaScript SDK initTokenCreation implementation
    */
   initTokenCreation({
     recipientWallet,
     amount,
     meta
   }) {
-    this.addAtom(new Atom({
-      isotope: "T",
-      position: recipientWallet.position,
-      walletAddress: recipientWallet.address,
-      token: recipientWallet.token,
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for token creation");
+    }
+    const atomMeta = new AtomMeta(meta);
+    atomMeta.setMetaWallet(recipientWallet);
+    this.addAtom(Atom.create({
+      isotope: "C",
+      wallet: this.sourceWallet,
       value: amount,
       metaType: "token",
       metaId: recipientWallet.token,
-      meta: meta ? [{ key: "tokenMeta", value: JSON.stringify(meta) }] : []
-    }));
-    this.addAtom(new Atom({
-      isotope: "M",
-      position: recipientWallet.position,
-      walletAddress: recipientWallet.address,
-      token: recipientWallet.token,
-      metaType: "walletBundle",
-      metaId: recipientWallet.bundle,
-      meta: meta ? [{ key: "tokenMeta", value: JSON.stringify(meta) }] : []
+      meta: atomMeta,
+      batchId: recipientWallet.batchId
     }));
     this.addContinuIdAtom();
     return this;
@@ -4206,26 +5245,57 @@ var Molecule = class _Molecule {
    */
   burnToken({
     amount,
-    walletBundle = null
+    walletBundle: _walletBundle = null
   }) {
     if (!this.sourceWallet) {
       throw new Error("Source wallet required for token burning");
     }
-    if (amount <= 0) {
-      throw new NegativeAmountException();
+    if (amount < 0) {
+      throw new NegativeAmountException("Molecule::burnToken() - Amount to burn must be positive!");
     }
-    if (this.sourceWallet.balance - amount < 0) {
+    if (Number(this.sourceWallet.balance) - amount < 0) {
       throw new BalanceInsufficientException();
     }
-    this.addAtom(new Atom({
+    const burnWallet = new Wallet({
+      bundle: "0000000000000000000000000000000000000000000000000000000000000000",
+      token: this.sourceWallet.token
+    });
+    this.addAtom(Atom.create({
       isotope: "V",
-      position: this.sourceWallet.position,
-      walletAddress: this.sourceWallet.address,
-      token: this.sourceWallet.token,
-      value: -amount,
-      metaType: walletBundle ? "walletBundle" : null,
-      metaId: walletBundle || null
+      wallet: this.sourceWallet,
+      value: -Number(this.sourceWallet.balance)
+    }));
+    this.addAtom(Atom.create({
+      isotope: "V",
+      wallet: burnWallet,
+      value: amount,
+      metaType: "walletBundle",
+      metaId: burnWallet.bundle
+    }));
+    this.addAtom(Atom.create({
+      isotope: "V",
+      wallet: this.remainderWallet,
+      value: Number(this.sourceWallet.balance) - amount,
+      metaType: "walletBundle",
+      metaId: this.remainderWallet.bundle
+    }));
+    return this;
+  }
+  /**
+   * Initialize authorization request
+   * Creates U-isotope (authorization) atom for requesting auth token
+   * Matches JavaScript SDK Molecule.initAuthorization
+   */
+  initAuthorization({ meta }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for authorization");
+    }
+    this.addAtom(Atom.create({
+      isotope: "U",
+      wallet: this.sourceWallet,
+      meta: new AtomMeta(meta)
     }));
+    this.addContinuIdAtom();
     return this;
   }
   /**
@@ -4240,59 +5310,123 @@ var Molecule = class _Molecule {
     if (!this.sourceWallet) {
       throw new Error("Source wallet required for meta creation");
     }
-    const metaArray = [];
-    if (meta) {
-      if (Array.isArray(meta)) {
-        metaArray.push(...meta);
-      } else if (typeof meta === "object") {
-        for (const [key, value] of Object.entries(meta)) {
-          metaArray.push({ key, value });
-        }
-      } else {
-        metaArray.push({ key: "value", value: meta });
-      }
-    }
-    if (policy) {
-      metaArray.push({ key: "policy", value: JSON.stringify(policy) });
-    }
-    this.addAtom(new Atom({
+    this.addAtom(Atom.create({
       isotope: "M",
-      position: this.sourceWallet.position,
-      walletAddress: this.sourceWallet.address,
-      token: this.sourceWallet.token,
+      wallet: this.sourceWallet,
       metaType,
       metaId,
-      meta: metaArray
+      meta: new AtomMeta(meta)
     }));
+    if (policy && Object.keys(policy).length > 0) {
+      this.addPolicyAtom({
+        metaType,
+        metaId,
+        meta,
+        policy
+      });
+    }
     this.addContinuIdAtom();
     return this;
   }
   /**
    * Initialize wallet creation
+   * Uses source wallet for atom properties (matching JavaScript SDK)
+   * The wallet being created is stored in metadata
    */
   initWalletCreation(wallet, atomMeta = null) {
-    const atom = new Atom({
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for wallet creation");
+    }
+    if (!atomMeta) {
+      atomMeta = new AtomMeta();
+    }
+    atomMeta.setMetaWallet(wallet);
+    const creationAtom = Atom.create({
       isotope: "C",
-      position: wallet.position,
-      walletAddress: wallet.address,
-      token: wallet.token,
+      wallet: this.sourceWallet,
       metaType: "wallet",
       metaId: wallet.address,
-      meta: atomMeta ? atomMeta.get() : []
+      meta: atomMeta,
+      batchId: wallet.batchId
     });
-    if (!atomMeta) {
-      atom.meta.push(
-        { key: "position", value: wallet.position },
-        { key: "bundle", value: wallet.bundle },
-        { key: "token", value: wallet.token },
-        { key: "batchId", value: wallet.batchId || "" },
-        { key: "characters", value: wallet.characters || "" }
-      );
-      if (wallet.pubkey) {
-        atom.meta.push({ key: "pubkey", value: wallet.pubkey });
-      }
+    this.addAtom(creationAtom);
+    this.addContinuIdAtom();
+    return this;
+  }
+  /**
+   * Creates atoms for rule definition
+   * Matches JavaScript SDK Molecule.createRule method
+   *
+   * @param metaType - The meta type for the rule
+   * @param metaId - The meta ID for the rule
+   * @param rule - Array of Rule objects or rule data
+   * @param policy - Optional policy object
+   * @return This molecule instance for chaining
+   */
+  createRule({
+    metaType,
+    metaId,
+    rule,
+    policy = {}
+  }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for createRule");
+    }
+    const ruleArray = Array.isArray(rule) ? rule : [rule];
+    const rules = [];
+    for (const r of ruleArray) {
+      rules.push(r instanceof Rule ? r : Rule.toObject(r));
+    }
+    const atomMeta = new AtomMeta({
+      rule: JSON.stringify(rules)
+    });
+    if (policy && Object.keys(policy).length > 0) {
+      atomMeta.addPolicy(policy);
+    }
+    this.addAtom(Atom.create({
+      isotope: "R",
+      wallet: this.sourceWallet,
+      metaType,
+      metaId,
+      meta: atomMeta
+    }));
+    this.addContinuIdAtom();
+    return this;
+  }
+  /**
+   * Initializes a token request molecule
+   * Matches JavaScript SDK Molecule.initTokenRequest method
+   *
+   * @param token - Token slug to request
+   * @param amount - Amount of tokens to request
+   * @param metaType - Meta type (typically 'walletBundle')
+   * @param metaId - Meta ID (typically recipient bundle hash)
+   * @param meta - Optional additional metadata
+   * @param batchId - Optional batch ID
+   * @return This molecule instance for chaining
+   */
+  initTokenRequest({
+    token,
+    amount,
+    metaType,
+    metaId,
+    meta = {},
+    batchId = null
+  }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for initTokenRequest");
     }
-    this.addAtom(atom);
+    const metaWithToken = { ...meta, token, amount: String(amount) };
+    this.local = 1;
+    this.addAtom(Atom.create({
+      isotope: "T",
+      wallet: this.sourceWallet,
+      value: amount,
+      metaType,
+      metaId,
+      meta: new AtomMeta(metaWithToken),
+      batchId
+    }));
     this.addContinuIdAtom();
     return this;
   }
@@ -4342,6 +5476,7 @@ var Molecule = class _Molecule {
           }
         });
       }
+      molecule.parentHashes = Array.isArray(data.parentHashes) ? [...data.parentHashes] : [];
       if (includeValidationContext) {
         if (data.sourceWallet) {
           molecule.sourceWallet = new Wallet({
@@ -4352,7 +5487,7 @@ var Molecule = class _Molecule {
             batchId: data.sourceWallet.batchId,
             characters: data.sourceWallet.characters
           });
-          molecule.sourceWallet.balance = data.sourceWallet.balance || 0;
+          molecule.sourceWallet.balance = String(data.sourceWallet.balance != null ? data.sourceWallet.balance : 0);
           molecule.sourceWallet.address = data.sourceWallet.address;
           if (data.sourceWallet.pubkey) {
             molecule.sourceWallet.pubkey = data.sourceWallet.pubkey;
@@ -4370,7 +5505,7 @@ var Molecule = class _Molecule {
             batchId: data.remainderWallet.batchId,
             characters: data.remainderWallet.characters
           });
-          molecule.remainderWallet.balance = data.remainderWallet.balance || 0;
+          molecule.remainderWallet.balance = String(data.remainderWallet.balance != null ? data.remainderWallet.balance : 0);
           molecule.remainderWallet.address = data.remainderWallet.address;
           if (data.remainderWallet.pubkey) {
             molecule.remainderWallet.pubkey = data.remainderWallet.pubkey;
@@ -4391,245 +5526,208 @@ var Molecule = class _Molecule {
   static jsonToObject(json) {
     return _Molecule.fromJSON(json);
   }
-};
-var AtomMeta = class _AtomMeta {
-  meta;
-  /**
-   * Create new AtomMeta instance
-   * @param meta - Initial metadata (object or array)
-   */
-  constructor(meta = null) {
-    this.meta = Meta.normalizeMeta(meta);
-  }
+  // =============================================================================
+  // ISOTOPE INIT METHODS - MATCHING JAVASCRIPT SDK PARITY
+  // =============================================================================
   /**
-   * Merge additional metadata
-   * @param meta - Metadata to merge
-   * @return This instance for chaining
+   * Initialize a P-type molecule for peer registration
+   * Matches JavaScript SDK Molecule.initPeering implementation exactly
+   *
+   * @param host - The peer host URL to register
+   * @return This molecule instance for chaining
    */
-  merge(meta) {
-    const normalized = Meta.normalizeMeta(meta);
-    const existingKeys = new Set(this.meta.map((m) => m.key));
-    for (const item of normalized) {
-      if (existingKeys.has(item.key)) {
-        const index = this.meta.findIndex((m) => m.key === item.key);
-        if (index !== -1) {
-          this.meta[index] = item;
-        }
-      } else {
-        this.meta.push(item);
-        existingKeys.add(item.key);
-      }
+  initPeering({ host }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for peer registration");
     }
+    this.addAtom(Atom.create({
+      isotope: "P",
+      wallet: this.sourceWallet,
+      metaType: "walletBundle",
+      metaId: this.bundle,
+      meta: new AtomMeta({ peerHost: host })
+    }));
+    this.addContinuIdAtom();
     return this;
   }
   /**
-   * Add context metadata if enabled
-   * @param context - Context URL or null for default
-   * @return This instance for chaining
-   */
-  addContext(context = null) {
-    return this;
-  }
-  /**
-   * Set atom wallet metadata
-   * @param wallet - Wallet to extract metadata from
-   * @return This instance for chaining
+   * Initialize an A-type molecule for an append request
+   * Matches JavaScript SDK Molecule.initAppendRequest implementation exactly
+   *
+   * @param metaType - The target MetaType to append to
+   * @param metaId - The target MetaId to append to
+   * @param action - The action to perform
+   * @param meta - Additional metadata
+   * @return This molecule instance for chaining
    */
-  setAtomWallet(wallet) {
-    const walletMeta = {
-      pubkey: wallet.pubkey,
-      characters: wallet.characters
-    };
-    if (wallet.tokenUnits && wallet.tokenUnits.length) {
-      walletMeta.tokenUnits = JSON.stringify(wallet.getTokenUnitsData ? wallet.getTokenUnitsData() : wallet.tokenUnits);
-    }
-    if (wallet.tradeRates && Object.keys(wallet.tradeRates).length) {
-      walletMeta.tradeRates = JSON.stringify(wallet.tradeRates);
+  initAppendRequest({
+    metaType,
+    metaId,
+    action,
+    meta = {}
+  }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for append request");
     }
-    this.merge(walletMeta);
-    return this;
-  }
-  /**
-   * Set full NEW wallet metadata
-   * Used for shadow wallet claim & wallet creation & token creation
-   * @param wallet - Wallet with full metadata
-   * @return This instance for chaining
-   */
-  setMetaWallet(wallet) {
-    this.merge({
-      walletTokenSlug: wallet.token,
-      walletBundleHash: wallet.bundle,
-      walletAddress: wallet.address,
-      walletPosition: wallet.position,
-      walletBatchId: wallet.batchId,
-      walletPubkey: wallet.pubkey,
-      walletCharacters: wallet.characters
-    });
-    return this;
-  }
-  /**
-   * Set shadow wallet claim flag
-   * @param shadowWalletClaim - Claim flag (converted to number)
-   * @return This instance for chaining
-   */
-  setShadowWalletClaim(shadowWalletClaim) {
-    this.merge({ shadowWalletClaim: Number(shadowWalletClaim) });
-    return this;
-  }
-  /**
-   * Set signing wallet metadata
-   * @param signingWallet - Wallet used for signing
-   * @return This instance for chaining
-   */
-  setSigningWallet(signingWallet) {
-    this.merge({
-      signingWallet: JSON.stringify({
-        tokenSlug: signingWallet.token,
-        bundleHash: signingWallet.bundle,
-        address: signingWallet.address,
-        position: signingWallet.position,
-        pubkey: signingWallet.pubkey,
-        characters: signingWallet.characters
-      })
-    });
-    return this;
-  }
-  /**
-   * Add policy metadata
-   * @param policy - Policy object to add
-   * @return This instance for chaining
-   */
-  addPolicy(policy) {
-    this.merge({
-      policy: JSON.stringify(policy)
-    });
+    this.addAtom(Atom.create({
+      isotope: "A",
+      wallet: this.sourceWallet,
+      metaType,
+      metaId,
+      meta: new AtomMeta({ action, ...meta })
+    }));
+    this.addContinuIdAtom();
     return this;
   }
   /**
-   * Get the normalized metadata array
-   * @return Array of normalized metadata items
-   */
-  get() {
-    return this.meta;
-  }
-  /**
-   * Convert metadata to plain object
-   * @return Aggregated metadata object
-   */
-  toObject() {
-    return Meta.aggregateMeta(this.meta);
-  }
-  /**
-   * Convert metadata to JSON string
-   * @return JSON string representation
-   */
-  toJSON() {
-    return JSON.stringify(this.toObject());
-  }
-  /**
-   * Get metadata value by key
-   * @param key - Key to lookup
-   * @param defaultValue - Default if not found
-   * @return Value or default
-   */
-  getValue(key, defaultValue = null) {
-    return Meta.getMetaValue(this.meta, key, defaultValue);
-  }
-  /**
-   * Check if metadata has a key
-   * @param key - Key to check
-   * @return True if key exists
-   */
-  hasKey(key) {
-    return Meta.hasKey(this.meta, key);
-  }
-  /**
-   * Remove metadata by key
-   * @param key - Key to remove
-   * @return This instance for chaining
+   * Initialize a deposit buffer operation (B-isotope)
+   * Matches JavaScript SDK Molecule.initDepositBuffer implementation exactly
+   *
+   * @param amount - Amount to deposit into buffer
+   * @param tradeRates - Trade rates for the buffer wallet
+   * @return This molecule instance for chaining
    */
-  remove(key) {
-    this.meta = Meta.removeMeta(this.meta, key);
+  initDepositBuffer({
+    amount,
+    tradeRates
+  }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for buffer deposit");
+    }
+    if (Number(this.sourceWallet.balance) - amount < 0) {
+      throw new BalanceInsufficientException();
+    }
+    const bufferWallet = Wallet.create({
+      secret: this.secret,
+      bundle: this.bundle,
+      token: this.sourceWallet.token,
+      batchId: this.sourceWallet.batchId
+    });
+    if (tradeRates) {
+      bufferWallet.tradeRates = tradeRates;
+    }
+    this.addAtom(Atom.create({
+      isotope: "V",
+      wallet: this.sourceWallet,
+      value: -Number(this.sourceWallet.balance)
+    }));
+    this.addAtom(Atom.create({
+      isotope: "B",
+      wallet: bufferWallet,
+      value: amount,
+      metaType: "walletBundle",
+      metaId: this.sourceWallet.bundle
+    }));
+    this.addAtom(Atom.create({
+      isotope: "V",
+      wallet: this.remainderWallet,
+      value: Number(this.sourceWallet.balance) - amount,
+      metaType: "walletBundle",
+      metaId: this.sourceWallet.bundle
+    }));
     return this;
   }
   /**
-   * Clear all metadata
-   * @return This instance for chaining
+   * Initialize a withdraw buffer operation (B-isotope)
+   * Matches JavaScript SDK Molecule.initWithdrawBuffer implementation exactly
+   *
+   * @param recipients - Map of recipientBundle → amount
+   * @param signingWallet - Optional signing wallet for reconciliation
+   * @return This molecule instance for chaining
    */
-  clear() {
-    this.meta = [];
+  initWithdrawBuffer({
+    recipients,
+    signingWallet = null
+  }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for buffer withdrawal");
+    }
+    let amount = 0;
+    for (const recipientAmount of Object.values(recipients || {})) {
+      amount += recipientAmount;
+    }
+    if (Number(this.sourceWallet.balance) - amount < 0) {
+      throw new BalanceInsufficientException();
+    }
+    const firstAtomMeta = new AtomMeta();
+    if (signingWallet) {
+      firstAtomMeta.setSigningWallet(signingWallet);
+    }
+    this.addAtom(Atom.create({
+      isotope: "B",
+      wallet: this.sourceWallet,
+      value: -Number(this.sourceWallet.balance),
+      meta: firstAtomMeta,
+      metaType: "walletBundle",
+      metaId: this.sourceWallet.bundle
+    }));
+    for (const [recipientBundle, recipientAmount] of Object.entries(recipients || {})) {
+      this.addAtom(new Atom({
+        isotope: "V",
+        token: this.sourceWallet.token,
+        value: recipientAmount,
+        batchId: this.sourceWallet.batchId ? generateBatchId({}) : null,
+        metaType: "walletBundle",
+        metaId: recipientBundle
+      }));
+    }
+    this.addAtom(Atom.create({
+      isotope: "B",
+      wallet: this.remainderWallet,
+      value: Number(this.sourceWallet.balance) - amount,
+      metaType: "walletBundle",
+      metaId: this.remainderWallet.bundle
+    }));
     return this;
   }
   /**
-   * Get count of metadata items
-   * @return Number of items
+   * Initialize shadow wallet claim
+   * Matches JavaScript SDK Molecule.initShadowWalletClaim implementation exactly
+   *
+   * @param wallet - The shadow wallet to claim
+   * @return This molecule instance for chaining
    */
-  count() {
-    return this.meta.length;
+  initShadowWalletClaim(wallet) {
+    const atomMeta = new AtomMeta();
+    atomMeta.setShadowWalletClaim(true);
+    return this.initWalletCreation(wallet, atomMeta);
   }
   /**
-   * Clone this AtomMeta instance
-   * @return New AtomMeta with same data
+   * Initialize identifier creation
+   * Matches JavaScript SDK Molecule.initIdentifierCreation implementation exactly
+   *
+   * @param type - Identifier type (phone or email)
+   * @param contact - Phone number or email string
+   * @param code - Verification code
+   * @return This molecule instance for chaining
    */
-  clone() {
-    return new _AtomMeta(Meta.clone(this.meta));
+  initIdentifierCreation({
+    type,
+    contact,
+    code
+  }) {
+    if (!this.sourceWallet) {
+      throw new Error("Source wallet required for identifier creation");
+    }
+    const meta = {
+      code,
+      hash: generateBundleHash(contact.trim(), "Molecule::initIdentifierCreation")
+    };
+    this.addAtom(Atom.create({
+      isotope: "C",
+      wallet: this.sourceWallet,
+      metaType: "identifier",
+      metaId: type,
+      meta: new AtomMeta(meta)
+    }));
+    this.addContinuIdAtom();
+    return this;
   }
 };
 
 // src/index.ts
 init_Dot();
 
-// src/libraries/array.ts
-function deepCloning(o, h) {
-  let i;
-  let r;
-  let x;
-  const t = [Array, Date, Number, String, Boolean];
-  const s = Object.prototype.toString;
-  h = h || [];
-  for (i = 0; i < h.length; i += 2) {
-    if (o === h[i]) {
-      return h[i + 1];
-    }
-  }
-  if (!r && o && typeof o === "object") {
-    r = {};
-    for (i = 0; i < t.length; i++) {
-      if (s.call(o) === s.call(x = new t[i](o))) {
-        r = i ? x : [];
-      }
-    }
-    h.push(o, r);
-    for (i in o) {
-      if (Object.prototype.hasOwnProperty.call(o, i)) {
-        r[i] = deepCloning(o[i], h);
-      }
-    }
-  }
-  return r || o;
-}
-function chunkArray(arr, size) {
-  if (!arr.length) {
-    return [];
-  }
-  return [arr.slice(0, size)].concat(chunkArray(arr.slice(size), size));
-}
-function diff(...arrays) {
-  return [].concat(...arrays.map((arr, i) => {
-    const others = arrays.slice(0);
-    others.splice(i, 1);
-    const unique = [...new Set([].concat(...others))];
-    return arr.filter((item) => !unique.includes(item));
-  }));
-}
-function intersect(...arrays) {
-  if (arrays.length === 0) return [];
-  if (arrays.length === 1) return arrays[0];
-  return arrays.reduce(
-    (first, second) => first.filter((item) => second.includes(item))
-  );
-}
-
 // src/libraries/Decimal.ts
 var MULTIPLIER = 10 ** 18;
 var Decimal = class _Decimal {
@@ -4841,6 +5939,129 @@ var GraphQLClient = class {
   }
 };
 
+// src/AuthToken.ts
+var AuthToken = class _AuthToken {
+  $__token;
+  $__expiresAt;
+  $__pubkey;
+  $__encrypt;
+  $__wallet;
+  /**
+   * Create new AuthToken instance
+   */
+  constructor({
+    token,
+    expiresAt,
+    encrypt,
+    pubkey
+  }) {
+    this.$__token = token;
+    this.$__expiresAt = expiresAt;
+    this.$__pubkey = pubkey;
+    this.$__encrypt = encrypt;
+  }
+  /**
+   * Static factory method to create AuthToken with wallet
+   */
+  static create(data, wallet) {
+    const authToken = new _AuthToken(data);
+    authToken.setWallet(wallet);
+    return authToken;
+  }
+  /**
+   * Restore AuthToken from snapshot
+   */
+  static restore(snapshot, secret) {
+    const wallet = new Wallet({
+      secret,
+      token: "AUTH",
+      position: snapshot.wallet.position,
+      characters: snapshot.wallet.characters
+    });
+    return _AuthToken.create({
+      token: snapshot.token,
+      expiresAt: snapshot.expiresAt,
+      pubkey: snapshot.pubkey,
+      encrypt: snapshot.encrypt
+    }, wallet);
+  }
+  /**
+   * Set wallet for this auth token
+   */
+  setWallet(wallet) {
+    this.$__wallet = wallet;
+  }
+  /**
+   * Get wallet
+   */
+  getWallet() {
+    return this.$__wallet;
+  }
+  /**
+   * Get auth token
+   */
+  getToken() {
+    return this.$__token;
+  }
+  /**
+   * Get expiration timestamp
+   */
+  getExpiresAt() {
+    return this.$__expiresAt;
+  }
+  /**
+   * Get public key
+   */
+  getPubkey() {
+    return this.$__pubkey;
+  }
+  /**
+   * Check if encryption is enabled
+   */
+  isEncrypted() {
+    return this.$__encrypt;
+  }
+  /**
+   * Get expire interval in milliseconds (matching JS SDK pattern)
+   */
+  getExpireInterval() {
+    return this.$__expiresAt * 1e3 - Date.now();
+  }
+  /**
+   * Check if token is expired
+   */
+  isExpired() {
+    return !this.$__expiresAt || this.getExpireInterval() < 0;
+  }
+  /**
+   * Get auth data for GraphQL client
+   */
+  getAuthData() {
+    return {
+      token: this.$__token,
+      pubkey: this.$__pubkey,
+      wallet: this.$__wallet
+    };
+  }
+  /**
+   * Create snapshot for persistence
+   */
+  toSnapshot() {
+    return {
+      token: this.$__token,
+      expiresAt: this.$__expiresAt,
+      pubkey: this.$__pubkey,
+      encrypt: this.$__encrypt,
+      ...this.$__wallet ? {
+        wallet: {
+          position: this.$__wallet.position,
+          characters: this.$__wallet.characters
+        }
+      } : {}
+    };
+  }
+};
+
 // src/query/Query.ts
 init_exception();
 var Query = class {
@@ -5004,36 +6225,36 @@ var Mutation = class extends Query {
 function createBrandedSchema(name, baseSchema = zod.z.string()) {
   return baseSchema.brand(name);
 }
-var WalletAddressSchema = createBrandedSchema(
+var WalletAddressSchema2 = createBrandedSchema(
   "WalletAddress",
   zod.z.string().regex(/^[0-9a-fA-F]{64}$/, "Invalid wallet address format")
 );
-var BundleHashSchema = createBrandedSchema(
+var BundleHashSchema2 = createBrandedSchema(
   "BundleHash",
   zod.z.string().regex(/^[0-9a-fA-F]{64}$/, "Invalid bundle hash format")
 );
-var PositionSchema = createBrandedSchema(
+var PositionSchema2 = createBrandedSchema(
   "Position",
   zod.z.string().regex(/^[0-9a-fA-F]{64}$/, "Invalid position format")
 );
-var MolecularHashSchema = createBrandedSchema(
+var MolecularHashSchema2 = createBrandedSchema(
   "MolecularHash",
   zod.z.string().regex(/^[0-9a-g]+$/, "Invalid molecular hash format (base17)")
 );
-var TokenSlugSchema = createBrandedSchema(
+var TokenSlugSchema2 = createBrandedSchema(
   "TokenSlug",
   zod.z.string().min(1).max(32).regex(/^[A-Z0-9_]+$/, "Token slug must be uppercase alphanumeric")
 );
-var BatchIdSchema = createBrandedSchema(
+var BatchIdSchema2 = createBrandedSchema(
   "BatchId",
   zod.z.string().uuid("Invalid batch ID format")
 );
-var CellSlugSchema = createBrandedSchema(
+var CellSlugSchema2 = createBrandedSchema(
   "CellSlug",
   zod.z.string().min(1).max(64).regex(/^[a-zA-Z0-9\-_.]+$/, "Invalid cell slug format")
 );
 var ISOTOPES2 = ["C", "V", "U", "T", "M", "I", "R", "B", "F"];
-var AtomIsotopeSchema = zod.z.enum(ISOTOPES2);
+var AtomIsotopeSchema2 = zod.z.enum(ISOTOPES2);
 zod.z.object({
   isotope: zod.z.literal("V"),
   value: zod.z.union([zod.z.string(), zod.z.number()]).refine(
@@ -5053,17 +6274,17 @@ zod.z.object({
 zod.z.object({
   isotope: zod.z.literal("C")
 }).strict();
-var MetaDataSchema = zod.z.lazy(
+var MetaDataSchema2 = zod.z.lazy(
   () => zod.z.union([
     zod.z.string(),
     zod.z.number(),
     zod.z.boolean(),
     zod.z.null(),
-    zod.z.record(zod.z.string(), MetaDataSchema),
-    zod.z.array(MetaDataSchema)
+    zod.z.record(zod.z.string(), MetaDataSchema2),
+    zod.z.array(MetaDataSchema2)
   ])
 );
-var AtomMetaDataSchema = zod.z.object({
+var AtomMetaDataSchema2 = zod.z.object({
   key: zod.z.string().min(1),
   value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()])
 }).strict();
@@ -5071,44 +6292,44 @@ zod.z.object({
   key: zod.z.string(),
   value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.boolean(), zod.z.null()])
 }).passthrough();
-var AtomParamsSchema = zod.z.object({
+var AtomParamsSchema2 = zod.z.object({
   position: zod.z.string().optional(),
-  walletAddress: zod.z.union([WalletAddressSchema, zod.z.string()]).optional(),
-  isotope: AtomIsotopeSchema.default("C"),
-  token: zod.z.union([TokenSlugSchema, zod.z.string()]).default("USER"),
+  walletAddress: zod.z.union([WalletAddressSchema2, zod.z.string()]).optional(),
+  isotope: AtomIsotopeSchema2.default("C"),
+  token: zod.z.union([TokenSlugSchema2, zod.z.string()]).default("USER"),
   value: zod.z.union([zod.z.string(), zod.z.number(), zod.z.null()]).optional(),
-  batchId: zod.z.union([BatchIdSchema, zod.z.string(), zod.z.null()]).optional(),
+  batchId: zod.z.union([BatchIdSchema2, zod.z.string(), zod.z.null()]).optional(),
   metaType: zod.z.string().optional(),
   metaId: zod.z.string().optional(),
-  meta: zod.z.array(AtomMetaDataSchema).optional(),
+  meta: zod.z.array(AtomMetaDataSchema2).optional(),
   otsFragment: zod.z.string().optional(),
   index: zod.z.number().int().min(0).optional(),
   createdAt: zod.z.string().optional(),
   version: zod.z.number().int().min(1).optional()
 }).strict();
-var WalletParamsSchema = zod.z.object({
+var WalletParamsSchema2 = zod.z.object({
   secret: zod.z.string().optional(),
-  bundle: zod.z.union([BundleHashSchema, zod.z.string()]).optional(),
-  token: zod.z.union([TokenSlugSchema, zod.z.string()]).default("USER"),
-  address: zod.z.union([WalletAddressSchema, zod.z.string()]).optional(),
-  position: zod.z.union([PositionSchema, zod.z.string()]).optional(),
-  batchId: zod.z.union([BatchIdSchema, zod.z.string()]).optional(),
+  bundle: zod.z.union([BundleHashSchema2, zod.z.string()]).optional(),
+  token: zod.z.union([TokenSlugSchema2, zod.z.string()]).default("USER"),
+  address: zod.z.union([WalletAddressSchema2, zod.z.string()]).optional(),
+  position: zod.z.union([PositionSchema2, zod.z.string()]).optional(),
+  batchId: zod.z.union([BatchIdSchema2, zod.z.string()]).optional(),
   characters: zod.z.string().optional()
 }).strict();
-var MoleculeParamsSchema = zod.z.object({
+var MoleculeParamsSchema2 = zod.z.object({
   secret: zod.z.string().optional(),
-  bundle: zod.z.union([BundleHashSchema, zod.z.string()]).optional(),
-  sourceWallet: WalletParamsSchema.optional(),
-  remainderWallet: WalletParamsSchema.optional(),
-  cellSlug: zod.z.union([CellSlugSchema, zod.z.string()]).optional(),
+  bundle: zod.z.union([BundleHashSchema2, zod.z.string()]).optional(),
+  sourceWallet: WalletParamsSchema2.optional(),
+  remainderWallet: WalletParamsSchema2.optional(),
+  cellSlug: zod.z.union([CellSlugSchema2, zod.z.string()]).optional(),
   version: zod.z.number().int().min(1).optional()
 }).strict();
-var KnishIOClientConfigSchema = zod.z.object({
+var KnishIOClientConfigSchema2 = zod.z.object({
   uri: zod.z.union([
     zod.z.string().url("Invalid URI format"),
     zod.z.array(zod.z.string().url("Invalid URI format")).min(1)
   ]).optional(),
-  cellSlug: zod.z.union([CellSlugSchema, zod.z.string()]).optional(),
+  cellSlug: zod.z.union([CellSlugSchema2, zod.z.string()]).optional(),
   client: zod.z.unknown().optional(),
   socket: zod.z.unknown().optional(),
   serverSdkVersion: zod.z.number().int().min(1).max(10).default(4),
@@ -5121,48 +6342,48 @@ var EnvironmentConfigSchema = zod.z.object({
   KNISHIO_LOGGING: zod.z.string().transform((val) => val === "true").default("false"),
   KNISHIO_SERVER_SDK_VERSION: zod.z.string().transform((val) => parseInt(val, 10)).default("4")
 }).partial();
-var TransferParamsSchema = zod.z.object({
-  recipient: zod.z.union([WalletAddressSchema, zod.z.string()]),
+var TransferParamsSchema2 = zod.z.object({
+  recipient: zod.z.union([WalletAddressSchema2, zod.z.string()]),
   amount: zod.z.union([zod.z.number(), zod.z.string()]).refine(
     (val) => Number(val) > 0,
     "Amount must be positive"
   ),
-  token: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+  token: zod.z.union([TokenSlugSchema2, zod.z.string()]).optional(),
   callbackUrl: zod.z.string().url().optional(),
   metaType: zod.z.string().optional(),
   metaId: zod.z.string().optional(),
-  meta: MetaDataSchema.optional()
+  meta: MetaDataSchema2.optional()
 }).strict();
-var CreateTokenParamsSchema = zod.z.object({
-  token: zod.z.union([TokenSlugSchema, zod.z.string()]),
+var CreateTokenParamsSchema2 = zod.z.object({
+  token: zod.z.union([TokenSlugSchema2, zod.z.string()]),
   amount: zod.z.union([zod.z.number(), zod.z.string()]).refine(
     (val) => Number(val) > 0,
     "Amount must be positive"
   ),
   metaType: zod.z.string().optional(),
   metaId: zod.z.string().optional(),
-  meta: MetaDataSchema.optional(),
+  meta: MetaDataSchema2.optional(),
   fungible: zod.z.boolean().default(true),
   splittable: zod.z.number().int().min(0).optional(),
-  supplyToken: zod.z.union([TokenSlugSchema, zod.z.string()]).optional()
+  supplyToken: zod.z.union([TokenSlugSchema2, zod.z.string()]).optional()
 }).strict();
-var RequestTokensParamsSchema = zod.z.object({
+var RequestTokensParamsSchema2 = zod.z.object({
   amount: zod.z.union([zod.z.number(), zod.z.string()]).refine(
     (val) => Number(val) > 0,
     "Amount must be positive"
   ),
-  token: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+  token: zod.z.union([TokenSlugSchema2, zod.z.string()]).optional(),
   metaType: zod.z.string().optional(),
   metaId: zod.z.string().optional(),
-  meta: MetaDataSchema.optional()
+  meta: MetaDataSchema2.optional()
 }).strict();
-var BalanceQueryParamsSchema = zod.z.object({
-  address: zod.z.union([WalletAddressSchema, zod.z.string()]).optional(),
-  bundleHash: zod.z.union([BundleHashSchema, zod.z.string()]).optional(),
-  token: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+var BalanceQueryParamsSchema2 = zod.z.object({
+  address: zod.z.union([WalletAddressSchema2, zod.z.string()]).optional(),
+  bundleHash: zod.z.union([BundleHashSchema2, zod.z.string()]).optional(),
+  token: zod.z.union([TokenSlugSchema2, zod.z.string()]).optional(),
   type: zod.z.enum(["token", "user"]).optional()
 }).strict();
-var MetaQueryParamsSchema = zod.z.object({
+var MetaQueryParamsSchema2 = zod.z.object({
   metaType: zod.z.string().min(1),
   metaId: zod.z.string().optional(),
   key: zod.z.string().optional(),
@@ -5172,33 +6393,33 @@ var MetaQueryParamsSchema = zod.z.object({
   queryArgs: zod.z.record(zod.z.unknown()).optional(),
   count: zod.z.number().int().min(0).optional(),
   countBy: zod.z.string().optional(),
-  cellSlug: zod.z.union([CellSlugSchema, zod.z.string()]).optional()
+  cellSlug: zod.z.union([CellSlugSchema2, zod.z.string()]).optional()
 }).strict();
-var WalletQueryParamsSchema = zod.z.object({
-  bundleHash: zod.z.union([BundleHashSchema, zod.z.string()]).optional(),
-  tokenSlug: zod.z.union([TokenSlugSchema, zod.z.string()]).optional(),
+var WalletQueryParamsSchema2 = zod.z.object({
+  bundleHash: zod.z.union([BundleHashSchema2, zod.z.string()]).optional(),
+  tokenSlug: zod.z.union([TokenSlugSchema2, zod.z.string()]).optional(),
   unspent: zod.z.boolean().optional()
 }).strict();
-var AuthTokenParamsSchema = zod.z.object({
+var AuthTokenParamsSchema2 = zod.z.object({
   token: zod.z.string().min(1),
   expiresAt: zod.z.number().int().min(0),
   encrypt: zod.z.boolean(),
   pubkey: zod.z.string().min(1)
 }).strict();
-var AuthParamsSchema = zod.z.object({
-  cellSlug: zod.z.union([CellSlugSchema, zod.z.string()]).optional(),
+var AuthParamsSchema2 = zod.z.object({
+  cellSlug: zod.z.union([CellSlugSchema2, zod.z.string()]).optional(),
   encrypt: zod.z.boolean().optional(),
   callback: zod.z.function().optional()
 }).strict();
-var GuestAuthParamsSchema = zod.z.object({
-  cellSlug: zod.z.union([CellSlugSchema, zod.z.string()]).optional()
+var GuestAuthParamsSchema2 = zod.z.object({
+  cellSlug: zod.z.union([CellSlugSchema2, zod.z.string()]).optional()
 }).strict();
-var GraphQLRequestSchema = zod.z.object({
+var GraphQLRequestSchema2 = zod.z.object({
   query: zod.z.string().min(1),
   variables: zod.z.record(zod.z.unknown()).optional(),
   operationName: zod.z.string().optional()
 }).strict();
-var GraphQLErrorSchema = zod.z.object({
+var GraphQLErrorSchema2 = zod.z.object({
   message: zod.z.string(),
   locations: zod.z.array(zod.z.object({
     line: zod.z.number().int(),
@@ -5207,9 +6428,9 @@ var GraphQLErrorSchema = zod.z.object({
   path: zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])).optional(),
   extensions: zod.z.record(zod.z.unknown()).optional()
 }).strict();
-var GraphQLResponseSchema = zod.z.object({
+var GraphQLResponseSchema2 = zod.z.object({
   data: zod.z.unknown().optional(),
-  errors: zod.z.array(GraphQLErrorSchema).optional(),
+  errors: zod.z.array(GraphQLErrorSchema2).optional(),
   extensions: zod.z.record(zod.z.unknown()).optional()
 }).strict();
 function safeParse(schema, data) {
@@ -5236,35 +6457,35 @@ function createTypeGuard(schema) {
 }
 var Schemas = {
   // Core types
-  WalletAddress: WalletAddressSchema,
-  BundleHash: BundleHashSchema,
-  Position: PositionSchema,
-  MolecularHash: MolecularHashSchema,
-  TokenSlug: TokenSlugSchema,
-  BatchId: BatchIdSchema,
-  CellSlug: CellSlugSchema,
+  WalletAddress: WalletAddressSchema2,
+  BundleHash: BundleHashSchema2,
+  Position: PositionSchema2,
+  MolecularHash: MolecularHashSchema2,
+  TokenSlug: TokenSlugSchema2,
+  BatchId: BatchIdSchema2,
+  CellSlug: CellSlugSchema2,
   // Entities
-  AtomParams: AtomParamsSchema,
-  WalletParams: WalletParamsSchema,
-  MoleculeParams: MoleculeParamsSchema,
+  AtomParams: AtomParamsSchema2,
+  WalletParams: WalletParamsSchema2,
+  MoleculeParams: MoleculeParamsSchema2,
   // Configuration
-  ClientConfig: KnishIOClientConfigSchema,
+  ClientConfig: KnishIOClientConfigSchema2,
   EnvironmentConfig: EnvironmentConfigSchema,
   // Operations
-  TransferParams: TransferParamsSchema,
-  CreateTokenParams: CreateTokenParamsSchema,
-  RequestTokensParams: RequestTokensParamsSchema,
+  TransferParams: TransferParamsSchema2,
+  CreateTokenParams: CreateTokenParamsSchema2,
+  RequestTokensParams: RequestTokensParamsSchema2,
   // Queries
-  BalanceQueryParams: BalanceQueryParamsSchema,
-  MetaQueryParams: MetaQueryParamsSchema,
-  WalletQueryParams: WalletQueryParamsSchema,
+  BalanceQueryParams: BalanceQueryParamsSchema2,
+  MetaQueryParams: MetaQueryParamsSchema2,
+  WalletQueryParams: WalletQueryParamsSchema2,
   // Auth
-  AuthTokenParams: AuthTokenParamsSchema,
-  AuthParams: AuthParamsSchema,
-  GuestAuthParams: GuestAuthParamsSchema,
+  AuthTokenParams: AuthTokenParamsSchema2,
+  AuthParams: AuthParamsSchema2,
+  GuestAuthParams: GuestAuthParamsSchema2,
   // GraphQL
-  GraphQLRequest: GraphQLRequestSchema,
-  GraphQLResponse: GraphQLResponseSchema
+  GraphQLRequest: GraphQLRequestSchema2,
+  GraphQLResponse: GraphQLResponseSchema2
 };
 
 // src/validation/ValidationService.ts
@@ -5943,7 +7164,8 @@ var ResponseBalance = class _ResponseBalance extends exports.Response {
    * Matches JavaScript SDK payload() method exactly
    */
   payload() {
-    const walletData = this.data();
+    const balanceData = this.data();
+    const walletData = Array.isArray(balanceData) ? balanceData[0] : balanceData;
     if (!walletData || !walletData.bundleHash || !walletData.tokenSlug) {
       return null;
     }
@@ -5961,7 +7183,7 @@ var ResponseBalance = class _ResponseBalance extends exports.Response {
     secret = null
   }) {
     let wallet;
-    if (data.position === null || typeof data.position === "undefined") {
+    if (!data.position) {
       wallet = Wallet.create({
         bundle: data.bundleHash,
         token: data.tokenSlug,
@@ -5990,7 +7212,7 @@ var ResponseBalance = class _ResponseBalance extends exports.Response {
         wallet.tradeRates[tradeRate.tokenSlug] = tradeRate.amount;
       }
     }
-    wallet.balance = Number(data.amount || 0);
+    wallet.balance = String(data.amount != null ? data.amount : 0);
     wallet.pubkey = data.pubkey;
     wallet.createdAt = data.createdAt;
     return wallet;
@@ -6183,7 +7405,7 @@ var ResponseWalletList = class _ResponseWalletList extends exports.Response {
         wallet.tradeRates[tradeRate.tokenSlug] = tradeRate.amount;
       }
     }
-    wallet.balance = Number(data.amount);
+    wallet.balance = String(data.amount != null ? data.amount : 0);
     wallet.pubkey = data.pubkey;
     wallet.createdAt = data.createdAt;
     return wallet;
@@ -6221,8 +7443,8 @@ var QueryWalletList = class extends Query {
    */
   constructor(graphQLClient, knishIOClient) {
     super(graphQLClient, knishIOClient);
-    this.$__query = core.gql`query( $bundleHash: String, $tokenSlug: String ) {
-      Wallet( bundleHash: $bundleHash, tokenSlug: $tokenSlug ) {
+    this.$__query = core.gql`query( $bundleHash: String, $token: String ) {
+      Wallet( bundleHash: $bundleHash, token: $token ) {
         address,
         bundleHash,
         token {
@@ -6364,7 +7586,7 @@ var ResponseContinuId = class extends exports.Response {
       wallet.batchId = continuId.batchId;
       wallet.characters = continuId.characters;
       wallet.pubkey = continuId.pubkey;
-      wallet.balance = continuId.amount * 1;
+      wallet.balance = String(continuId.amount != null ? continuId.amount : 0);
     }
     return wallet;
   }
@@ -6390,6 +7612,13 @@ var QueryContinuId = class extends Query {
       }
     }`;
   }
+  /**
+   * Force network-only for ContinuID queries to prevent URQL cache from
+   * returning stale wallet positions after mutations advance the ContinuID chain
+   */
+  createQueryContext() {
+    return { requestPolicy: "network-only" };
+  }
   /**
    * Returns a Response object
    * Matches JavaScript SDK createResponse method exactly
@@ -6419,31 +7648,40 @@ var ResponseMetaType = class extends exports.Response {
       dataKey: "data.MetaType"
     });
   }
+  /**
+   * Extracts payload from metaData object
+   */
+  extractPayload(metaData) {
+    return {
+      instances: metaData?.instances || [],
+      instanceCount: metaData?.instanceCount || [],
+      paginatorInfo: metaData?.paginatorInfo || {}
+    };
+  }
   /**
    * Returns meta type instance results
-   * Matches JavaScript SDK payload method exactly
+   * Handles various response formats from server:
+   * - Array of results (normal case)
+   * - Single object (filtered queries)
+   * - null/undefined (no results)
+   * - Empty array (no matching data)
    */
   payload() {
     const metaTypeData = this.data();
-    if (!metaTypeData || metaTypeData.length === 0) {
+    if (metaTypeData === null || metaTypeData === void 0) {
       return null;
     }
-    const response = {
-      instances: {},
-      instanceCount: {},
-      paginatorInfo: {}
-    };
-    const metaData = metaTypeData.pop();
-    if (metaData.instances) {
-      response.instances = metaData.instances;
-    }
-    if (metaData.instanceCount) {
-      response.instanceCount = metaData.instanceCount;
+    if (Array.isArray(metaTypeData)) {
+      if (metaTypeData.length === 0) {
+        return this.extractPayload(null);
+      }
+      const metaData = metaTypeData[metaTypeData.length - 1];
+      return this.extractPayload(metaData);
     }
-    if (metaData.paginatorInfo) {
-      response.paginatorInfo = metaData.paginatorInfo;
+    if (typeof metaTypeData === "object") {
+      return this.extractPayload(metaTypeData);
     }
-    return response;
+    return null;
   }
 };
 var QueryMetaType = class extends Query {
@@ -6911,10 +8149,9 @@ var ResponsePolicy = class extends exports.Response {
   }) {
     super({
       query,
-      json
+      json,
+      dataKey: "data.Policy"
     });
-    this.dataKey = "data.Policy";
-    this.init();
   }
   /**
    * Returns the policy payload
@@ -7017,7 +8254,6 @@ var QueryActiveSession = class extends Query {
           metaId
           jsonData
           createdAt
-          updatedAt
         }
       }
     `;
@@ -7350,6 +8586,252 @@ var QueryMetaTypeViaAtom = class extends Query {
   }
 };
 
+// src/response/ResponseMetaTypeViaMolecule.ts
+init_Response();
+var ResponseMetaTypeViaMolecule = class _ResponseMetaTypeViaMolecule extends exports.Response {
+  /**
+   * Class constructor
+   */
+  constructor({
+    query,
+    json
+  }) {
+    super({
+      query,
+      json,
+      dataKey: "data.MetaTypeViaAtom"
+    });
+  }
+  /**
+   * Extracts metas from a molecule's atoms' metasJson for a specific instance.
+   * Filters atoms by matching metaType and metaId, then parses metasJson.
+   */
+  static extractMetasFromMolecule(molecule, metaType, metaId) {
+    if (!molecule || !molecule.atoms) {
+      return [];
+    }
+    const metas = [];
+    for (const atom of molecule.atoms) {
+      if (atom.metaType !== metaType || atom.metaId !== metaId) {
+        continue;
+      }
+      if (!atom.metasJson) {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(atom.metasJson);
+        if (!Array.isArray(parsed)) {
+          continue;
+        }
+      } catch (e) {
+        continue;
+      }
+      for (const entry of parsed) {
+        metas.push({
+          molecularHash: molecule.molecularHash,
+          position: atom.position,
+          key: entry.key,
+          value: entry.value,
+          createdAt: atom.createdAt
+        });
+      }
+    }
+    return metas;
+  }
+  /**
+   * Returns meta type instance results with metas synthesized from molecule data.
+   * Produces the same payload format as ResponseMetaType and ResponseMetaTypeViaAtom:
+   * { instances, instanceCount, paginatorInfo }
+   */
+  payload() {
+    const metaTypeData = this.data();
+    if (!metaTypeData || metaTypeData.length === 0) {
+      return null;
+    }
+    const response = {
+      instances: {},
+      instanceCount: {},
+      paginatorInfo: {}
+    };
+    const metaData = metaTypeData.pop();
+    if (metaData.instances) {
+      response.instances = metaData.instances.map((instance) => {
+        let metas = instance.metas;
+        if (!metas || metas.length === 0) {
+          metas = _ResponseMetaTypeViaMolecule.extractMetasFromMolecule(
+            instance.molecule,
+            instance.metaType,
+            instance.metaId
+          );
+        }
+        return {
+          ...instance,
+          metas
+        };
+      });
+    }
+    if (metaData.instanceCount) {
+      response.instanceCount = metaData.instanceCount;
+    }
+    if (metaData.paginatorInfo) {
+      response.paginatorInfo = metaData.paginatorInfo;
+    }
+    return response;
+  }
+  /**
+   * Verifies the cryptographic integrity of all molecules associated
+   * with meta instances in this response.
+   */
+  verifyIntegrity() {
+    const results = [];
+    const metaTypeData = this.data();
+    if (!metaTypeData || metaTypeData.length === 0) {
+      return { verified: true, molecules: results };
+    }
+    const instances = metaTypeData[metaTypeData.length - 1]?.instances || [];
+    for (const instance of instances) {
+      if (!instance.molecule) continue;
+      results.push(CheckMolecule.verifyFromServerData(instance.molecule));
+    }
+    return {
+      verified: results.length === 0 || results.every((r) => r.verified),
+      molecules: results
+    };
+  }
+};
+var QueryMetaTypeViaMolecule = class extends Query {
+  /**
+   * Create new QueryMetaTypeViaMolecule instance
+   */
+  constructor(graphQLClient, knishIOClient) {
+    super(graphQLClient, knishIOClient);
+    this.$__query = core.gql`query ($metaTypes: [String!], $metaIds: [String!], $values: [String!], $keys: [String!], $latest: Boolean, $filter: [MetaFilter!], $queryArgs: QueryArgs, $countBy: String, $atomValues: [String!], $cellSlugs: [String!] ) {
+      MetaTypeViaAtom(
+        metaTypes: $metaTypes
+        metaIds: $metaIds
+        atomValues: $atomValues
+        cellSlugs: $cellSlugs
+        filter: $filter,
+        latest: $latest,
+        queryArgs: $queryArgs
+        countBy: $countBy
+      ) {
+        metaType,
+        instanceCount {
+          key,
+          value
+        },
+        instances {
+          metaType,
+          metaId,
+          createdAt,
+          metas( values: $values, keys: $keys ) {
+            molecularHash,
+            position,
+            key,
+            value,
+            createdAt
+          },
+          molecule {
+            molecularHash,
+            bundleHash,
+            cellSlug,
+            status,
+            createdAt,
+            atoms {
+              position,
+              walletAddress,
+              isotope,
+              tokenSlug,
+              value,
+              batchId,
+              metaType,
+              metaId,
+              index,
+              createdAt,
+              otsFragment,
+              metasJson
+            }
+          }
+        },
+        paginatorInfo {
+          currentPage,
+          total
+        }
+      }
+    }`;
+  }
+  /**
+   * Builds a GraphQL-friendly variables object based on input fields
+   */
+  static createVariables({
+    metaType = null,
+    metaId = null,
+    key = null,
+    value = null,
+    keys = null,
+    values = null,
+    atomValues = null,
+    latest = null,
+    filter = null,
+    queryArgs = null,
+    countBy = null,
+    cellSlug = null
+  } = {}) {
+    const variables = {};
+    if (atomValues) {
+      variables.atomValues = atomValues;
+    }
+    if (keys) {
+      variables.keys = keys;
+    }
+    if (values) {
+      variables.values = values;
+    }
+    if (metaType) {
+      variables.metaTypes = typeof metaType === "string" ? [metaType] : metaType;
+    }
+    if (metaId) {
+      variables.metaIds = typeof metaId === "string" ? [metaId] : metaId;
+    }
+    if (cellSlug) {
+      variables.cellSlugs = typeof cellSlug === "string" ? [cellSlug] : cellSlug;
+    }
+    if (countBy) {
+      variables.countBy = countBy;
+    }
+    if (filter) {
+      variables.filter = filter;
+    }
+    if (key && value) {
+      variables.filter = variables.filter || [];
+      variables.filter.push({
+        key,
+        value,
+        comparison: "="
+      });
+    }
+    variables.latest = latest === true;
+    if (queryArgs) {
+      if (typeof queryArgs.limit === "undefined" || queryArgs.limit === 0) {
+        queryArgs.limit = "*";
+      }
+      variables.queryArgs = queryArgs;
+    }
+    return variables;
+  }
+  /**
+   * Returns a Response object
+   */
+  createResponse(json) {
+    return new ResponseMetaTypeViaMolecule({
+      query: this,
+      json
+    });
+  }
+};
+
 // src/response/ResponseProposeMolecule.ts
 init_Response();
 init_Dot();
@@ -7368,7 +8850,6 @@ var ResponseProposeMolecule = class extends exports.Response {
       dataKey: "data.ProposeMolecule"
     });
     this.$__clientMolecule = query.molecule();
-    this.init();
   }
   /**
    * Initialize response object with payload data
@@ -7932,12 +9413,31 @@ var ResponseRequestAuthorization = class extends ResponseProposeMolecule {
     return this.payloadKey("token");
   }
   /**
-   * Returns timestamp
-   * Matches JavaScript SDK time method exactly
+   * Returns raw time value from payload
    */
   time() {
     return this.payloadKey("time");
   }
+  /**
+   * Returns the expiration timestamp as Unix seconds.
+   * Handles both server formats:
+   * - PHP server: time = lifetime in ms, expiresAt = Unix timestamp in payload
+   * - Rust server: time = Unix timestamp in seconds
+   */
+  expiresAt() {
+    try {
+      const ea = this.payloadKey("expiresAt");
+      if (ea) {
+        return Number(ea);
+      }
+    } catch (_e) {
+    }
+    const timeValue = Number(this.time());
+    if (timeValue >= 1577836800) {
+      return timeValue;
+    }
+    return Math.floor(Date.now() / 1e3) + Math.floor(timeValue / 1e3);
+  }
   /**
    * Returns encryption info
    * Matches JavaScript SDK encrypt method exactly
@@ -8029,11 +9529,31 @@ var ResponseRequestAuthorizationGuest = class extends exports.Response {
     return this.payloadKey("token");
   }
   /**
-   * Returns timestamp
+   * Returns raw time value from payload
    */
   time() {
     return this.payloadKey("time");
   }
+  /**
+   * Returns the expiration timestamp as Unix seconds.
+   * Handles both server formats:
+   * - PHP server: time = lifetime in ms, expiresAt = Unix timestamp in payload
+   * - Rust server: time = Unix timestamp in seconds
+   */
+  expiresAt() {
+    try {
+      const ea = this.payloadKey("expiresAt");
+      if (ea) {
+        return Number(ea);
+      }
+    } catch (_e) {
+    }
+    const timeValue = Number(this.time());
+    if (timeValue >= 1577836800) {
+      return timeValue;
+    }
+    return Math.floor(Date.now() / 1e3) + Math.floor(timeValue / 1e3);
+  }
   /**
    * Returns public key
    */
@@ -8123,10 +9643,74 @@ var MutationLinkIdentifier = class extends Mutation {
     `;
   }
   /**
-   * Returns a Response object
+   * Returns a Response object
+   */
+  createResponse(json) {
+    return new ResponseLinkIdentifier({
+      query: this,
+      json
+    });
+  }
+};
+
+// src/response/ResponsePeering.ts
+var ResponsePeering = class extends ResponseProposeMolecule {
+};
+
+// src/mutation/MutationPeering.ts
+var MutationPeering = class extends MutationProposeMolecule {
+  /**
+   * Fills a molecule with a P-isotope peering atom
+   * Matches JavaScript SDK fillMolecule method exactly
+   */
+  fillMolecule({ host }) {
+    this.$__molecule.initPeering({ host });
+    this.$__molecule.sign({});
+    this.$__molecule.check();
+  }
+  /**
+   * Builds a Response object out of a JSON object
+   * Matches JavaScript SDK createResponse method exactly
+   */
+  createResponse(json) {
+    return new ResponsePeering({
+      query: this,
+      json
+    });
+  }
+};
+
+// src/response/ResponseAppendRequest.ts
+var ResponseAppendRequest = class extends ResponseProposeMolecule {
+};
+
+// src/mutation/MutationAppendRequest.ts
+var MutationAppendRequest = class extends MutationProposeMolecule {
+  /**
+   * Fills a molecule with an A-isotope append request atom
+   * Matches JavaScript SDK fillMolecule method exactly
+   */
+  fillMolecule({
+    metaType,
+    metaId,
+    action,
+    meta = {}
+  }) {
+    this.$__molecule.initAppendRequest({
+      metaType,
+      metaId,
+      action,
+      meta
+    });
+    this.$__molecule.sign({});
+    this.$__molecule.check();
+  }
+  /**
+   * Builds a Response object out of a JSON object
+   * Matches JavaScript SDK createResponse method exactly
    */
   createResponse(json) {
-    return new ResponseLinkIdentifier({
+    return new ResponseAppendRequest({
       query: this,
       json
     });
@@ -8355,6 +9939,7 @@ var KnishIOClient = class {
   $__logging = false;
   $__authTokenObjects = {};
   $__authToken = null;
+  $__authInProcess = false;
   $__remainderWallet = null;
   lastMoleculeQuery = null;
   abortControllers = /* @__PURE__ */ new Map();
@@ -8498,6 +10083,9 @@ var KnishIOClient = class {
     } else {
       this.$__uris = uri;
     }
+    if (this.$__client && "setUri" in this.$__client) {
+      this.$__client.setUri(this.getRandomUri());
+    }
   }
   /**
    * Gets the Knish.IO server URIs
@@ -8560,7 +10148,8 @@ var KnishIOClient = class {
     return this.$__remainderWallet;
   }
   /**
-   * Creates a new molecule for a transaction
+   * Instantiates a new Molecule and prepares this client session to operate on it
+   * Matches JavaScript SDK createMolecule implementation
    */
   async createMolecule({
     secret = null,
@@ -8571,17 +10160,38 @@ var KnishIOClient = class {
     this.log("info", "KnishIOClient::createMolecule() - Creating a new molecule...");
     secret = secret || this.getSecret();
     bundle = bundle || this.getBundle();
+    let continuIdPosition = null;
+    if (sourceWallet && sourceWallet.token !== "USER") {
+      if (this.lastMoleculeQuery && this.getRemainderWallet() && this.getRemainderWallet()?.token === "USER" && this.lastMoleculeQuery.response() && this.lastMoleculeQuery.response()?.success()) {
+        continuIdPosition = this.getRemainderWallet()?.position || null;
+        this.log("info", `KnishIOClient::createMolecule() - Captured USER ContinuID position ${continuIdPosition?.substring(0, 16)}... for non-USER source wallet`);
+      } else {
+        const userWallet = await this.getSourceWallet();
+        continuIdPosition = userWallet?.position || null;
+        this.log("info", `KnishIOClient::createMolecule() - Queried USER ContinuID position ${continuIdPosition?.substring(0, 16)}... for non-USER source wallet`);
+      }
+    }
     if (!sourceWallet && this.lastMoleculeQuery && this.getRemainderWallet()?.token === "USER" && this.lastMoleculeQuery.response() && this.lastMoleculeQuery.response()?.success()) {
       sourceWallet = this.getRemainderWallet();
+      this.log("info", `KnishIOClient::createMolecule() - Using carry-forward remainder wallet at position ${sourceWallet?.position?.substring(0, 16)}...`);
     }
     if (!sourceWallet) {
       sourceWallet = await this.getSourceWallet();
     }
-    return new Molecule({
+    this.setRemainderWallet(remainderWallet || Wallet.create({
       secret,
       bundle,
+      token: "USER",
+      batchId: sourceWallet.batchId,
+      characters: sourceWallet.characters
+    }));
+    return new Molecule({
+      secret,
       sourceWallet,
-      remainderWallet
+      remainderWallet: this.getRemainderWallet(),
+      cellSlug: this.getCellSlug(),
+      version: this.getServerSdkVersion(),
+      continuIdPosition
     });
   }
   /**
@@ -8604,7 +10214,7 @@ var KnishIOClient = class {
    * Executes a query or mutation
    */
   async executeQuery(query, variables = null) {
-    if (this.$__authToken && this.$__authToken.isExpired()) {
+    if (this.$__authToken && this.$__authToken.isExpired() && !this.$__authInProcess) {
       this.log("info", "KnishIOClient::executeQuery() - Access token is expired. Getting new one...");
       await this.requestAuthToken({
         secret: this.$__secret,
@@ -8631,14 +10241,26 @@ var KnishIOClient = class {
     }
   }
   /**
-   * Gets source wallet - basic implementation
+   * Retrieves this session's wallet used for signing the next Molecule
+   * Queries ContinuID from the server to get the authoritative position
+   * Matches JavaScript SDK getSourceWallet implementation
    */
   async getSourceWallet() {
-    return Wallet.create({
-      secret: this.getSecret(),
-      bundle: this.getBundle(),
-      token: "USER"
-    });
+    let sourceWallet = (await this.queryContinuId({
+      bundle: this.getBundle()
+    }))?.payload();
+    if (!sourceWallet) {
+      sourceWallet = new Wallet({
+        secret: this.getSecret()
+      });
+    } else {
+      sourceWallet.key = Wallet.generateKey({
+        secret: this.getSecret(),
+        token: sourceWallet.token,
+        position: sourceWallet.position
+      });
+    }
+    return sourceWallet;
   }
   /**
    * Transfer tokens between wallets
@@ -8667,7 +10289,7 @@ var KnishIOClient = class {
         amount
       });
     }
-    if (sourceWallet === null || Decimal.cmp(sourceWallet.balance, amount) < 0) {
+    if (sourceWallet === null || Decimal.cmp(Number(sourceWallet.balance), amount) < 0) {
       throw new exports.TransferBalanceException();
     }
     const recipientWallet = Wallet.create({
@@ -8702,19 +10324,48 @@ var KnishIOClient = class {
     return await this.executeQuery(query);
   }
   /**
-   * Request authorization token
+   * Request authorization token (guest or profile)
+   *
+   * @param secret - User secret for profile auth (null for guest)
+   * @param seed - Seed to generate secret (alternative to secret)
+   * @param cellSlug - Cell slug for scoped access
+   * @param encrypt - Whether to use encryption
    */
   async requestAuthToken({
-    secret: _secret = null,
-    seed: _seed = null,
-    cellSlug: _cellSlug = null,
-    encrypt: _encrypt = false
+    secret = null,
+    seed = null,
+    cellSlug = null,
+    encrypt = false
   } = {}) {
     if (this.$__serverSdkVersion < 3) {
-      this.log("warn", "KnishIOClient::authorize() - Server SDK version does not require an authorization...");
+      this.log("warn", "KnishIOClient::requestAuthToken() - Server SDK version does not require authorization...");
       return null;
     }
-    return null;
+    if (secret === null && seed) {
+      secret = generateSecret(seed);
+    }
+    if (cellSlug) {
+      this.setCellSlug(cellSlug);
+    }
+    this.$__authInProcess = true;
+    let response;
+    if (secret) {
+      response = await this.requestProfileAuthToken({
+        secret,
+        encrypt
+      });
+    } else {
+      response = await this.requestGuestAuthToken({
+        cellSlug: cellSlug || this.getCellSlug(),
+        encrypt
+      });
+    }
+    if (this.$__authToken) {
+      this.log("info", `KnishIOClient::requestAuthToken() - Successfully retrieved auth token...`);
+    }
+    this.switchEncryption(encrypt);
+    this.$__authInProcess = false;
+    return response;
   }
   /**
    * Logging utility
@@ -8812,7 +10463,7 @@ var KnishIOClient = class {
     });
     const sourceWallet = response.payload();
     const amountNum = typeof amount === "string" ? Number(amount) : amount;
-    if (sourceWallet === null || Decimal.cmp(sourceWallet.balance || 0, amountNum) < 0) {
+    if (sourceWallet === null || Decimal.cmp(Number(sourceWallet.balance || 0), amountNum) < 0) {
       throw new exports.TransferBalanceException();
     }
     if (!sourceWallet.position || !sourceWallet.address) {
@@ -8832,7 +10483,7 @@ var KnishIOClient = class {
     const walletQuery = this.createQuery(QueryWalletList);
     const response = await this.executeQuery(walletQuery, {
       bundleHash: bundle || this.getBundle(),
-      tokenSlug: token,
+      token,
       unspent
     });
     return response?.payload() || [];
@@ -8882,6 +10533,7 @@ var KnishIOClient = class {
     count = null,
     countBy = null,
     throughAtom = true,
+    throughMolecule = false,
     values = null,
     keys = null,
     atomValues = null
@@ -8889,7 +10541,23 @@ var KnishIOClient = class {
     this.log("info", `KnishIOClient::queryMeta() - Querying metaType: ${metaType}, metaId: ${metaId}...`);
     let query;
     let variables;
-    if (throughAtom) {
+    if (throughMolecule) {
+      query = this.createQuery(QueryMetaTypeViaMolecule);
+      variables = QueryMetaTypeViaMolecule.createVariables({
+        metaType,
+        metaId,
+        key,
+        value,
+        latest,
+        filter,
+        queryArgs,
+        countBy,
+        values,
+        keys,
+        atomValues,
+        cellSlug: this.getCellSlug()
+      });
+    } else if (throughAtom) {
       query = this.createQuery(QueryMetaTypeViaAtom);
       variables = QueryMetaTypeViaAtom.createVariables({
         metaType,
@@ -8922,6 +10590,19 @@ var KnishIOClient = class {
     }
     return this.executeQuery(query, variables);
   }
+  /**
+   * Queries meta assets and verifies cryptographic integrity of associated molecules.
+   * Forces throughMolecule=true to ensure molecule data is available for verification.
+   * Returns the same response as queryMeta(), with an additional `integrity` field on the payload.
+   */
+  async queryMetaVerified(params) {
+    const response = await this.queryMeta({ ...params, throughMolecule: true });
+    const payload = response.payload();
+    if (payload && typeof response.verifyIntegrity === "function") {
+      payload.integrity = response.verifyIntegrity();
+    }
+    return response;
+  }
   /**
    * Query cascading meta instances for batchId
    */
@@ -9184,7 +10865,7 @@ var KnishIOClient = class {
     const recipientWallet = new Wallet({
       secret: this.getSecret(),
       bundle: this.getBundle(),
-      token: token.toUpperCase(),
+      token,
       batchId
     });
     await mutation.fillMolecule({
@@ -9212,7 +10893,7 @@ var KnishIOClient = class {
     this.log("info", `KnishIOClient::requestTokens() - Requesting ${amount || "units"} of ${token}...`);
     const mutation = await this.createMoleculeMutation({ mutationClass: MutationRequestTokens });
     await mutation.fillMolecule({
-      token: token.toUpperCase(),
+      token,
       amount: amount ?? 0,
       metaType: to || "",
       metaId: to || "",
@@ -9241,11 +10922,19 @@ var KnishIOClient = class {
         amount: amount || 0
       });
     }
-    const mutation = await this.createMoleculeMutation({ mutationClass: MutationTransferTokens });
+    const remainderWallet = sourceWallet.createRemainder(this.getSecret());
+    const molecule = await this.createMolecule({
+      sourceWallet,
+      remainderWallet
+    });
+    const mutation = await this.createMoleculeMutation({
+      mutationClass: MutationTransferTokens,
+      molecule
+    });
     const recipientWallet = new Wallet({
       secret: this.getSecret(),
       bundle: "0000000000000000000000000000000000000000000000000000000000000000",
-      token: token.toUpperCase()
+      token
     });
     await mutation.fillMolecule({
       recipientWallet,
@@ -9300,7 +10989,7 @@ var KnishIOClient = class {
     const newWallet = new Wallet({
       secret: this.getSecret(),
       bundle: this.getBundle(),
-      token: token.toUpperCase()
+      token
     });
     await mutation.fillMolecule(newWallet);
     const response = await this.executeQuery(mutation);
@@ -9331,7 +11020,7 @@ var KnishIOClient = class {
     }
     const mutation = await this.createMoleculeMutation({ mutationClass: MutationClaimShadowWallet });
     await mutation.fillMolecule({
-      token: token.toUpperCase(),
+      token,
       batchId: shadowWallet.batchId
     });
     const response = await this.executeQuery(mutation);
@@ -9379,11 +11068,16 @@ var KnishIOClient = class {
     policy = null
   }) {
     this.log("info", `KnishIOClient::createMeta() - Creating metadata for ${metaType}:${metaId}...`);
-    const mutation = await this.createMoleculeMutation({ mutationClass: MutationCreateMeta });
+    const mutation = await this.createMoleculeMutation({
+      mutationClass: MutationCreateMeta,
+      molecule: await this.createMolecule({
+        secret: this.getSecret()
+      })
+    });
     await mutation.fillMolecule({
-      metaType: metaType.toUpperCase(),
+      metaType,
       metaId,
-      meta,
+      meta: meta || {},
       policy
     });
     const response = await this.executeQuery(mutation);
@@ -9402,9 +11096,14 @@ var KnishIOClient = class {
     policy = null
   }) {
     this.log("info", `KnishIOClient::createRule() - Creating rule for ${metaType}:${metaId}...`);
-    const mutation = await this.createMoleculeMutation({ mutationClass: MutationCreateRule });
+    const mutation = await this.createMoleculeMutation({
+      mutationClass: MutationCreateRule,
+      molecule: await this.createMolecule({
+        secret: this.getSecret()
+      })
+    });
     await mutation.fillMolecule({
-      metaType: metaType.toUpperCase(),
+      metaType,
       metaId,
       rule,
       policy
@@ -9491,8 +11190,8 @@ var KnishIOClient = class {
     this.log("info", `KnishIOClient::activeSession() - Declaring active session for ${metaType}:${metaId}...`);
     const mutation = this.createQuery(MutationActiveSession);
     const response = await this.executeQuery(mutation, {
-      bundle: bundle || this.getBundle(),
-      metaType: metaType.toUpperCase(),
+      bundleHash: bundle || this.getBundle(),
+      metaType,
       metaId,
       ipAddress,
       browser,
@@ -9522,7 +11221,15 @@ var KnishIOClient = class {
         amount
       });
     }
-    const mutation = await this.createMoleculeMutation({ mutationClass: MutationDepositBufferToken });
+    const remainderWallet = sourceWallet.createRemainder(this.getSecret());
+    const molecule = await this.createMolecule({
+      sourceWallet,
+      remainderWallet
+    });
+    const mutation = await this.createMoleculeMutation({
+      mutationClass: MutationDepositBufferToken,
+      molecule
+    });
     await mutation.fillMolecule({
       amount: typeof amount === "string" ? Number(amount) : amount,
       tradeRates
@@ -9585,6 +11292,7 @@ var KnishIOClient = class {
   }
   /**
    * Request profile authentication token
+   * Matches JavaScript SDK requestProfileAuthToken implementation
    */
   async requestProfileAuthToken({
     secret,
@@ -9592,151 +11300,108 @@ var KnishIOClient = class {
   }) {
     this.log("info", "KnishIOClient::requestProfileAuthToken() - Requesting profile auth token...");
     this.setSecret(secret);
-    const mutation = await this.createMoleculeMutation({ mutationClass: MutationRequestAuthorization });
-    await mutation.fillMolecule({
+    const wallet = new Wallet({
+      secret,
+      token: "AUTH"
+    });
+    const molecule = await this.createMolecule({
+      secret,
+      sourceWallet: wallet
+    });
+    const mutation = await this.createMoleculeMutation({
+      mutationClass: MutationRequestAuthorization,
+      molecule
+    });
+    mutation.fillMolecule({
       meta: { encrypt: encrypt ? "true" : "false" }
     });
     const response = await this.executeQuery(mutation);
     if (!response) {
       throw new CodeException("Profile auth token request failed");
     }
+    if (response.success()) {
+      const authToken = AuthToken.create({
+        token: response.token(),
+        expiresAt: response.expiresAt(),
+        encrypt: String(response.encrypt()) === "true",
+        pubkey: response.pubKey()
+      }, wallet);
+      this.setAuthToken(authToken);
+    } else {
+      throw new AuthorizationRejectedException_default(
+        `KnishIOClient::requestProfileAuthToken() - Authorization attempt rejected by ledger. Reason: ${response.reason()}`
+      );
+    }
     if (encrypt) {
       this.switchEncryption(true);
     }
     return response;
   }
   // =============================================================================
-  // LEGACY/DEPRECATED METHODS
+  // MUTATION METHODS - PEERING & APPEND REQUEST
   // =============================================================================
   /**
-   * @deprecated Use getCellSlug() instead
-   */
-  cellSlug() {
-    return this.getCellSlug();
-  }
-  /**
-   * @deprecated Use getUri() instead
+   * Register a peer node via P-isotope
+   * Matches JavaScript SDK registerPeer implementation exactly
    */
-  uri() {
-    return this.getUri();
+  async registerPeer({ host }) {
+    this.log("info", `KnishIOClient::registerPeer() - Registering peer at ${host}...`);
+    const mutation = await this.createMoleculeMutation({
+      mutationClass: MutationPeering,
+      molecule: await this.createMolecule({
+        secret: this.getSecret()
+      })
+    });
+    mutation.fillMolecule({ host });
+    const response = await this.executeQuery(mutation);
+    if (!response) {
+      throw new CodeException("Peer registration failed");
+    }
+    return response;
   }
-};
-
-// src/AuthToken.ts
-var AuthToken = class _AuthToken {
-  $__token;
-  $__expiresAt;
-  $__pubkey;
-  $__encrypt;
-  $__wallet;
   /**
-   * Create new AuthToken instance
+   * Submit an append request via A-isotope
+   * Matches JavaScript SDK appendRequest implementation exactly
    */
-  constructor({
-    token,
-    expiresAt,
-    encrypt,
-    pubkey
+  async appendRequest({
+    metaType,
+    metaId,
+    action,
+    meta = {}
   }) {
-    this.$__token = token;
-    this.$__expiresAt = expiresAt;
-    this.$__pubkey = pubkey;
-    this.$__encrypt = encrypt;
-  }
-  /**
-   * Static factory method to create AuthToken with wallet
-   */
-  static create(data, wallet) {
-    const authToken = new _AuthToken(data);
-    authToken.setWallet(wallet);
-    return authToken;
-  }
-  /**
-   * Restore AuthToken from snapshot
-   */
-  static restore(snapshot, secret) {
-    const wallet = new Wallet({
-      secret,
-      token: "AUTH",
-      position: snapshot.wallet.position,
-      characters: snapshot.wallet.characters
+    this.log("info", `KnishIOClient::appendRequest() - Submitting append request for ${metaType}:${metaId}...`);
+    const mutation = await this.createMoleculeMutation({
+      mutationClass: MutationAppendRequest,
+      molecule: await this.createMolecule({
+        secret: this.getSecret()
+      })
     });
-    return _AuthToken.create({
-      token: snapshot.token,
-      expiresAt: snapshot.expiresAt,
-      pubkey: snapshot.pubkey,
-      encrypt: snapshot.encrypt
-    }, wallet);
-  }
-  /**
-   * Set wallet for this auth token
-   */
-  setWallet(wallet) {
-    this.$__wallet = wallet;
-  }
-  /**
-   * Get wallet
-   */
-  getWallet() {
-    return this.$__wallet;
-  }
-  /**
-   * Get auth token
-   */
-  getToken() {
-    return this.$__token;
-  }
-  /**
-   * Get expiration timestamp
-   */
-  getExpiresAt() {
-    return this.$__expiresAt;
-  }
-  /**
-   * Get public key
-   */
-  getPubkey() {
-    return this.$__pubkey;
-  }
-  /**
-   * Check if encryption is enabled
-   */
-  isEncrypted() {
-    return this.$__encrypt;
-  }
-  /**
-   * Check if token is expired
-   */
-  isExpired() {
-    const now = Math.floor(Date.now() / 1e3);
-    return now >= this.$__expiresAt;
+    mutation.fillMolecule({
+      metaType,
+      metaId,
+      action,
+      meta
+    });
+    const response = await this.executeQuery(mutation);
+    if (!response) {
+      throw new CodeException("Append request failed");
+    }
+    return response;
   }
+  // =============================================================================
+  // LEGACY/DEPRECATED METHODS
+  // =============================================================================
   /**
-   * Get auth data for GraphQL client
+   * @deprecated Use getCellSlug() instead
    */
-  getAuthData() {
-    return {
-      token: this.$__token,
-      pubkey: this.$__pubkey,
-      wallet: this.$__wallet
-    };
+  cellSlug() {
+    return this.getCellSlug();
   }
   /**
-   * Create snapshot for persistence
+   * @deprecated Use getUri() instead
    */
-  toSnapshot() {
-    return {
-      token: this.$__token,
-      expiresAt: this.$__expiresAt,
-      pubkey: this.$__pubkey,
-      encrypt: this.$__encrypt,
-      ...this.$__wallet ? {
-        wallet: {
-          position: this.$__wallet.position,
-          characters: this.$__wallet.characters
-        }
-      } : {}
-    };
+  uri() {
+    return this.getUri();
   }
 };
 
@@ -9914,9 +11579,11 @@ exports.KnishIOClient = KnishIOClient;
 exports.Meta = Meta;
 exports.Molecule = Molecule;
 exports.Mutation = Mutation;
+exports.MutationAppendRequest = MutationAppendRequest;
 exports.MutationCreateMeta = MutationCreateMeta;
 exports.MutationCreateToken = MutationCreateToken;
 exports.MutationCreateWallet = MutationCreateWallet;
+exports.MutationPeering = MutationPeering;
 exports.MutationProposeMolecule = MutationProposeMolecule;
 exports.MutationRequestAuthorization = MutationRequestAuthorization;
 exports.MutationRequestTokens = MutationRequestTokens;
@@ -9931,6 +11598,7 @@ exports.QueryMetaType = QueryMetaType;
 exports.QueryMetaTypeViaAtom = QueryMetaTypeViaAtom;
 exports.QueryWalletBundle = QueryWalletBundle;
 exports.QueryWalletList = QueryWalletList;
+exports.ResponseAppendRequest = ResponseAppendRequest;
 exports.ResponseAtom = ResponseAtom;
 exports.ResponseBalance = ResponseBalance;
 exports.ResponseContinuId = ResponseContinuId;
@@ -9939,6 +11607,7 @@ exports.ResponseCreateToken = ResponseCreateToken;
 exports.ResponseCreateWallet = ResponseCreateWallet;
 exports.ResponseMetaType = ResponseMetaType;
 exports.ResponseMetaTypeViaAtom = ResponseMetaTypeViaAtom;
+exports.ResponsePeering = ResponsePeering;
 exports.ResponseProposeMolecule = ResponseProposeMolecule;
 exports.ResponseRequestAuthorization = ResponseRequestAuthorization;
 exports.ResponseRequestTokens = ResponseRequestTokens;