@wishknish/knishio-client-ts 0.7.0 → 0.7.2

package/src/core/Atom.ts

@@ -54,7 +54,7 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
  * while ensuring perfect compatibility with other SDK implementations.
  */
 
-import { shake256, convertToBase17 } from '@/libraries/crypto'
+import { convertToBase17 } from '@/libraries/crypto'
 import JsSHA from 'jssha'
 import { PROTOCOL_CONFIG } from '@/constants'
 import { handleIsotope, isWalletAddress, isPosition } from '@/types/guards'

package/src/core/Molecule.ts

@@ -52,7 +52,6 @@ import Wallet from './Wallet'
 import CheckMolecule from '@/libraries/CheckMolecule'
 import { chunkSubstr, hexToBase64 } from '@/libraries/strings'
 import { generateBundleHash, generateOTSSignature } from '@/libraries/crypto'
-import { deepCloning } from '@/libraries/array'
 import {
   AtomsMissingException,
   BalanceInsufficientException,

package/src/core/Wallet.ts

@@ -48,7 +48,7 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import JsSHA from 'jssha'
 import { randomString, chunkSubstr } from '@/libraries/strings'
-import { generateBundleHash, generateSecret, shake256 } from '@/libraries/crypto'
+import { generateBundleHash, generateSecret, shake256, generateBatchId } from '@/libraries/crypto'
 import WalletCredentialException from '@/exception/WalletCredentialException'
 import { isWalletAddress, isBundleHash, isPosition } from '@/types'
 // Post-quantum cryptography for ML-KEM768 key encapsulation
@@ -73,6 +73,13 @@ export default class Wallet {
   public tradeRates: Record<string, any>
   public molecules: Record<string, any>
 
+  // Token metadata (populated from query responses)
+  public tokenName?: string
+  public tokenAmount?: string
+  public tokenSupply?: string
+  public tokenFungibility?: string
+  public createdAt?: string
+
   constructor({
     secret = null,
     bundle = null,
@@ -291,6 +298,62 @@ export default class Wallet {
     })
   }
 
+  /**
+   * Sets up a batch ID - either using the sender's, or a new one
+   * Matches JavaScript SDK Wallet.initBatchId exactly
+   */
+  initBatchId({
+    sourceWallet,
+    isRemainder = false
+  }: {
+    sourceWallet: Wallet
+    isRemainder?: boolean
+  }): void {
+    if (sourceWallet.batchId) {
+      this.batchId = isRemainder ? sourceWallet.batchId : generateBatchId({})
+    }
+  }
+
+  /**
+   * Split token units between wallets
+   * Matches JavaScript SDK Wallet.splitUnits exactly
+   *
+   * @param units - Array of token unit IDs to transfer
+   * @param remainderWallet - Wallet to receive units not being transferred
+   * @param recipientWallet - Wallet to receive the transferred units (optional)
+   */
+  splitUnits(
+    units: string[],
+    remainderWallet: Wallet,
+    recipientWallet: Wallet | null = null
+  ): void {
+    // No units supplied, nothing to split
+    if (units.length === 0) {
+      return
+    }
+
+    // Init recipient & remainder token units
+    const recipientTokenUnits: any[] = []
+    const remainderTokenUnits: any[] = []
+
+    this.tokenUnits.forEach(tokenUnit => {
+      if (units.includes(tokenUnit.id)) {
+        recipientTokenUnits.push(tokenUnit)
+      } else {
+        remainderTokenUnits.push(tokenUnit)
+      }
+    })
+
+    // Reset token units to the sending value
+    this.tokenUnits = recipientTokenUnits
+
+    // Set token units to recipient & remainder
+    if (recipientWallet !== null) {
+      recipientWallet.tokenUnits = recipientTokenUnits
+    }
+    remainderWallet.tokenUnits = remainderTokenUnits
+  }
+
   /**
    * Get token units data
    * Stub for compatibility
@@ -319,9 +382,9 @@ export default class Wallet {
    * Initializes the ML-KEM key pair (matches JavaScript SDK exactly)
    */
   initializeMLKEM(): void {
-    // Generate a 64-byte (512-bit) seed from the Knish.IO private key  
-    // Use deterministic approach: generateSecret(key, 128) → 128 hex chars = 64 bytes
-    const seedHex = generateSecret(this.key!, 128)  // 128 hex chars = 64 bytes
+    // 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
     
     // Convert the hex string to a Uint8Array  
     const seed = new Uint8Array(64)
@@ -408,7 +471,7 @@ export default class Wallet {
     // Import shared secret as CryptoKey
     const key = await crypto.subtle.importKey(
       'raw',
-      sharedSecret,
+      sharedSecret as BufferSource,
       { name: 'AES-GCM' },
       false,
       ['encrypt']
@@ -418,7 +481,7 @@ export default class Wallet {
     const encryptedContent = await crypto.subtle.encrypt(
       { name: 'AES-GCM', iv },
       key,
-      message
+      message as BufferSource
     )
     
     // Combine IV and encrypted content
@@ -440,7 +503,7 @@ export default class Wallet {
     // Import shared secret as CryptoKey
     const key = await crypto.subtle.importKey(
       'raw',
-      sharedSecret,
+      sharedSecret as BufferSource,
       { name: 'AES-GCM' },
       false,
       ['decrypt']
@@ -450,7 +513,7 @@ export default class Wallet {
     const decryptedContent = await crypto.subtle.decrypt(
       { name: 'AES-GCM', iv },
       key,
-      ciphertext
+      ciphertext as BufferSource
     )
     
     return new Uint8Array(decryptedContent)

package/src/libraries/CheckMolecule.ts

@@ -248,10 +248,10 @@ export default class CheckMolecule {
       const metas = Meta.aggregateMeta(atom.meta)
 
       for (const key of policyArray) {
-        let policy = metas[key]
+        const policyRaw = metas[key]
 
-        if (policy) {
-          policy = JSON.parse(policy as string) as Record<string, any>
+        if (policyRaw) {
+          const policy = JSON.parse(policyRaw as string) as Record<string, any>
 
           for (const [policyName, policyValue] of Object.entries(policy)) {
             if (!policyArray.includes(policyName)) {

package/src/libraries/GraphQLClient.ts

@@ -55,7 +55,12 @@ import {
 } from '@urql/core'
 import { createClient as createWSClient } from 'graphql-ws'
 import { pipe, subscribe } from 'wonka'
-import type { GraphQLClient as IGraphQLClient } from '@/types'
+import type {
+  GraphQLClient as IGraphQLClient,
+  GraphQLRequest,
+  GraphQLResponse,
+  GraphQLVariables
+} from '@/types'
 import type Wallet from '@/core/Wallet'
 
 /**
@@ -89,8 +94,7 @@ export default class GraphQLClient implements IGraphQLClient {
 
   private createUrqlClient({
     serverUri,
-    socket,
-    encrypt
+    socket
   }: {
     serverUri: string
     socket?: { socketUri: string | null } | null
@@ -111,7 +115,7 @@ export default class GraphQLClient implements IGraphQLClient {
         subscriptionExchange({
           forwardSubscription: (operation) => ({
             subscribe: (sink) => {
-              const disposable = wsClient.subscribe(operation, sink)
+              const disposable = wsClient.subscribe(operation as any, sink as any)
               return { unsubscribe: disposable }
             }
           })
@@ -153,29 +157,63 @@ export default class GraphQLClient implements IGraphQLClient {
     })
   }
 
-  async query<TResult = unknown, TVariables = Record<string, any>>(
-    request: { query: string; variables?: TVariables },
+  async query<TResult = unknown, TVariables = GraphQLVariables>(
+    request: GraphQLRequest,
     variables?: TVariables
-  ): Promise<any> {
-    const finalVariables = variables || request.variables || {}
+  ): Promise<GraphQLResponse<TResult>> {
+    const finalVariables = (variables || request.variables || {}) as Record<string, any>
     const result = await this.$__client.query(request.query, finalVariables).toPromise()
-    return this.formatResponse(result)
+    return this.formatResponse<TResult>(result)
   }
 
-  async mutate<TResult = unknown, TVariables = Record<string, any>>(
-    request: { mutation: string; variables?: TVariables },
+  async mutation<TResult = unknown, TVariables = GraphQLVariables>(
+    request: GraphQLRequest,
     variables?: TVariables
-  ): Promise<any> {
-    const finalVariables = variables || request.variables || {}
-    const result = await this.$__client.mutation(request.mutation, finalVariables).toPromise()
-    return this.formatResponse(result)
+  ): Promise<GraphQLResponse<TResult>> {
+    const finalVariables = (variables || request.variables || {}) as Record<string, any>
+    // Support both query and mutation properties for backward compatibility
+    const mutationString = (request as any).mutation || request.query
+    const result = await this.$__client.mutation(mutationString, finalVariables).toPromise()
+    return this.formatResponse<TResult>(result)
   }
 
-  async mutation<TResult = unknown, TVariables = Record<string, any>>(
-    request: { mutation: string; variables?: TVariables },
+  // Alias for mutation() to match JS SDK interface
+  async mutate<TResult = unknown, TVariables = GraphQLVariables>(
+    request: GraphQLRequest,
     variables?: TVariables
-  ): Promise<any> {
-    return this.mutate(request, variables)
+  ): Promise<GraphQLResponse<TResult>> {
+    return this.mutation<TResult, TVariables>(request, variables)
+  }
+
+  async *subscription<TResult = unknown, TVariables = GraphQLVariables>(
+    request: GraphQLRequest,
+    variables?: TVariables
+  ): AsyncIterableIterator<GraphQLResponse<TResult>> {
+    const finalVariables = (variables || request.variables || {}) as Record<string, any>
+
+    // Create subscription stream
+    const subscription = this.$__client.subscription(request.query, finalVariables)
+
+    // Convert wonka stream to async iterator
+    const results: GraphQLResponse<TResult>[] = []
+    const { unsubscribe } = pipe(
+      subscription,
+      subscribe((result) => {
+        results.push(this.formatResponse<TResult>(result))
+      })
+    )
+
+    try {
+      while (true) {
+        if (results.length > 0) {
+          yield results.shift()!
+        }
+        // Small delay to prevent busy waiting
+        await new Promise(resolve => setTimeout(resolve, 10))
+      }
+    } finally {
+      unsubscribe()
+    }
   }
 
   subscribe(
@@ -203,12 +241,12 @@ export default class GraphQLClient implements IGraphQLClient {
     }
   }
 
-  private formatResponse(result: any): any {
-    // Match old Apollo response format
+  private formatResponse<T>(result: any): GraphQLResponse<T> {
+    // Match JS SDK (UrqlClientWrapper) response format exactly
     return {
       data: result.data,
       errors: result.error ? [result.error] : undefined
-    }
+    } as GraphQLResponse<T>
   }
 
   unsubscribe(operationName: string): void {
@@ -220,7 +258,7 @@ export default class GraphQLClient implements IGraphQLClient {
   }
 
   unsubscribeAll(): void {
-    this.$__subscriptionManager.forEach((subscription, operationName) => {
+    this.$__subscriptionManager.forEach((_subscription, operationName) => {
       this.unsubscribe(operationName)
     })
   }

package/src/libraries/array.ts

@@ -72,7 +72,7 @@ export function diff<T>(...arrays: T[][]): T[] {
   return [].concat(...arrays.map((arr, i) => {
     const others = arrays.slice(0)
     others.splice(i, 1)
-    const unique = [...new Set([].concat(...others as any))]
+    const unique: T[] = [...new Set([].concat(...others as any))] as T[]
     return arr.filter(item => !unique.includes(item))
   }) as any)
 }
@@ -83,7 +83,7 @@ export function diff<T>(...arrays: T[][]): T[] {
  */
 export function intersect<T>(...arrays: T[][]): T[] {
   if (arrays.length === 0) return []
-  if (arrays.length === 1) return arrays[0]
+  if (arrays.length === 1) return arrays[0]!
   
   return arrays.reduce((first, second) => 
     first.filter(item => second.includes(item))

package/src/libraries/crypto.ts

@@ -110,9 +110,11 @@ export function shake256(input: string, outputLength: number): string {
  */
 export function shake256Enhanced(options: SHAKE256Options): string {
   const { input, outputLength, encoding = 'hex' } = options
-  
-  const sponge = new JsSHA('SHAKE256', typeof input === 'string' ? 'TEXT' : 'UINT8ARRAY')
-  sponge.update(input)
+
+  // Always treat input as string for SHAKE256
+  const inputStr = typeof input === 'string' ? input : Array.from(input).map(b => String.fromCharCode(b)).join('')
+  const sponge = new JsSHA('SHAKE256', 'TEXT')
+  sponge.update(inputStr)
   
   // outputLength is in BITS consistently across all encodings
   switch (encoding) {
@@ -136,7 +138,7 @@ export function shake256Enhanced(options: SHAKE256Options): string {
  * If seed provided: uses SHAKE256 to generate deterministic secret
  * If no seed: uses cryptographically secure random string
  */
-export function generateSecret(seed: string | null = null, length = CRYPTO_CONSTANTS.SECRET_LENGTH): string {
+export function generateSecret(seed: string | null = null, length: number = CRYPTO_CONSTANTS.SECRET_LENGTH): string {
   if (seed) {
     // Deterministic generation using SHAKE256 - MUST match JS SDK
     const sponge = new JsSHA('SHAKE256', 'TEXT')
@@ -221,10 +223,10 @@ export function generatePosition(): Position {
  * Enhanced position generation with options
  */
 export function generatePositionEnhanced(options: PositionGenerationOptions = {}): Position {
-  const { 
+  const {
     entropy = null,
-    algorithm = 'SHAKE256',
-    length = CRYPTO_CONSTANTS.POSITION_LENGTH 
+    algorithm: _algorithm = 'SHAKE256',
+    length = CRYPTO_CONSTANTS.POSITION_LENGTH
   } = options
 
   if (entropy) {
@@ -499,21 +501,21 @@ export function charsetBaseConvert(
   fromCharset: string,
   toCharset: string
 ): string {
-  if (input === '') return toCharset[0]
-  
+  if (input === '') return toCharset[0]!
+
   // Convert input from source base to decimal using BigInt for precision
   let decimal = 0n
   for (let i = 0; i < input.length; i++) {
-    const char = input[i]
+    const char = input[i]!
     const value = BigInt(fromCharset.indexOf(char))
     if (value === -1n) {
       throw new Error(`Invalid character '${char}' for source base ${fromBase}`)
     }
     decimal = decimal * BigInt(fromBase) + value
   }
-  
+
   // Convert decimal to target base
-  if (decimal === 0n) return toCharset[0]
+  if (decimal === 0n) return toCharset[0]!
   
   let result = ''
   while (decimal > 0n) {
@@ -557,9 +559,9 @@ export function enumerateMolecularHash(hash: string): number[] {
   const hashList = hash.toLowerCase().split('')
   
   for (let index = 0; index < hashList.length; index++) {
-    const symbol = hashList[index]
+    const symbol = hashList[index]!
     if (typeof mapped[symbol] !== 'undefined') {
-      target[index] = mapped[symbol]
+      target[index] = mapped[symbol]!
     } else {
       throw new Error(`Invalid character '${symbol}' in molecular hash`)
     }
@@ -581,19 +583,20 @@ export function normalizeMolecularHash(mappedHashArray: number[]): number[] {
   
   while (total !== 0) {
     for (let index = 0; index < normalized.length; index++) {
-      const condition = totalCondition 
-        ? normalized[index] < 8 
-        : normalized[index] > -8
-      
+      const value = normalized[index]!
+      const condition = totalCondition
+        ? value < 8
+        : value > -8
+
       if (condition) {
         if (totalCondition) {
-          normalized[index]++
+          normalized[index] = value + 1
           total++
         } else {
-          normalized[index]--
+          normalized[index] = value - 1
           total--
         }
-        
+
         if (total === 0) break
       }
     }
@@ -634,8 +637,8 @@ export function generateOTSSignature(privateKey: string, molecularHash: string):
     // Step 3: Generate signature fragments
     let signatureFragments = ''
     for (let index = 0; index < keyChunks.length; index++) {
-      let workingChunk = keyChunks[index]
-      
+      let workingChunk = keyChunks[index]!
+
       // Hash (8 - normalized[index]) times for signature generation
       const iterations = 8 - (normalized[index] || 0)
       for (let j = 0; j < iterations; j++) {
@@ -689,8 +692,8 @@ export function verifyOTSSignature(
     // Step 4: Process each chunk for verification
     let keyFragments = ''
     for (let index = 0; index < otsChunks.length; index++) {
-      let workingChunk = otsChunks[index]
-      
+      let workingChunk = otsChunks[index]!
+
       // Hash (8 + normalized[index]) times for verification
       const iterations = 8 + (normalized[index] || 0)
       for (let j = 0; j < iterations; j++) {

package/src/libraries/strings.ts

@@ -88,9 +88,9 @@ export function randomString(
   if (typeof crypto !== 'undefined' && crypto.getRandomValues) {
     const randomValues = new Uint8Array(length)
     crypto.getRandomValues(randomValues)
-    
+
     for (let i = 0; i < length; i++) {
-      result += alphabet.charAt(randomValues[i] % alphabet.length)
+      result += alphabet.charAt(randomValues[i]! % alphabet.length)
     }
   } else {
     // Fallback to Math.random (less secure but compatible)
@@ -310,7 +310,7 @@ export function toCamelCase(str: string): string {
   
   return str
     .toLowerCase()
-    .replace(/[^a-zA-Z0-9]+(.)/g, (match, chr) => chr.toUpperCase())
+    .replace(/[^a-zA-Z0-9]+(.)/g, (_match, chr) => chr.toUpperCase())
 }
 
 /**

package/src/mutation/MutationProposeMolecule.ts

@@ -48,6 +48,7 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Mutation from './Mutation'
 import ResponseProposeMolecule from '../response/ResponseProposeMolecule'
+import { gql } from '@urql/core'
 import type GraphQLClient from '../libraries/GraphQLClient'
 import type KnishIOClient from '../KnishIOClient'
 import type Molecule from '../core/Molecule'
@@ -68,7 +69,7 @@ export default abstract class MutationProposeMolecule extends Mutation {
 
     this.$__molecule = molecule
     this.$__remainderWallet = null
-    this.$__query = `
+    this.$__query = gql`
       mutation($molecule: MoleculeInput!) {
         ProposeMolecule(molecule: $molecule) {
           molecularHash,

package/src/query/Query.ts

@@ -49,6 +49,7 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 import { CodeException } from '@/exception'
 import type Response from '@/response/Response'
 import type { GraphQLClient } from '@/types'
+import type { TypedDocumentNode } from '@urql/core'
 
 /**
  * Base Query class for constructing GraphQL queries
@@ -57,7 +58,7 @@ export default class Query {
   protected client: GraphQLClient
   protected knishIOClient: any // Will be KnishIOClient type
   protected $__variables: Record<string, any> | null = null
-  protected $__query: string | null = null
+  protected $__query: string | TypedDocumentNode<any, any> | null = null
   protected $__response: Response | null = null
   protected $__request: any = null
 

package/src/query/QueryAtom.ts

@@ -48,7 +48,8 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Query from './Query'
 import ResponseAtom from '../response/ResponseAtom'
-import type { UrqlClientWrapper } from '../client/GraphQLClient'
+import { gql } from '@urql/core'
+import type { GraphQLClient } from '../types/graphql'
 import type KnishIOClient from '../KnishIOClient'
 
 /**
@@ -60,10 +61,10 @@ export default class QueryAtom extends Query {
    * Create new QueryAtom instance
    * Matches JavaScript SDK constructor signature exactly
    */
-  constructor(graphQLClient: UrqlClientWrapper, knishIOClient: KnishIOClient) {
+  constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = `query(
+    this.$__query = gql`query(
       $molecularHashes: [String!],
       $bundleHashes: [String!],
       $positions:[String!],

package/src/query/QueryBalance.ts

@@ -48,6 +48,7 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Query from './Query'
 import ResponseBalance from '../response/ResponseBalance'
+import { gql } from '@urql/core'
 import type GraphQLClient from '../libraries/GraphQLClient'
 import type KnishIOClient from '../KnishIOClient'
 
@@ -62,7 +63,7 @@ export default class QueryBalance extends Query {
   constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = `
+    this.$__query = gql`
       query($address: String, $bundleHash: String, $type: String, $token: String, $position: String) {
         Balance(address: $address, bundleHash: $bundleHash, type: $type, token: $token, position: $position) {
           address,

package/src/query/QueryBatch.ts

@@ -48,7 +48,8 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Query from './Query'
 import Response from '../response/Response'
-import type { UrqlClientWrapper } from '../client/GraphQLClient'
+import { gql } from '@urql/core'
+import type { GraphQLClient } from '../types/graphql'
 import type KnishIOClient from '../KnishIOClient'
 
 /**
@@ -60,10 +61,10 @@ export default class QueryBatch extends Query {
    * Create new QueryBatch instance
    * Matches JavaScript SDK constructor signature exactly
    */
-  constructor(graphQLClient: UrqlClientWrapper, knishIOClient: KnishIOClient) {
+  constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = `query( $batchId: String ) {
+    this.$__query = gql`query( $batchId: String ) {
       Batch( batchId: $batchId ) {
         ${QueryBatch.getFields()},
         children {

package/src/query/QueryContinuId.ts

@@ -48,7 +48,8 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Query from './Query'
 import ResponseContinuId from '../response/ResponseContinuId'
-import type { UrqlClientWrapper } from '../client/GraphQLClient'
+import { gql } from '@urql/core'
+import type { GraphQLClient } from '../types/graphql'
 import type KnishIOClient from '../KnishIOClient'
 
 /**
@@ -60,10 +61,10 @@ export default class QueryContinuId extends Query {
    * Create new QueryContinuId instance
    * Matches JavaScript SDK constructor signature exactly
    */
-  constructor(graphQLClient: UrqlClientWrapper, knishIOClient: KnishIOClient) {
+  constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = `query ($bundle: String!) {
+    this.$__query = gql`query ($bundle: String!) {
       ContinuId(bundle: $bundle) {
         address,
         bundleHash,

package/src/query/QueryMetaType.ts

@@ -48,7 +48,8 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Query from './Query'
 import ResponseMetaType from '../response/ResponseMetaType'
-import type { UrqlClientWrapper } from '../client/GraphQLClient'
+import { gql } from '@urql/core'
+import type { GraphQLClient } from '../types/graphql'
 import type KnishIOClient from '../KnishIOClient'
 
 /**
@@ -60,10 +61,10 @@ export default class QueryMetaType extends Query {
    * Create new QueryMetaType instance
    * Matches JavaScript SDK constructor signature exactly
    */
-  constructor(graphQLClient: UrqlClientWrapper, knishIOClient: KnishIOClient) {
+  constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = `query( $metaType: String, $metaTypes: [ String! ], $metaId: String, $metaIds: [ String! ], $key: String, $keys: [ String! ], $value: String, $values: [ String! ], $count: String, $latest: Boolean, $filter: [ MetaFilter! ], $queryArgs: QueryArgs, $countBy: String, $cellSlug: String ) {
+    this.$__query = gql`query( $metaType: String, $metaTypes: [ String! ], $metaId: String, $metaIds: [ String! ], $key: String, $keys: [ String! ], $value: String, $values: [ String! ], $count: String, $latest: Boolean, $filter: [ MetaFilter! ], $queryArgs: QueryArgs, $countBy: String, $cellSlug: String ) {
       MetaType( metaType: $metaType, metaTypes: $metaTypes, metaId: $metaId, metaIds: $metaIds, key: $key, keys: $keys, value: $value, values: $values, count: $count, filter: $filter, queryArgs: $queryArgs, countBy: $countBy, cellSlug: $cellSlug ) {
         metaType,
         instanceCount {

package/src/query/QueryMetaTypeViaAtom.ts

@@ -48,7 +48,8 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Query from './Query'
 import ResponseMetaTypeViaAtom from '../response/ResponseMetaTypeViaAtom'
-import type { UrqlClientWrapper } from '../client/GraphQLClient'
+import { gql } from '@urql/core'
+import type { GraphQLClient } from '../types/graphql'
 import type KnishIOClient from '../KnishIOClient'
 
 /**
@@ -60,10 +61,10 @@ export default class QueryMetaTypeViaAtom extends Query {
    * Create new QueryMetaTypeViaAtom instance
    * Matches JavaScript SDK constructor signature exactly
    */
-  constructor(graphQLClient: UrqlClientWrapper, knishIOClient: KnishIOClient) {
+  constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = `query ($metaTypes: [String!], $metaIds: [String!], $values: [String!], $keys: [String!], $latest: Boolean, $filter: [MetaFilter!], $queryArgs: QueryArgs, $countBy: String, $atomValues: [String!], $cellSlugs: [String!] ) {
+    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

package/src/query/QueryWalletBundle.ts

@@ -48,6 +48,7 @@ License: https://github.com/WishKnish/KnishIO-Client-TS/blob/master/LICENSE
 
 import Query from './Query'
 import ResponseWalletBundle from '../response/ResponseWalletBundle'
+import { gql } from '@urql/core'
 import type GraphQLClient from '../libraries/GraphQLClient'
 import type KnishIOClient from '../KnishIOClient'
 
@@ -62,7 +63,7 @@ export default class QueryWalletBundle extends Query {
   constructor(graphQLClient: GraphQLClient, knishIOClient: KnishIOClient) {
     super(graphQLClient, knishIOClient)
 
-    this.$__query = `
+    this.$__query = gql`
       query($bundleHashes: [String!]) {
         WalletBundle(bundleHashes: $bundleHashes) {
           bundleHash,