@mimicprotocol/lib-ts 0.0.1-rc.28 → 0.0.1-rc.30

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @mimicprotocol/lib-ts
 
+## 0.0.1-rc.30
+
+### Patch Changes
+
+- 213f37f: Fix class names overlapping
+
+## 0.0.1-rc.29
+
+### Patch Changes
+
+- 72bb607: Fix relevant tokens query price filter
+- 52b567d: Align oracle types naming convention
+- 73a9cde: Fix npx init
+- 0a6602a: Handle oracle query errors
+
 ## 0.0.1-rc.28
 
 ### Patch Changes

package/README.md

@@ -57,7 +57,7 @@ import { environment, ERC20Token } from '@mimicprotocol/lib-ts'
 
 const USDC = ERC20Token.fromString('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', 1)
 
-environment.getPrice(USDC, new Date(1744818017000))
+environment.tokenPriceQuery(USDC, new Date(1744818017000))
 ```
 
 For full task development guide and examples please visit [docs.mimic.fi](https://docs.mimic.fi/)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimicprotocol/lib-ts",
-  "version": "0.0.1-rc.28",
+  "version": "0.0.1-rc.30",
   "license": "GPL-3.0",
   "private": false,
   "type": "module",

package/src/environment.ts

@@ -4,20 +4,23 @@ import { Context, SerializableContext } from './context'
 import { ListType } from './helpers'
 import { Swap, Transfer, EvmCall, SvmCall } from './intents'
 import {
-  Call as CallQuery,
-  GetAccountsInfo,
-  GetAccountsInfoResponse,
-  GetPrice,
-  GetRelevantTokens,
-  GetRelevantTokensResponse,
-  RelevantTokenBalance,
-  SerializableGetAccountsInfoResponse,
+  EvmCallQuery,
+  RelevantTokensQuery,
+  RelevantTokensQueryResult,
+  TokenBalanceQuery,
+  RelevantTokensQueryResponse,
   SubgraphQuery,
+  SvmAccountsInfoQuery,
+  SvmAccountsInfoQueryResponse,
+  SvmAccountsInfoQueryResult,
+  SubgraphQueryResult,
+  TokenPriceQuery,
+  EvmCallQueryResponse,
   SubgraphQueryResponse,
+  TokenPriceQueryResponse, 
 } from './queries'
 import { BlockchainToken, Token, TokenAmount, USD } from './tokens'
-import { Address, BigInt, ChainId } from './types'
-import { log } from './log'
+import { Address, BigInt, ChainId, Result } from './types'
 
 export namespace environment {
   @external('environment', '_evmCall')
@@ -32,20 +35,20 @@ export namespace environment {
   @external('environment', '_transfer')
   declare function _transfer(params: string): void
 
-  @external('environment', '_getPrice')
-  declare function _getPrice(params: string): string
+  @external('environment', '_tokenPriceQuery')
+  declare function _tokenPriceQuery(params: string): string
 
-  @external('environment', '_getRelevantTokens')
-  declare function _getRelevantTokens(params: string): string
+  @external('environment', '_relevantTokensQuery')
+  declare function _relevantTokensQuery(params: string): string
 
-  @external('environment', '_contractCall')
-  declare function _contractCall(params: string): string
+  @external('environment', '_evmCallQuery')
+  declare function _evmCallQuery(params: string): string
 
   @external('environment', '_subgraphQuery')
   declare function _subgraphQuery(params: string): string
 
-  @external('environment', '_getAccountsInfo')
-  declare function _getAccountsInfo(params: string): string
+  @external('environment', '_svmAccountsInfoQuery')
+  declare function _svmAccountsInfoQuery(params: string): string
 
   @external('environment', '_getContext')
   declare function _getContext(): string
@@ -86,36 +89,49 @@ export namespace environment {
    * Tells the prices from different sources for a token in USD at a specific timestamp.
    * @param token - The token to get the price of
    * @param timestamp - The timestamp for price lookup (optional, defaults to current time)
-   * @returns The token prices in USD
+   * @returns Result containing either an array of USD prices or an error string
    */
-  export function getRawPrice(token: Token, timestamp: Date | null = null): USD[] {
-    if (token.isUSD()) return [USD.fromI32(1)]
-    else if (!(token instanceof BlockchainToken)) throw new Error('Price query not supported for token ' + token.toString())
-    const prices = _getPrice(JSON.stringify(GetPrice.fromToken(token as BlockchainToken, timestamp)))
-    return JSON.parse<string[]>(prices).map<USD>((price) => USD.fromBigInt(BigInt.fromString(price)))
+  export function rawTokenPriceQuery(token: Token, timestamp: Date | null = null): Result<USD[], string> {
+    if (token.isUSD()) return Result.ok<USD[], string>([USD.fromI32(1)])
+    else if (!(token instanceof BlockchainToken)) return Result.err<USD[], string>('Price query not supported for token ' + token.toString())
+    
+    const responseStr = _tokenPriceQuery(JSON.stringify(TokenPriceQuery.fromToken(changetype<BlockchainToken>(token), timestamp)))
+    const parsed = TokenPriceQueryResponse.fromJson<TokenPriceQueryResponse>(responseStr)
+    
+    if (parsed.success !== 'true') return Result.err<USD[], string>(parsed.error.length > 0 ? parsed.error : 'Unknown error getting price')
+    
+    const prices = parsed.data.map<USD>((price) => USD.fromBigInt(BigInt.fromString(price)))
+    return Result.ok<USD[], string>(prices)
   }
 
   /**
    * Tells the median price from different sources for a token in USD at a specific timestamp.
    * @param token - The token to get the price of
    * @param timestamp - The timestamp for price lookup (optional, defaults to current time)
-   * @returns The token median price in USD
+   * @returns Result containing either the median USD price or an error string
    */
-  export function getPrice(token: Token, timestamp: Date | null = null): USD {
-    const prices = getRawPrice(token, timestamp)
-    if (prices.length === 0) throw new Error('Prices not found for token ' + token.toString())
+  export function tokenPriceQuery(token: Token, timestamp: Date | null = null): Result<USD, string> {
+    const pricesResult = rawTokenPriceQuery(token, timestamp)
+    
+    if (pricesResult.isError) return Result.err<USD, string>(pricesResult.error)
+    
+    const prices = pricesResult.value
+    if (prices.length === 0) return Result.err<USD, string>('Prices not found for token ' + token.toString())
 
     const sortedPrices = prices.sort((a: USD, b: USD) => a.compare(b))
 
     const length = sortedPrices.length
+    let median: USD
     if (length % 2 === 1) {
-      return sortedPrices[length / 2]
+      median = sortedPrices[length / 2]
     } else {
       const left = sortedPrices[length / 2 - 1]
       const right = sortedPrices[length / 2]
       const sum = left.plus(right)
-      return sum.div(BigInt.fromI32(2))
+      median = sum.div(BigInt.fromI32(2))
     }
+    
+    return Result.ok<USD, string>(median)
   }
 
   /**
@@ -125,12 +141,16 @@ export namespace environment {
    * @param usdMinAmount - Minimum USD value threshold for tokens (optional, defaults to zero)
    * @param tokensList - List of blockchain tokens to include/exclude (optional, defaults to empty array)
    * @param listType - Whether to include (AllowList) or exclude (DenyList) the tokens in `tokensList` (optional, defaults to DenyList)
-   * @returns Array of RelevantTokenBalance objects representing the relevant tokens
+   * @returns Result containing either an array of RelevantTokenBalance arrays or an error string
    */
-  export function getRawRelevantTokens(address: Address, chainIds: ChainId[], usdMinAmount: USD, tokensList: BlockchainToken[], listType: ListType): RelevantTokenBalance[][] {
-    const responseStr = _getRelevantTokens(JSON.stringify(GetRelevantTokens.init(address, chainIds, usdMinAmount, tokensList, listType)))
-    const responses = JSON.parse<GetRelevantTokensResponse[]>(responseStr)
-    return responses.map((response: GetRelevantTokensResponse) => response.balances)
+  export function rawRelevantTokensQuery(address: Address, chainIds: ChainId[], usdMinAmount: USD, tokensList: BlockchainToken[], listType: ListType): Result<TokenBalanceQuery[][], string> {
+    const responseStr = _relevantTokensQuery(JSON.stringify(RelevantTokensQuery.init(address, chainIds, usdMinAmount, tokensList, listType)))
+    const parsed = RelevantTokensQueryResponse.fromJson<RelevantTokensQueryResponse>(responseStr)
+    
+    if (parsed.success !== 'true') return Result.err<TokenBalanceQuery[][], string>(parsed.error.length > 0 ? parsed.error : 'Unknown error getting relevant tokens')
+    
+    const responses = parsed.data
+    return Result.ok<TokenBalanceQuery[][], string>(responses.map((response: RelevantTokensQueryResult) => response.balances))
   }
 
   /**
@@ -142,14 +162,18 @@ export namespace environment {
    * @param listType - Whether to include (AllowList) or exclude (DenyList) the tokens in `tokensList` (optional, defaults to DenyList)
    * @returns Array of TokenAmount objects representing the relevant tokens
    */
-  export function getRelevantTokens(
+  export function relevantTokensQuery(
     address: Address,
     chainIds: ChainId[],
     usdMinAmount: USD = USD.zero(),
     tokensList: BlockchainToken[] = [],
     listType: ListType = ListType.DenyList
-  ): TokenAmount[] {
-    const response = getRawRelevantTokens(address, chainIds, usdMinAmount, tokensList, listType)
+  ): Result<TokenAmount[], string> {
+    const responseResult = rawRelevantTokensQuery(address, chainIds, usdMinAmount, tokensList, listType)
+    
+    if (responseResult.isError) return Result.err<TokenAmount[], string>(responseResult.error)
+    
+    const response = responseResult.value
     const resultMap: Map<string, TokenAmount> = new Map()
     for (let i = 0; i < response.length; i++) {
       for (let j = 0; j < response[i].length; j++) {
@@ -160,7 +184,8 @@ export namespace environment {
         resultMap.set(mapKey, tokenAmount)
       }
     }
-    return resultMap.values()
+    
+    return Result.ok<TokenAmount[], string>(resultMap.values())
   }
 
   /**
@@ -171,15 +196,16 @@ export namespace environment {
    * @param data - The encoded function call data
    * @returns The raw response from the contract call
    */
-  export function contractCall(
+  export function evmCallQuery(
     to: Address,
     chainId: ChainId,
     data: string,
     timestamp: Date | null = null,
-  ): string {
-    return _contractCall(
-      JSON.stringify(CallQuery.from(to, chainId, timestamp, data))
-    )
+  ): Result<string, string> {
+    const responseStr = _evmCallQuery(JSON.stringify(EvmCallQuery.from(to, chainId, timestamp, data)))
+    const parsed = EvmCallQueryResponse.fromJson<EvmCallQueryResponse>(responseStr)
+    if (parsed.success !== 'true') return Result.err<string, string>(parsed.error.length > 0 ? parsed.error : 'Unknown error getting evm call')
+    return Result.ok<string, string>(parsed.data)
   }
 
   /**
@@ -195,31 +221,30 @@ export namespace environment {
     subgraphId: string,
     query: string,
     timestamp: Date | null = null,
-  ): SubgraphQueryResponse {
+  ): Result<SubgraphQueryResult, string> {
     const responseStr = _subgraphQuery(JSON.stringify(SubgraphQuery.from(chainId, subgraphId, query, timestamp)))
-    return JSON.parse<SubgraphQueryResponse>(responseStr)
+    const parsed = SubgraphQueryResponse.fromJson<SubgraphQueryResponse>(responseStr)
+    if (parsed.success !== 'true') return Result.err<SubgraphQueryResult, string>(parsed.error.length > 0 ? parsed.error : 'Unknown error getting subgraph query')
+    return Result.ok<SubgraphQueryResult, string>(parsed.data)
   }
    
   /**
    * SVM - Gets on-chain account info
    * @param publicKeys - Accounts to read from chain
    * @param timestamp - The timestamp for the call context (optional)
-   * @returns The raw response from the underlying getMultipleAccountsInfo call
+   * @returns Result containing either the account info result or an error string
    */
-
-  export function getAccountsInfo(
+  export function svmAccountsInfoQuery(
     publicKeys: Address[],
     timestamp: Date | null = null,
-  ): GetAccountsInfoResponse {
-    // There is a bug with json-as, so we have to do this with JSON booleans
-    const responseStr = _getAccountsInfo(
-      JSON.stringify(GetAccountsInfo.from(publicKeys, timestamp))
-    )
-      .replaceAll("true",`"true"`)
-      .replaceAll("false",`"false"`)
-
-    const response = JSON.parse<SerializableGetAccountsInfoResponse>(responseStr)
-    return GetAccountsInfoResponse.fromSerializable(response)
+  ): Result<SvmAccountsInfoQueryResult, string> {
+    const responseStr = _svmAccountsInfoQuery(JSON.stringify(SvmAccountsInfoQuery.from(publicKeys, timestamp)))
+    const parsed = SvmAccountsInfoQueryResponse.fromJson<SvmAccountsInfoQueryResponse>(responseStr)
+    
+    if (parsed.success !== 'true') return Result.err<SvmAccountsInfoQueryResult, string>(parsed.error.length > 0 ? parsed.error : 'Unknown error getting SVM accounts info')
+    
+    const result = SvmAccountsInfoQueryResult.fromSerializable(parsed.data)
+    return Result.ok<SvmAccountsInfoQueryResult, string>(result)
   }
 
   /**

package/src/helpers/strings.ts

@@ -26,6 +26,45 @@ export function stringToBool(str: string): bool {
   return str === 'true'
 }
 
+/**
+ * Workaround for json-as boolean bug:
+ * Converts JSON boolean values (true/false) into their string equivalents ("true"/"false")
+ * without touching occurrences inside JSON strings or keys.
+ *
+ * This function assumes compact JSON (no newlines between the boolean and the delimiter).
+ */
+export function replaceJsonBooleans(json: string): string {
+  return (
+    json
+      // true after ':' (object property values)
+      .replaceAll(':true', ':"true"')
+      .replaceAll(':true,', ':"true",')
+      .replaceAll(':true}', ':"true"}')
+      .replaceAll(':true]', ':"true"]')
+      .replaceAll(': true,', ': "true",')
+      .replaceAll(': true}', ': "true"}')
+      .replaceAll(': true]', ': "true"]')
+      // true in arrays
+      .replaceAll('[true,', '["true",')
+      .replaceAll('[true]', '["true"]')
+      .replaceAll(',true,', ',"true",')
+      .replaceAll(',true]', ',"true"]')
+      // false after ':' (object property values)
+      .replaceAll(':false', ':"false"')
+      .replaceAll(':false,', ':"false",')
+      .replaceAll(':false}', ':"false"}')
+      .replaceAll(':false]', ':"false"]')
+      .replaceAll(': false,', ': "false",')
+      .replaceAll(': false}', ': "false"}')
+      .replaceAll(': false]', ': "false"]')
+      // false in arrays
+      .replaceAll('[false,', '["false",')
+      .replaceAll('[false]', '["false"]')
+      .replaceAll(',false,', ',"false",')
+      .replaceAll(',false]', ',"false"]')
+  )
+}
+
 export function areAllZeros(str: string): boolean {
   for (let i = 0; i < str.length; i++) if (str.charCodeAt(i) !== 48) return false
   return true

package/src/queries/EvmCallQuery.ts

@@ -0,0 +1,39 @@
+import { Address, ChainId } from '../types'
+
+import { QueryResponseBase } from './QueryResponse'
+
+@json
+class EvmCallQueryBase {
+  constructor(
+    public readonly to: string,
+    public readonly chainId: ChainId,
+    public readonly data: string
+  ) {}
+}
+
+@json
+export class EvmCallQuery extends EvmCallQueryBase {
+  public readonly timestamp: i64
+
+  constructor(to: string, chainId: ChainId, timestamp: i64, data: string) {
+    super(to, chainId, data)
+    this.timestamp = timestamp
+  }
+
+  static from(to: Address, chainId: ChainId, timestamp: Date | null, data: string): EvmCallQueryBase {
+    const address = to.toString()
+    return timestamp
+      ? new EvmCallQuery(address, chainId, changetype<Date>(timestamp).getTime(), data)
+      : new EvmCallQueryBase(address, chainId, data)
+  }
+}
+
+@json
+export class EvmCallQueryResponse extends QueryResponseBase {
+  public data: string
+
+  constructor(success: string, data: string, error: string) {
+    super(success, error)
+    this.data = data
+  }
+}

package/src/queries/QueryResponse.ts

@@ -0,0 +1,15 @@
+import { JSON } from 'json-as'
+
+import { replaceJsonBooleans } from '../helpers'
+
+@json
+export class QueryResponseBase {
+  constructor(
+    public success: string, // boolean as string due to json-as bug
+    public error: string
+  ) {}
+
+  static fromJson<T extends QueryResponseBase>(json: string): T {
+    return JSON.parse<T>(replaceJsonBooleans(json))
+  }
+}

package/src/queries/{GetRelevantTokens.ts → RelevantTokensQuery.ts}

@@ -2,6 +2,8 @@ import { ListType } from '../helpers'
 import { BlockchainToken, TokenAmount, USD } from '../tokens'
 import { Address, BigInt, ChainId } from '../types'
 
+import { QueryResponseBase } from './QueryResponse'
+
 @json
 class TokenQuery {
   constructor(
@@ -15,7 +17,7 @@ class TokenQuery {
 }
 
 @json
-export class GetRelevantTokens {
+export class RelevantTokensQuery {
   constructor(
     public readonly owner: string,
     public readonly chainIds: ChainId[],
@@ -30,16 +32,16 @@ export class GetRelevantTokens {
     usdMinAmount: USD,
     tokens: BlockchainToken[],
     tokenFilter: ListType
-  ): GetRelevantTokens {
+  ): RelevantTokensQuery {
     const ownerStr = owner.toString()
-    const usdMinAmountStr = usdMinAmount.toString()
+    const usdMinAmountStr = usdMinAmount.value.toString()
     const tokensQueries = tokens.map<TokenQuery>((token) => TokenQuery.fromToken(token))
-    return new GetRelevantTokens(ownerStr, chainIds, usdMinAmountStr, tokensQueries, tokenFilter)
+    return new RelevantTokensQuery(ownerStr, chainIds, usdMinAmountStr, tokensQueries, tokenFilter)
   }
 }
 
 @json
-export class RelevantTokenBalance {
+export class TokenBalanceQuery {
   constructor(
     public token: TokenQuery,
     public balance: string
@@ -54,9 +56,19 @@ export class RelevantTokenBalance {
 }
 
 @json
-export class GetRelevantTokensResponse {
+export class RelevantTokensQueryResult {
   constructor(
     public timestamp: i64,
-    public balances: RelevantTokenBalance[]
+    public balances: TokenBalanceQuery[]
   ) {}
 }
+
+@json
+export class RelevantTokensQueryResponse extends QueryResponseBase {
+  public data: RelevantTokensQueryResult[]
+
+  constructor(success: string, data: RelevantTokensQueryResult[], error: string) {
+    super(success, error)
+    this.data = data
+  }
+}

package/src/queries/SubgraphQuery.ts

@@ -1,5 +1,7 @@
 import { ChainId } from '../types'
 
+import { QueryResponseBase } from './QueryResponse'
+
 @json
 class SubgraphQueryBase {
   constructor(
@@ -26,9 +28,19 @@ export class SubgraphQuery extends SubgraphQueryBase {
 }
 
 @json
-export class SubgraphQueryResponse {
+export class SubgraphQueryResult {
   constructor(
     public blockNumber: i64,
     public data: string
   ) {}
 }
+
+@json
+export class SubgraphQueryResponse extends QueryResponseBase {
+  public data: SubgraphQueryResult
+
+  constructor(success: string, data: SubgraphQueryResult, error: string) {
+    super(success, error)
+    this.data = data
+  }
+}

package/src/queries/SvmAccountsInfoQuery.ts

@@ -0,0 +1,57 @@
+import { Address, SerializableSvmAccountInfo, SvmAccountInfo } from '../types'
+
+import { QueryResponseBase } from './QueryResponse'
+
+@json
+class SvmAccountsInfoQueryBase {
+  constructor(public readonly publicKeys: string[]) {}
+}
+
+@json
+export class SvmAccountsInfoQuery extends SvmAccountsInfoQueryBase {
+  public readonly timestamp: i64
+
+  constructor(publicKeys: string[], timestamp: i64) {
+    super(publicKeys)
+    this.timestamp = timestamp
+  }
+
+  static from(publicKeys: Address[], timestamp: Date | null): SvmAccountsInfoQueryBase {
+    const strPublicKeys = publicKeys.map((pk: Address) => pk.toString())
+    return timestamp
+      ? new SvmAccountsInfoQuery(strPublicKeys, changetype<Date>(timestamp).getTime())
+      : new SvmAccountsInfoQueryBase(strPublicKeys)
+  }
+}
+
+@json
+export class SerializableSvmAccountsInfoQueryResult {
+  constructor(
+    public accountsInfo: SerializableSvmAccountInfo[],
+    public slot: string
+  ) {}
+}
+
+export class SvmAccountsInfoQueryResult {
+  constructor(
+    public accountsInfo: SvmAccountInfo[],
+    public slot: string
+  ) {}
+
+  static fromSerializable(serializable: SerializableSvmAccountsInfoQueryResult): SvmAccountsInfoQueryResult {
+    return new SvmAccountsInfoQueryResult(
+      serializable.accountsInfo.map((acc: SerializableSvmAccountInfo) => SvmAccountInfo.fromSerializable(acc)),
+      serializable.slot
+    )
+  }
+}
+
+@json
+export class SvmAccountsInfoQueryResponse extends QueryResponseBase {
+  public data: SerializableSvmAccountsInfoQueryResult
+
+  constructor(success: string, data: SerializableSvmAccountsInfoQueryResult, error: string) {
+    super(success, error)
+    this.data = data
+  }
+}

package/src/queries/TokenPriceQuery.ts

@@ -0,0 +1,40 @@
+import { BlockchainToken } from '../tokens'
+
+import { QueryResponseBase } from './QueryResponse'
+
+@json
+class TokenPriceQueryBase {
+  constructor(
+    public readonly address: string,
+    public readonly chainId: i32
+  ) {}
+}
+
+@json
+export class TokenPriceQuery extends TokenPriceQueryBase {
+  public readonly timestamp: i64
+
+  constructor(address: string, chainId: i32, timestamp: i64) {
+    super(address, chainId)
+    this.timestamp = timestamp
+  }
+
+  static fromToken(token: BlockchainToken, timestamp: Date | null): TokenPriceQueryBase {
+    const address = token.address.toString()
+    const chainId = token.chainId
+
+    return timestamp
+      ? new TokenPriceQuery(address, chainId, changetype<Date>(timestamp).getTime())
+      : new TokenPriceQueryBase(address, chainId)
+  }
+}
+
+@json
+export class TokenPriceQueryResponse extends QueryResponseBase {
+  public data: string[]
+
+  constructor(success: string, data: string[], error: string) {
+    super(success, error)
+    this.data = data
+  }
+}

package/src/queries/index.ts

@@ -1,5 +1,6 @@
-export * from './Call'
-export * from './GetAccountsInfo'
-export * from './GetPrice'
-export * from './GetRelevantTokens'
+export * from './EvmCallQuery'
+export * from './QueryResponse'
+export * from './RelevantTokensQuery'
 export * from './SubgraphQuery'
+export * from './SvmAccountsInfoQuery'
+export * from './TokenPriceQuery'

package/src/tokens/ERC20Token.ts

@@ -1,6 +1,7 @@
 import { environment } from '../environment'
 import { evm } from '../evm'
 import { EVM_NATIVE_ADDRESS } from '../helpers'
+import { log } from '../log'
 import { Address, ChainId, EvmDecodeParam } from '../types'
 
 import { BlockchainToken } from './BlockchainToken'
@@ -110,30 +111,24 @@ export class ERC20Token extends BlockchainToken {
   /**
    * Gets the token’s symbol (e.g., "ETH", "USDC").
    * If the symbol was not provided during construction, it will be lazily fetched
-   * via a `contractCall` to the token’s `symbol()` function (ERC-20 standard, selector `0x95d89b41`).
+   * via a `evmCallQuery` to the token’s `symbol()` function (ERC-20 standard, selector `0x95d89b41`).
    * The fetched symbol is cached in the instance for future accesses.
    * @returns A string containing the token symbol.
    */
   get symbol(): string {
-    if (this._symbol === ERC20Token.EMPTY_SYMBOL) {
-      const response = environment.contractCall(this.address, this.chainId, '0x95d89b41', this._timestamp)
-      this._symbol = evm.decode(new EvmDecodeParam('string', response))
-    }
+    if (this._symbol === ERC20Token.EMPTY_SYMBOL) this._getSymbol()
     return this._symbol
   }
 
   /**
    * Gets the token’s decimals (number of decimal places used).
    * If decimals were not provided during construction, they will be lazily fetched
-   * via a `contractCall` to the token’s `decimals()` function (ERC-20 standard, selector `0x313ce567`).
+   * via a `evmCallQuery` to the token’s `decimals()` function (ERC-20 standard, selector `0x313ce567`).
    * The fetched value is parsed to `u8` and cached for future accesses.
    * @returns A `u8` representing the number of decimals of the token.
    */
   get decimals(): u8 {
-    if (this._decimals == ERC20Token.EMPTY_DECIMALS) {
-      const result = environment.contractCall(this.address, this.chainId, '0x313ce567', this._timestamp)
-      this._decimals = u8.parse(evm.decode(new EvmDecodeParam('uint8', result)))
-    }
+    if (this._decimals == ERC20Token.EMPTY_DECIMALS) this._getDecimals()
     return this._decimals
   }
 
@@ -154,4 +149,38 @@ export class ERC20Token extends BlockchainToken {
   isNative(): boolean {
     return this.equals(ERC20Token.native(this.chainId))
   }
+
+  /**
+   * Internal method to fetch and cache the token symbol.
+   * Performs an EVM call query to the token's symbol() function.
+   * @private
+   */
+  private _getSymbol(): void {
+    const response = environment.evmCallQuery(this.address, this.chainId, '0x95d89b41', this._timestamp)
+    if (response.isError) {
+      log.warning(
+        `Failed to get symbol for token ${this.address.toString()} on chain ${this.chainId.toString()}: ${response.error}`
+      )
+      this._symbol = ERC20Token.EMPTY_SYMBOL
+      return
+    }
+    this._symbol = evm.decode(new EvmDecodeParam('string', response.value))
+  }
+
+  /**
+   * Internal method to fetch and cache the token decimals.
+   * Performs an EVM call query to the token's decimals() function.
+   * @private
+   */
+  private _getDecimals(): void {
+    const result = environment.evmCallQuery(this.address, this.chainId, '0x313ce567', this._timestamp)
+    if (result.isError) {
+      log.warning(
+        `Failed to get decimals for token ${this.address.toString()} on chain ${this.chainId.toString()}: ${result.error}`
+      )
+      this._decimals = ERC20Token.EMPTY_DECIMALS
+      return
+    }
+    this._decimals = u8.parse(evm.decode(new EvmDecodeParam('uint8', result.value)))
+  }
 }

package/src/tokens/SPLToken.ts

@@ -1,5 +1,6 @@
 import { environment } from '../environment'
 import { SVM_NATIVE_ADDRESS } from '../helpers'
+import { log } from '../log'
 import { svm } from '../svm'
 import { Address, ChainId, SvmMint, SvmPdaSeed, SvmTokenMetadataData } from '../types'
 
@@ -71,11 +72,7 @@ export class SPLToken extends BlockchainToken {
    * @returns A `u8` representing the number of decimals of the token.
    */
   get decimals(): u8 {
-    if (this._decimals == SPLToken.EMPTY_DECIMALS) {
-      const result = environment.getAccountsInfo([this.address])
-      const decimals = SvmMint.fromHex(result.accountsInfo[0].data).decimals
-      this._decimals = decimals
-    }
+    if (this._decimals == SPLToken.EMPTY_DECIMALS) this._getDecimals()
     return this._decimals
   }
 
@@ -87,18 +84,50 @@ export class SPLToken extends BlockchainToken {
    * @returns A string containing the token symbol.
    */
   get symbol(): string {
-    if (this._symbol == SPLToken.EMPTY_SYMBOL) {
-      const result = environment.getAccountsInfo([this.getMetadataAddress()])
-      const data = result.accountsInfo[0].data
-      // Return placeholder symbol from address if TokenMetadata standard is not used
-      this._symbol =
-        data === '0x'
-          ? `${this.address.toString().slice(0, 5)}...${this.address.toString().slice(-5)}`
-          : SvmTokenMetadataData.fromTokenMetadataHex(result.accountsInfo[0].data).symbol
-    }
+    if (this._symbol == SPLToken.EMPTY_SYMBOL) this._getSymbol()
     return this._symbol
   }
 
+  /**
+   * Internal method to fetch and cache the token decimals.
+   * Performs an SVM accounts info query to get the mint data.
+   * @private
+   */
+  private _getDecimals(): void {
+    const result = environment.svmAccountsInfoQuery([this.address])
+    if (result.isError) {
+      log.warning(
+        `Failed to get decimals for token ${this.address.toString()} on chain ${this.chainId.toString()}: ${result.error}`
+      )
+      this._decimals = SPLToken.EMPTY_DECIMALS
+      return
+    }
+    const decimals = SvmMint.fromHex(result.value.accountsInfo[0].data).decimals
+    this._decimals = decimals
+  }
+
+  /**
+   * Internal method to fetch and cache the token symbol.
+   * Performs an SVM accounts info query to get the token metadata.
+   * @private
+   */
+  private _getSymbol(): void {
+    const result = environment.svmAccountsInfoQuery([this.getMetadataAddress()])
+    if (result.isError) {
+      log.warning(
+        `Failed to get symbol for token ${this.address.toString()} on chain ${this.chainId.toString()}: ${result.error}`
+      )
+      this._symbol = SPLToken.EMPTY_SYMBOL
+      return
+    }
+    const data = result.value.accountsInfo[0].data
+    // Return placeholder symbol from address if TokenMetadata standard is not used
+    this._symbol =
+      data === '0x'
+        ? `${this.address.toString().slice(0, 5)}...${this.address.toString().slice(-5)}`
+        : SvmTokenMetadataData.fromTokenMetadataHex(result.value.accountsInfo[0].data).symbol
+  }
+
   /**
    * Derives Metaplex Metadata address for this given token
    */

package/src/tokens/TokenAmount.ts

@@ -1,5 +1,5 @@
 import { environment } from '../environment'
-import { BigInt, JSON } from '../types'
+import { BigInt, JSON, Result } from '../types'
 
 import { BlockchainToken } from './BlockchainToken'
 import { SerializableToken, Token } from './Token'
@@ -217,11 +217,14 @@ export class TokenAmount {
    * Converts this TokenAmount to its USD equivalent.
    * @returns A USD instance representing the current USD value
    */
-  toUsd(): USD {
-    if (this.isZero()) return USD.zero()
-    const tokenPrice = environment.getPrice(this.token)
+  toUsd(): Result<USD, string> {
+    if (this.isZero()) return Result.ok<USD, string>(USD.zero())
+    const tokenPriceResult = environment.tokenPriceQuery(this.token)
+    if (tokenPriceResult.isError) return Result.err<USD, string>(tokenPriceResult.error)
+
+    const tokenPrice = tokenPriceResult.value
     const amountUsd = this.amount.times(tokenPrice.value).downscale(this.decimals)
-    return USD.fromBigInt(amountUsd)
+    return Result.ok<USD, string>(USD.fromBigInt(amountUsd))
   }
 
   /**
@@ -229,9 +232,12 @@ export class TokenAmount {
    * @param other - The target token to convert to
    * @returns A TokenAmount of the target token with equivalent USD value
    */
-  toTokenAmount(other: Token): TokenAmount {
-    if (this.isZero()) return TokenAmount.fromI32(other, 0)
-    return this.toUsd().toTokenAmount(other)
+  toTokenAmount(other: Token): Result<TokenAmount, string> {
+    if (this.isZero()) return Result.ok<TokenAmount, string>(TokenAmount.fromI32(other, 0))
+    const usdResult = this.toUsd()
+    if (usdResult.isError) return Result.err<TokenAmount, string>(usdResult.error)
+
+    return usdResult.value.toTokenAmount(other)
   }
 
   /**

package/src/tokens/USD.ts

@@ -1,7 +1,7 @@
 import { environment } from '../environment'
 import { STANDARD_DECIMALS } from '../helpers'
 import { Token, TokenAmount } from '../tokens'
-import { BigInt } from '../types'
+import { BigInt, Result } from '../types'
 
 /**
  * Represents a USD amount with fixed decimal precision.
@@ -192,10 +192,13 @@ export class USD {
    * @param token - The target token to convert to
    * @returns A TokenAmount representing the equivalent value in the target token
    */
-  toTokenAmount(token: Token): TokenAmount {
-    if (this.isZero()) return TokenAmount.fromI32(token, 0)
-    const tokenPrice = environment.getPrice(token)
+  toTokenAmount(token: Token): Result<TokenAmount, string> {
+    if (this.isZero()) return Result.ok<TokenAmount, string>(TokenAmount.fromI32(token, 0))
+    const tokenPriceResult = environment.tokenPriceQuery(token)
+    if (tokenPriceResult.isError) return Result.err<TokenAmount, string>(tokenPriceResult.error)
+
+    const tokenPrice = tokenPriceResult.value
     const tokenAmount = this.value.upscale(token.decimals).div(tokenPrice.value)
-    return TokenAmount.fromBigInt(token, tokenAmount)
+    return Result.ok<TokenAmount, string>(TokenAmount.fromBigInt(token, tokenAmount))
   }
 }

package/src/types/Result.ts

@@ -0,0 +1,56 @@
+// eslint-disable-next-line no-secrets/no-secrets
+// This file is based on code from "The Graph Tooling" (https://github.com/graphprotocol/graph-tooling/tree/7faa3098b2e6c61f09fc81b8b2d333e66b0080d1).
+// Licensed under the MIT License.
+// Copyright (c) 2018 Graph Protocol, Inc. and contributors.
+// Modified by Mimic Protocol, 2025.
+
+/**
+ * The result of an operation, with a corresponding value and error type.
+ */
+export class Result<V, E> {
+  constructor(
+    private _value: Wrapped<V> | null,
+    private _error: Wrapped<E> | null
+  ) {}
+
+  static ok<V, E>(value: V): Result<V, E> {
+    return new Result<V, E>(new Wrapped<V>(value), null)
+  }
+
+  static err<V, E>(error: E): Result<V, E> {
+    return new Result<V, E>(null, new Wrapped<E>(error))
+  }
+
+  get isOk(): boolean {
+    return this._value !== null
+  }
+
+  get isError(): boolean {
+    return this._error !== null
+  }
+
+  get value(): V {
+    if (this.isError) throw new Error('Trying to get a value from an error result')
+    return changetype<Wrapped<V>>(this._value).inner
+  }
+
+  get error(): E {
+    if (this.isOk) throw new Error('Trying to get an error from a successful result')
+    return changetype<Wrapped<E>>(this._error).inner
+  }
+}
+
+// This is used to wrap a generic so that it can be unioned with `null`, working around limitations
+// with primitives.
+export class Wrapped<T> {
+  inner: T
+
+  constructor(inner: T) {
+    this.inner = inner
+  }
+}
+
+// This is used to represent a void return type
+export class Void {
+  constructor() {}
+}

package/src/types/index.ts

@@ -7,6 +7,7 @@ export * from './Bytes'
 export * from './ChainId'
 export * from './evm'
 export * from './Option'
+export * from './Result'
 export * from './svm'
 export * from './TriggerType'
 export { JSON }

package/src/queries/Call.ts

@@ -1,27 +0,0 @@
-import { Address, ChainId } from '../types'
-
-@json
-class CallBase {
-  constructor(
-    public readonly to: string,
-    public readonly chainId: ChainId,
-    public readonly data: string
-  ) {}
-}
-
-@json
-export class Call extends CallBase {
-  public readonly timestamp: i64
-
-  constructor(to: string, chainId: ChainId, timestamp: i64, data: string) {
-    super(to, chainId, data)
-    this.timestamp = timestamp
-  }
-
-  static from(to: Address, chainId: ChainId, timestamp: Date | null, data: string): CallBase {
-    const address = to.toString()
-    return timestamp
-      ? new Call(address, chainId, changetype<Date>(timestamp).getTime(), data)
-      : new CallBase(address, chainId, data)
-  }
-}

package/src/queries/GetAccountsInfo.ts

@@ -1,46 +0,0 @@
-import { Address, SerializableSvmAccountInfo, SvmAccountInfo } from '../types'
-
-@json
-class GetAccountsInfoBase {
-  constructor(public readonly publicKeys: string[]) {}
-}
-
-@json
-export class GetAccountsInfo extends GetAccountsInfoBase {
-  public readonly timestamp: i64
-
-  constructor(publicKeys: string[], timestamp: i64) {
-    super(publicKeys)
-    this.timestamp = timestamp
-  }
-
-  static from(publicKeys: Address[], timestamp: Date | null): GetAccountsInfoBase {
-    const strPublicKeys = publicKeys.map((pk: Address) => pk.toString())
-    return timestamp
-      ? new GetAccountsInfo(strPublicKeys, changetype<Date>(timestamp).getTime())
-      : new GetAccountsInfoBase(strPublicKeys)
-  }
-}
-
-// There is a bug with json-as, so this can't be parsed directly
-export class GetAccountsInfoResponse {
-  constructor(
-    public accountsInfo: SvmAccountInfo[],
-    public slot: string
-  ) {}
-
-  static fromSerializable(serializable: SerializableGetAccountsInfoResponse): GetAccountsInfoResponse {
-    return new GetAccountsInfoResponse(
-      serializable.accountsInfo.map((acc: SerializableSvmAccountInfo) => SvmAccountInfo.fromSerializable(acc)),
-      serializable.slot
-    )
-  }
-}
-
-@json
-export class SerializableGetAccountsInfoResponse {
-  constructor(
-    public accountsInfo: SerializableSvmAccountInfo[],
-    public slot: string
-  ) {}
-}

package/src/queries/GetPrice.ts

@@ -1,28 +0,0 @@
-import { BlockchainToken } from '../tokens'
-
-@json
-class GetPriceBase {
-  constructor(
-    public readonly address: string,
-    public readonly chainId: i32
-  ) {}
-}
-
-@json
-export class GetPrice extends GetPriceBase {
-  public readonly timestamp: i64
-
-  constructor(address: string, chainId: i32, timestamp: i64) {
-    super(address, chainId)
-    this.timestamp = timestamp
-  }
-
-  static fromToken(token: BlockchainToken, timestamp: Date | null): GetPriceBase {
-    const address = token.address.toString()
-    const chainId = token.chainId
-
-    return timestamp
-      ? new GetPrice(address, chainId, changetype<Date>(timestamp).getTime())
-      : new GetPriceBase(address, chainId)
-  }
-}