@wishknish/knishio-client-js 0.7.4 → 0.7.6

package/src/query/QueryMetaTypeViaMolecule.js

@@ -0,0 +1,223 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (//////////////)
+                       (////////////////(               (///////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
+*/
+import Query from './Query.js'
+import ResponseMetaTypeViaMolecule from '../response/ResponseMetaTypeViaMolecule.js'
+import { gql } from '@urql/core'
+
+/**
+ * Query for retrieving Meta Asset information via Molecule data.
+ *
+ * Unlike QueryMetaTypeViaAtom, this query does NOT request the redundant
+ * instance-level `metas` field. Instead, metadata is extracted client-side
+ * from molecule atoms' `metasJson`, eliminating duplicate data transfer.
+ */
+export default class QueryMetaTypeViaMolecule extends Query {
+  /**
+   * @param {UrqlClientWrapper} graphQLClient
+   * @param {KnishIOClient} knishIOClient
+   */
+  constructor (graphQLClient, 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
+   *
+   * @param {string|array|null} metaType
+   * @param {string|array|null} metaId
+   * @param {string|null} key
+   * @param {string|null} value
+   * @param {array|null} values
+   * @param {array|null} keys
+   * @param {array|null} atomValues
+   * @param {boolean|null} latest
+   * @param {array|null} filter
+   * @param {object|null} queryArgs
+   * @param {string|null} countBy
+   * @param {string|null} cellSlug
+   * @return {{}}
+   */
+  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
+   *
+   * @param {object} json
+   * @return {ResponseMetaTypeViaMolecule}
+   */
+  createResponse (json) {
+    return new ResponseMetaTypeViaMolecule({
+      query: this,
+      json
+    })
+  }
+}

package/src/query/QueryWalletList.js

@@ -60,8 +60,8 @@ export default class QueryWalletList extends Query {
   constructor (graphQLClient, 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/ResponseContinuId.js

@@ -91,7 +91,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/ResponseMetaTypeViaMolecule.js

@@ -0,0 +1,210 @@
+/*
+                               (
+                              (/(
+                              (//(
+                              (///(
+                             (/////(
+                             (//////(                          )
+                            (////////(                        (/)
+                            (////////(                       (///)
+                           (//////////(                      (////)
+                           (//////////(                     (//////)
+                          (////////////(                    (///////)
+                         (/////////////(                   (/////////)
+                        (//////////////(                  (///////////)
+                        (///////////////(                (//////////////)
+                       (////////////////(               (///////////////)
+                      (((((((((((((((((((              (((((((((((((((
+                     (((((((((((((((((((              ((((((((((((((
+                     (((((((((((((((((((            ((((((((((((((
+                    ((((((((((((((((((((           (((((((((((((
+                    ((((((((((((((((((((          ((((((((((((
+                    (((((((((((((((((((         ((((((((((((
+                    (((((((((((((((((((        ((((((((((
+                    ((((((((((((((((((/      (((((((((
+                    ((((((((((((((((((     ((((((((
+                    (((((((((((((((((    (((((((
+                   ((((((((((((((((((  (((((
+                   #################  ##
+                   ################  #
+                  ################# ##
+                 %################  ###
+                 ###############(   ####
+                ###############      ####
+               ###############       ######
+              %#############(        (#######
+             %#############           #########
+            ############(              ##########
+           ###########                  #############
+          #########                      ##############
+        %######
+
+        Powered by Knish.IO: Connecting a Decentralized World
+
+Please visit https://github.com/WishKnish/KnishIO-Client-JS for information.
+
+License: https://github.com/WishKnish/KnishIO-Client-JS/blob/master/LICENSE
+*/
+
+import Query from '../query/Query.js'
+import Response from './Response.js'
+import CheckMolecule from '../libraries/CheckMolecule.js'
+
+/**
+ * Response for MetaType queries via Molecule data.
+ *
+ * Instead of using the redundant instance-level `metas` field,
+ * this response extracts metadata from molecule atoms' `metasJson`,
+ * producing a payload format compatible with ResponseMetaType and
+ * ResponseMetaTypeViaAtom for drop-in replacement usage.
+ */
+export default class ResponseMetaTypeViaMolecule extends Response {
+  /**
+   * Class constructor
+   *
+   * @param {Query} query
+   * @param {object} json
+   */
+  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.
+   *
+   * @param {object} molecule - Molecule data with atoms array
+   * @param {string} metaType - Instance meta type to filter by
+   * @param {string} metaId - Instance meta ID to filter by
+   * @return {Array<{molecularHash: string, position: string, key: string, value: string, createdAt: string}>}
+   */
+  static extractMetasFromMolecule (molecule, metaType, metaId) {
+    if (!molecule || !molecule.atoms) {
+      return []
+    }
+
+    const metas = []
+
+    for (const atom of molecule.atoms) {
+      // Filter atoms to those matching this instance's metaType and metaId
+      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 }
+   *
+   * @return {null|{instances: Array, instanceCount: Array, paginatorInfo: object}}
+   */
+  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 => {
+        // Prefer server-filtered metas (from metas sub-field) 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. For each instance, reconstructs
+   * the molecule from server data and runs CheckMolecule.verify() to validate
+   * the molecular hash and OTS signature.
+   *
+   * @return {{ verified: boolean, molecules: Array<{ molecularHash: string, verified: boolean, error: string|null }> }}
+   */
+  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
+    }
+  }
+}

package/src/response/ResponseRequestAuthorization.js

@@ -76,7 +76,7 @@ export default class ResponseRequestAuthorization extends ResponseProposeMolecul
   }
 
   /**
-   * Returns timestamp
+   * Returns raw time value from payload
    *
    * @return {string}
    */
@@ -84,6 +84,39 @@ export default class ResponseRequestAuthorization extends ResponseProposeMolecul
     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
+   *
+   * @return {number}
+   */
+  expiresAt () {
+    // 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)
+  }
+
   /**
    *
    * @return {string}

package/src/response/ResponseRequestAuthorizationGuest.js

@@ -120,7 +120,7 @@ export default class ResponseRequestAuthorizationGuest extends Response {
   }
 
   /**
-   * Returns timestamp
+   * Returns raw time value from payload
    *
    * @return {*}
    */
@@ -128,6 +128,37 @@ export default class ResponseRequestAuthorizationGuest extends Response {
     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
+   *
+   * @return {number}
+   */
+  expiresAt () {
+    // 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
+    if (timeValue >= 1577836800) {
+      return timeValue
+    }
+
+    // Otherwise, time is a lifetime in milliseconds (PHP server format)
+    return Math.floor(Date.now() / 1000) + Math.floor(timeValue / 1000)
+  }
+
   /**
    * Returns timestamp
    *

package/src/response/ResponseWalletList.js

@@ -122,7 +122,7 @@ export default class ResponseWalletList extends Response {
       }
     }
 
-    wallet.balance = Number(data.amount)
+    wallet.balance = String(data.amount != null ? data.amount : 0)
     wallet.pubkey = data.pubkey
     wallet.createdAt = data.createdAt