@wishknish/knishio-client-ts 0.7.4 → 0.7.7

package/src/core/Wallet.ts

@@ -47,10 +47,10 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 */
 
 import JsSHA from 'jssha'
-import { randomString, chunkSubstr } from '@/libraries/strings'
+import { randomString, chunkSubstr, isHex } from '@/libraries/strings'
 import { generateBundleHash, generateSecret, shake256, generateBatchId } from '@/libraries/crypto'
 import WalletCredentialException from '@/exception/WalletCredentialException'
-import { isWalletAddress, isBundleHash, isPosition } from '@/types'
+import { isBundleHash } from '@/types'
 // Post-quantum cryptography for ML-KEM768 key encapsulation
 import { ml_kem768 } from '@noble/post-quantum/ml-kem.js'
 
@@ -60,7 +60,7 @@ import { ml_kem768 } from '@noble/post-quantum/ml-kem.js'
  */
 export default class Wallet {
   public token: string
-  public balance: number
+  public balance: string
   public address: string | null
   public position: string | null
   public bundle: string | null
@@ -97,18 +97,8 @@ export default class Wallet {
     batchId?: string | null
     characters?: string | null
   } = {}) {
-    // TypeScript 2025: Exhaustive validation with type guards
-    if (address !== null && !isWalletAddress(address)) {
-      throw new WalletCredentialException('Invalid wallet address format')
-    }
-    if (bundle !== null && !isBundleHash(bundle)) {
-      throw new WalletCredentialException('Invalid bundle hash format')
-    }
-    if (position !== null && !isPosition(position)) {
-      throw new WalletCredentialException('Invalid position format')
-    }
     this.token = token
-    this.balance = 0
+    this.balance = '0'
     this.molecules = {}
     
     // Empty values
@@ -164,20 +154,21 @@ export default class Wallet {
     batchId?: string | null
     characters?: string | null
   }): Wallet {
-    let position = null
-    
+    let position: string | null = null
+
     // No credentials parameters provided?
     if (!secret && !bundle) {
       throw new WalletCredentialException()
     }
-    
+
     // Secret, but no bundle?
     if (secret && !bundle) {
       position = Wallet.generatePosition()
       bundle = generateBundleHash(secret, 'Wallet::create')
     }
-    
-    // Wallet initialization
+
+    // Wallet initialization (matching JS SDK exactly)
+    // Bundle-only wallets (shadow) get no position/address generation
     return new Wallet({
       secret,
       bundle,
@@ -202,11 +193,15 @@ export default class Wallet {
     token: string
     position: string
   }): string {
+    // Normalize non-hex secret/position via SHAKE256 (matching JS/Rust SDKs)
+    const secretHex = isHex(secret) ? secret : shake256(secret, 1024)
+    const positionHex = isHex(position) ? position : shake256(position, 256)
+
     // Converting secret to bigInt
-    const bigIntSecret = BigInt(`0x${secret}`)
-    
+    const bigIntSecret = BigInt(`0x${secretHex}`)
+
     // Adding new position to the user secret to produce the indexed key
-    const indexedKey = bigIntSecret + BigInt(`0x${position}`)
+    const indexedKey = bigIntSecret + BigInt(`0x${positionHex}`)
     
     // Hashing the indexed key to produce the intermediate key
     // CRITICAL FIX: Use sponge pattern exactly like JavaScript SDK
@@ -383,8 +378,8 @@ export default class Wallet {
    */
   initializeMLKEM(): void {
     // Generate a 64-byte (512-bit) seed from the Knish.IO private key
-    // Use deterministic approach: generateSecret(key, 64) → matches JS SDK exactly
-    const seedHex = generateSecret(this.key!, 64)  // Matches JS SDK for cross-platform compatibility
+    // Use deterministic approach: generateSecret(key, 128) → 128 hex chars = 64 bytes
+    const seedHex = generateSecret(this.key!, 128)  // 128 hex chars = 64 bytes, matches JS SDK
     
     // Convert the hex string to a Uint8Array  
     const seed = new Uint8Array(64)

package/src/index.ts

@@ -113,6 +113,10 @@ export { default as MutationCreateMeta } from './mutation/MutationCreateMeta'
 export { default as MutationCreateToken } from './mutation/MutationCreateToken'
 export { default as MutationRequestTokens } from './mutation/MutationRequestTokens'
 
+// P-isotope and A-isotope Mutation classes
+export { default as MutationPeering } from './mutation/MutationPeering'
+export { default as MutationAppendRequest } from './mutation/MutationAppendRequest'
+
 // Essential Response classes (Phase 1)
 export { default as ResponseBalance } from './response/ResponseBalance'
 export { default as ResponseWalletBundle } from './response/ResponseWalletBundle'
@@ -134,6 +138,10 @@ export { default as ResponseMetaTypeViaAtom } from './response/ResponseMetaTypeV
 export { default as ResponseCreateToken } from './response/ResponseCreateToken'
 export { default as ResponseRequestTokens } from './response/ResponseRequestTokens'
 
+// P-isotope and A-isotope Response classes
+export { default as ResponsePeering } from './response/ResponsePeering'
+export { default as ResponseAppendRequest } from './response/ResponseAppendRequest'
+
 // Phase 2 Tier 2 Priority 3: Essential Query Operations
 export { default as ResponseContinuId } from './response/ResponseContinuId'
 // QueryBatch uses base Response class directly

package/src/instance/rules/Rule.ts

@@ -1,29 +1,138 @@
-/**
- * Rule class - Policy and rule management for KnishIO DLT
- * STUB IMPLEMENTATION - Full implementation pending
- */
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (/////////////)
+                       (////////////////(               (//////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-TS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
+*/
+
+import Callback from './Callback'
+import Condition from './Condition'
+import RuleArgumentException from './exception/RuleArgumentException'
+import { MetaMissingException } from '@/exception'
+
+interface RuleParams {
+  condition?: Condition[]
+  callback?: Callback[]
+}
+
+interface RuleJSON {
+  condition: Condition[]
+  callback: Callback[]
+}
+
 export default class Rule {
-  public name: string
-  public conditions: any[]
-  public actions: any[]
-
-  constructor(data: any = {}) {
-    this.name = data.name || ''
-    this.conditions = data.conditions || []
-    this.actions = data.actions || []
+  private __condition: Condition[]
+  private __callback: Callback[]
+
+  constructor({ condition = [], callback = [] }: RuleParams) {
+    for (const element of condition) {
+      if (!(element instanceof Condition)) {
+        throw new RuleArgumentException()
+      }
+    }
+
+    for (const element of callback) {
+      if (!(element instanceof Callback)) {
+        throw new RuleArgumentException()
+      }
+    }
+
+    this.__condition = condition
+    this.__callback = callback
+  }
+
+  /**
+   * Adds a condition to this rule
+   */
+  set comparison(condition: Condition | Record<string, any>) {
+    this.__condition.push(
+      condition instanceof Condition ? condition : Condition.toObject(condition as any)
+    )
+  }
+
+  /**
+   * Adds a callback to this rule
+   */
+  set callback(callback: Callback | Record<string, any>) {
+    this.__callback.push(
+      callback instanceof Callback ? callback : Callback.toObject(callback as any)
+    )
   }
 
   /**
    * Convert rule data to Rule object
-   * @param data - Rule data to convert
+   * @param object - Rule data to convert
    * @return Rule instance
    */
-  static toObject(data: any): Rule {
-    if (data instanceof Rule) {
-      return data
+  static toObject(object: any): Rule {
+    if (!object.condition) {
+      throw new MetaMissingException('Rule::toObject() - Incorrect rule format! There is no condition field.')
+    }
+    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
     }
-    return new Rule(data)
+
+    for (const callback of object.callback) {
+      rule.callback = callback
+    }
+
+    return rule
   }
 
-  // TODO: Implement remaining Rule methods
-}
+  /**
+   * Converts to JSON representation
+   */
+  toJSON(): RuleJSON {
+    return {
+      condition: this.__condition,
+      callback: this.__callback
+    }
+  }
+}

package/src/libraries/CheckMolecule.ts

@@ -71,6 +71,7 @@ import Rule from '@/instance/rules/Rule'
 import { base64ToHex, chunkSubstr } from '@/libraries/strings'
 import { shake256 } from '@/libraries/crypto'
 import Dot from '@/libraries/Dot'
+import Molecule from '@/core/Molecule'
 
 // Type definitions for Molecule structure
 interface MoleculeStructure {
@@ -461,7 +462,7 @@ export default class CheckMolecule {
         throw new TypeError('Invalid isotope "V" values')
       }
 
-      const remainder = senderWallet.balance + firstValue
+      const remainder = Number(senderWallet.balance) + firstValue
 
       // Is there enough balance to send?
       if (remainder < 0) {
@@ -578,4 +579,90 @@ export default class CheckMolecule {
     // Looks like we passed all the tests!
     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 = []
+  }: {
+    molecularHash: string
+    bundleHash: string
+    cellSlug?: string | null
+    status?: string | null
+    createdAt?: string | null
+    atoms?: any[]
+  }): Molecule {
+    const mappedAtoms = atoms.map((serverAtom: any) => {
+      let meta: Array<{ key: string; value: string }> = []
+      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: any): {
+    molecularHash: string | null
+    verified: boolean
+    error: string | null
+  } {
+    try {
+      const molecule = CheckMolecule.fromServerData(moleculeData)
+      new CheckMolecule(molecule as unknown as MoleculeStructure).verify()
+      return {
+        molecularHash: moleculeData.molecularHash,
+        verified: true,
+        error: null
+      }
+    } catch (error) {
+      return {
+        molecularHash: moleculeData.molecularHash || null,
+        verified: false,
+        error: (error as Error).message || String(error)
+      }
+    }
+  }
 }

package/src/libraries/crypto.ts

@@ -176,19 +176,15 @@ export function generateSecretEnhanced(options: SecretGenerationOptions): string
  * Generate bundle hash from secret - MUST produce identical results to JS SDK
  * Uses SHAKE256 with 256-bit output (64 hex characters)
  */
-export function generateBundleHash(secret: string, source: string | null = null): BundleHash {
+export function generateBundleHash(secret: string, _source: string | null = null): BundleHash {
   if (!secret || secret.length === 0) {
     throw new Error('Secret is required for bundle hash generation')
   }
 
-  let input = secret
-  if (source) {
-    input = secret + source
-  }
-
-  // Fix: BUNDLE_HASH_LENGTH is 64 (hex chars), but shake256 expects bits
-  // So we multiply by 4: 64 hex chars * 4 = 256 bits (matching JS SDK)
-  const hash = shake256(input, CRYPTO_CONSTANTS.BUNDLE_HASH_LENGTH * 4)
+  // CRITICAL: source parameter must be IGNORED to match JS SDK behavior.
+  // JS SDK's generateBundleHash() accepts source but never uses it.
+  // The bundle hash is an identity anchor and must be deterministic from secret alone.
+  const hash = shake256(secret, CRYPTO_CONSTANTS.BUNDLE_HASH_LENGTH * 4)
   return hash as BundleHash
 }
 
@@ -251,30 +247,18 @@ export function generatePositionEnhanced(options: PositionGenerationOptions = {}
  * Generate batch ID from molecular hash and index
  * Uses SHAKE256 to create deterministic batch identifiers
  */
-export function generateBatchId({ 
-  molecularHash = null, 
-  index = null 
-}: { 
+export function generateBatchId({
+  molecularHash = null,
+  index = null
+}: {
   molecularHash?: string | null
-  index?: number | null 
+  index?: number | null
 } = {}): string {
-  let input = ''
-  
-  if (molecularHash) {
-    input += molecularHash
+  // Match JS SDK: require BOTH molecularHash AND index for deterministic batch ID
+  if (molecularHash && index !== null) {
+    return shake256(molecularHash + index, 256) // 256 bits = 64 hex chars
   }
-  
-  if (index !== null) {
-    input += index.toString()
-  }
-  
-  // If no input provided, generate random batch ID
-  if (input === '') {
-    input = randomString(32)
-  }
-  
-  // Use SHAKE256 to generate 64-character batch ID
-  return shake256(input, 64)
+  return randomString(64)
 }
 
 // =============================================================================

package/src/libraries/strings.ts

@@ -78,7 +78,7 @@ export function chunkSubstr(str: string, size: number): string[] {
  */
 export function randomString(
   length = 32,
-  alphabet = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+  alphabet = 'abcdef0123456789'
 ): string {
   if (length <= 0) return ''
   
@@ -108,7 +108,8 @@ export function randomString(
 
 /**
  * Convert between different character sets/bases
- * Ported from JavaScript SDK for cross-platform compatibility
+ * Uses BigInt for arbitrary-precision arithmetic to handle 256-bit hashes
+ * MUST match JavaScript SDK charsetBaseConvert exactly
  */
 export function charsetBaseConvert(
   src: string,
@@ -120,37 +121,37 @@ export function charsetBaseConvert(
   if (!src || fromBase < 2 || toBase < 2 || fromBase > srcSymbolTable.length || toBase > destSymbolTable.length) {
     return false
   }
-  
+
   try {
-    // Convert from source base to decimal
-    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) {
+    // Convert from source base to BigInt (arbitrary precision)
+    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 // Invalid character for source base
       }
-      
-      decimalValue += charIndex * Math.pow(fromBase, i)
+
+      val = val * bigFromBase + BigInt(symbolIndex)
     }
-    
-    // Convert from decimal to destination base
-    if (decimalValue === 0) {
+
+    // Convert from BigInt to destination base
+    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
   }

package/src/mutation/MutationAppendRequest.ts

@@ -0,0 +1,52 @@
+/*
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-TS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
+*/
+
+import MutationProposeMolecule from './MutationProposeMolecule'
+import ResponseAppendRequest from '../response/ResponseAppendRequest'
+
+/**
+ * Mutation for submitting an append request via the A-isotope
+ * Matches JavaScript SDK MutationAppendRequest implementation exactly
+ */
+export default class MutationAppendRequest extends MutationProposeMolecule {
+  /**
+   * Fills a molecule with an A-isotope append request atom
+   * Matches JavaScript SDK fillMolecule method exactly
+   */
+  override fillMolecule({
+    metaType,
+    metaId,
+    action,
+    meta = {}
+  }: {
+    metaType: string
+    metaId: string
+    action: string
+    meta?: Record<string, any>
+  }): void {
+    (this.$__molecule as any).initAppendRequest({
+      metaType,
+      metaId,
+      action,
+      meta
+    });
+    (this.$__molecule as any).sign({});
+    (this.$__molecule as any).check()
+  }
+
+  /**
+   * Builds a Response object out of a JSON object
+   * Matches JavaScript SDK createResponse method exactly
+   */
+  override createResponse(json: any): ResponseAppendRequest {
+    return new ResponseAppendRequest({
+      query: this,
+      json
+    })
+  }
+}

package/src/mutation/MutationCreateRule.ts

@@ -65,8 +65,8 @@ export default class MutationCreateRule extends MutationProposeMolecule {
   }: {
     metaType: MetaType
     metaId: MetaId
-    rule: Record<string, any>[]
-    policy: Record<string, any>
+    rule: any[] | any  // Accept single object or array
+    policy?: Record<string, any> | null
   }): void {
     (this.$__molecule as any).createRule({
       metaType,

package/src/mutation/MutationPeering.ts

@@ -0,0 +1,37 @@
+/*
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-TS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
+*/
+
+import MutationProposeMolecule from './MutationProposeMolecule'
+import ResponsePeering from '../response/ResponsePeering'
+
+/**
+ * Mutation for registering a peer node via the P-isotope
+ * Matches JavaScript SDK MutationPeering implementation exactly
+ */
+export default class MutationPeering extends MutationProposeMolecule {
+  /**
+   * Fills a molecule with a P-isotope peering atom
+   * Matches JavaScript SDK fillMolecule method exactly
+   */
+  override fillMolecule({ host }: { host: string }): void {
+    (this.$__molecule as any).initPeering({ host });
+    (this.$__molecule as any).sign({});
+    (this.$__molecule as any).check()
+  }
+
+  /**
+   * Builds a Response object out of a JSON object
+   * Matches JavaScript SDK createResponse method exactly
+   */
+  override createResponse(json: any): ResponsePeering {
+    return new ResponsePeering({
+      query: this,
+      json
+    })
+  }
+}

package/src/mutation/MutationRequestAuthorization.ts

@@ -59,9 +59,9 @@ export default class MutationRequestAuthorization extends MutationProposeMolecul
    * Matches JavaScript SDK fillMolecule method exactly
    */
   override fillMolecule({ meta }: { meta: any }): void {
-    (this.$__molecule as any).initAuthorization({ meta });
-    (this.$__molecule as any).sign({});
-    (this.$__molecule as any).check()
+    this.$__molecule.initAuthorization({ meta })
+    this.$__molecule.sign({})
+    this.$__molecule.check()
   }
 
   /**

package/src/query/QueryActiveSession.ts

@@ -71,7 +71,6 @@ export default class QueryActiveSession extends Query {
           metaId
           jsonData
           createdAt
-          updatedAt
         }
       }
     `

package/src/query/QueryContinuId.ts

@@ -79,6 +79,14 @@ export default class QueryContinuId extends Query {
     }`
   }
 
+  /**
+   * Force network-only for ContinuID queries to prevent URQL cache from
+   * returning stale wallet positions after mutations advance the ContinuID chain
+   */
+  override createQueryContext(): Record<string, any> {
+    return { requestPolicy: 'network-only' }
+  }
+
   /**
    * Returns a Response object
    * Matches JavaScript SDK createResponse method exactly