@wishknish/knishio-client-ts 0.7.4 → 0.7.6

package/src/query/QueryMetaTypeViaMolecule.ts

@@ -0,0 +1,221 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (//////////////)
+                       (////////////////(               (///////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 Query from './Query'
+import ResponseMetaTypeViaMolecule from '../response/ResponseMetaTypeViaMolecule'
+import { gql } from '@urql/core'
+import type { GraphQLClient } from '../types/graphql'
+import type KnishIOClient from '../KnishIOClient'
+
+/**
+ * Query for retrieving Meta Asset information via Molecule data.
+ *
+ * Unlike QueryMetaTypeViaAtom, this query includes molecule data with atoms
+ * (including otsFragment and metasJson) for integrity verification and
+ * client-side metadata extraction.
+ */
+export default class QueryMetaTypeViaMolecule extends Query {
+  /**
+   * Create new QueryMetaTypeViaMolecule instance
+   */
+  constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
+    super(graphQLClient, knishIOClient)
+
+    this.$__query = 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
+  }: {
+    metaType?: string | string[] | null
+    metaId?: string | string[] | null
+    key?: string | null
+    value?: string | null
+    keys?: string[] | null
+    values?: string[] | null
+    atomValues?: string[] | null
+    latest?: boolean | null
+    filter?: any[] | null
+    queryArgs?: any | null
+    countBy?: string | null
+    cellSlug?: string | string[] | null
+  } = {}): Record<string, any> {
+    const variables: Record<string, any> = {}
+
+    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
+   */
+  override createResponse(json: any): ResponseMetaTypeViaMolecule {
+    return new ResponseMetaTypeViaMolecule({
+      query: this,
+      json
+    })
+  }
+}

package/src/query/QueryWalletList.ts

@@ -64,8 +64,8 @@ export default class QueryWalletList extends Query {
   constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = gql`query( $bundleHash: String, $tokenSlug: String ) {
-      Wallet( bundleHash: $bundleHash, tokenSlug: $tokenSlug ) {
+    this.$__query = gql`query( $bundleHash: String, $token: String ) {
+      Wallet( bundleHash: $bundleHash, token: $token ) {
         address,
         bundleHash,
         token {

package/src/response/ResponseAppendRequest.ts

@@ -0,0 +1,17 @@
+/*
+        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 ResponseProposeMolecule from './ResponseProposeMolecule'
+
+/**
+ * Response for append requests via A-isotope
+ * Matches JavaScript SDK ResponseAppendRequest implementation exactly
+ */
+export default class ResponseAppendRequest extends ResponseProposeMolecule {
+
+}

package/src/response/ResponseBalance.ts

@@ -77,7 +77,10 @@ export default class ResponseBalance extends Response {
    * Matches JavaScript SDK payload() method exactly
    */
   override payload(): Wallet | null {
-    const walletData = this.data() as any
+    const balanceData = this.data() as any
+
+    // Balance query returns an array, get the first result
+    const walletData = Array.isArray(balanceData) ? balanceData[0] : balanceData
 
     if (!walletData || !walletData.bundleHash || !walletData.tokenSlug) {
       return null
@@ -102,7 +105,9 @@ export default class ResponseBalance extends Response {
   }): Wallet {
     let wallet: Wallet
 
-    if (data.position === null || typeof data.position === 'undefined') {
+    // Handle null, undefined, or empty string positions
+    // Empty positions occur for shadow wallets created before this fix
+    if (!data.position) {
       wallet = Wallet.create({
         bundle: data.bundleHash,
         token: data.tokenSlug,
@@ -144,7 +149,7 @@ export default class ResponseBalance extends Response {
     }
 
     // Set balance and other properties
-    wallet.balance = Number(data.amount || 0)
+    wallet.balance = String(data.amount != null ? data.amount : 0)
     wallet.pubkey = data.pubkey
     wallet.createdAt = data.createdAt
 

package/src/response/ResponseContinuId.ts

@@ -93,7 +93,7 @@ export default class ResponseContinuId extends Response {
       wallet.batchId = continuId.batchId
       wallet.characters = continuId.characters
       wallet.pubkey = continuId.pubkey
-      wallet.balance = continuId.amount * 1.0
+      wallet.balance = String(continuId.amount != null ? continuId.amount : 0)
     }
 
     return wallet

package/src/response/ResponseMetaType.ts

@@ -72,37 +72,50 @@ export default class ResponseMetaType extends Response {
     })
   }
 
+  /**
+   * Extracts payload from metaData object
+   */
+  private extractPayload(metaData: any): any {
+    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)
    */
   override payload(): any | null {
     const metaTypeData = this.data()
 
-    if (!metaTypeData || metaTypeData.length === 0) {
+    // Handle null/undefined responses
+    if (metaTypeData === null || metaTypeData === undefined) {
       return null
     }
 
-    const response: any = {
-      instances: {},
-      instanceCount: {},
-      paginatorInfo: {}
-    }
-
-    const metaData = metaTypeData.pop()
-
-    if (metaData.instances) {
-      response.instances = metaData.instances
-    }
-
-    if (metaData.instanceCount) {
-      response.instanceCount = metaData.instanceCount
+    // Handle array response (expected format)
+    if (Array.isArray(metaTypeData)) {
+      if (metaTypeData.length === 0) {
+        // Return empty structure instead of null for empty results
+        return this.extractPayload(null)
+      }
+      // Get last element without mutating the array
+      const metaData = metaTypeData[metaTypeData.length - 1]
+      return this.extractPayload(metaData)
     }
 
-    if (metaData.paginatorInfo) {
-      response.paginatorInfo = metaData.paginatorInfo
+    // Handle single object response (some filtered queries)
+    if (typeof metaTypeData === 'object') {
+      return this.extractPayload(metaTypeData)
     }
 
-    return response
+    // Unknown format, return null
+    return null
   }
 }

package/src/response/ResponseMetaTypeViaMolecule.ts

@@ -0,0 +1,224 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (//////////////)
+                       (////////////////(               (///////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        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 type Query from '../query/Query'
+import Response from './Response'
+import CheckMolecule from '../libraries/CheckMolecule'
+
+/**
+ * Response for MetaType queries via Molecule data.
+ *
+ * Instead of relying solely on the instance-level `metas` field,
+ * this response can extract metadata from molecule atoms' `metasJson`,
+ * and provides cryptographic integrity verification via `verifyIntegrity()`.
+ */
+export default class ResponseMetaTypeViaMolecule extends Response {
+  /**
+   * Class constructor
+   */
+  constructor({
+    query,
+    json
+  }: {
+    query: Query
+    json: any
+  }) {
+    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: any,
+    metaType: string,
+    metaId: string
+  ): Array<{
+    molecularHash: string
+    position: string
+    key: string
+    value: string
+    createdAt: string
+  }> {
+    if (!molecule || !molecule.atoms) {
+      return []
+    }
+
+    const metas: Array<{
+      molecularHash: string
+      position: string
+      key: string
+      value: string
+      createdAt: string
+    }> = []
+
+    for (const atom of molecule.atoms) {
+      if (atom.metaType !== metaType || atom.metaId !== metaId) {
+        continue
+      }
+
+      if (!atom.metasJson) {
+        continue
+      }
+
+      let parsed: any
+      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 }
+   */
+  override payload(): any | null {
+    const metaTypeData = this.data()
+
+    if (!metaTypeData || metaTypeData.length === 0) {
+      return null
+    }
+
+    const response: any = {
+      instances: {},
+      instanceCount: {},
+      paginatorInfo: {}
+    }
+
+    const metaData = metaTypeData.pop()
+
+    if (metaData.instances) {
+      response.instances = metaData.instances.map((instance: any) => {
+        // Prefer server-filtered metas when available
+        let metas = instance.metas
+        if (!metas || metas.length === 0) {
+          // Fallback: synthesize from molecule atoms' metasJson
+          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(): {
+    verified: boolean
+    molecules: Array<{
+      molecularHash: string | null
+      verified: boolean
+      error: string | null
+    }>
+  } {
+    const results: Array<{
+      molecularHash: string | null
+      verified: boolean
+      error: string | null
+    }> = []
+    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: any) => r.verified),
+      molecules: results
+    }
+  }
+}

package/src/response/ResponsePeering.ts

@@ -0,0 +1,17 @@
+/*
+        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 ResponseProposeMolecule from './ResponseProposeMolecule'
+
+/**
+ * Response for peer registration via P-isotope
+ * Matches JavaScript SDK ResponsePeering implementation exactly
+ */
+export default class ResponsePeering extends ResponseProposeMolecule {
+
+}

package/src/response/ResponsePolicy.ts

@@ -65,10 +65,9 @@ export default class ResponsePolicy extends Response {
   }) {
     super({
       query,
-      json
+      json,
+      dataKey: 'data.Policy'
     })
-    this.dataKey = 'data.Policy'
-    this.init()
   }
 
   /**

package/src/response/ResponseProposeMolecule.ts

@@ -74,7 +74,6 @@ export default class ResponseProposeMolecule extends Response {
       dataKey: 'data.ProposeMolecule'
     })
     this.$__clientMolecule = (query as any).molecule()
-    this.init()
   }
 
   /**

package/src/response/ResponseRequestAuthorization.ts

@@ -75,13 +75,43 @@ export default class ResponseRequestAuthorization extends ResponseProposeMolecul
   }
 
   /**
-   * Returns timestamp
-   * Matches JavaScript SDK time method exactly
+   * Returns raw time value from payload
    */
   time(): string {
     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(): number {
+    // Try the explicit expiresAt payload key first (PHP server provides this)
+    try {
+      const ea = this.payloadKey('expiresAt')
+      if (ea) {
+        return Number(ea)
+      }
+    } catch (_e) {
+      // Not available in payload, fall back
+    }
+
+    // Use time field with heuristic detection
+    const timeValue = Number(this.time())
+
+    // If timeValue looks like a valid Unix timestamp (>= year 2020), use directly
+    // Rust server sets time = Unix timestamp in seconds
+    if (timeValue >= 1577836800) {
+      return timeValue
+    }
+
+    // Otherwise, time is a lifetime in milliseconds (PHP server format)
+    // Convert to Unix timestamp: now_seconds + lifetime_seconds
+    return Math.floor(Date.now() / 1000) + Math.floor(timeValue / 1000)
+  }
+
   /**
    * Returns encryption info
    * Matches JavaScript SDK encrypt method exactly