@mimicprotocol/lib-ts 0.0.1-rc.9 → 0.1.0

package/src/environment.ts

@@ -1,126 +1,205 @@
-import { join, ListType, serialize, serializeArray } from './helpers'
-import { Token, TokenAmount, USD } from './tokens'
-import { Address, BigInt, ChainId } from './types'
-import { Swap, Transfer, Call } from './intents'
-import { Call as CallQuery } from './queries'
 import { JSON } from 'json-as/assembly'
+
 import { Context, SerializableContext } from './context'
+import { evm } from './evm'
+import { Consensus, ListType, MIMIC_HELPER_ADDRESS } from './helpers'
+import { Intent } from './intents'
+import {
+  EvmCallQuery,
+  EvmCallQueryResponse,
+  RelevantTokensQuery,
+  RelevantTokensQueryResponse,
+  SubgraphQuery,
+  SubgraphQueryResponse,
+  SubgraphQueryResult,
+  SvmAccountsInfoQuery,
+  SvmAccountsInfoQueryResponse,
+  SvmAccountsInfoQueryResult,
+  TokenBalanceQuery,
+  TokenPriceQuery,
+  TokenPriceQueryResponse,
+} from './queries'
+import { BlockchainToken, Token, TokenAmount, USD } from './tokens'
+import { Address, BigInt, Bytes, ChainId, EvmDecodeParam, EvmEncodeParam, Result } from './types'
 
 export namespace environment {
-  @external('environment', '_call')
-  declare function _call(params: string): void
+  @external('environment', '_sendIntent')
+  declare function _sendIntent(params: string): void
 
-  @external('environment', '_swap')
-  declare function _swap(params: string): void
+  @external('environment', '_tokenPriceQuery')
+  declare function _tokenPriceQuery(params: string): string
 
-  @external('environment', '_transfer')
-  declare function _transfer(params: string): void
+  @external('environment', '_relevantTokensQuery')
+  declare function _relevantTokensQuery(params: string): string
 
-  @external('environment', '_getPrice')
-  declare function _getPrice(params: string): string
+  @external('environment', '_evmCallQuery')
+  declare function _evmCallQuery(params: string): string
 
-  @external('environment', '_getRelevantTokens')
-  declare function _getRelevantTokens(params: string): string
+  @external('environment', '_subgraphQuery')
+  declare function _subgraphQuery(params: string): string
 
-  @external('environment', '_contractCall')
-  declare function _contractCall(params: string): string
+  @external('environment', '_svmAccountsInfoQuery')
+  declare function _svmAccountsInfoQuery(params: string): string
 
   @external('environment', '_getContext')
   declare function _getContext(): string
 
   /**
-   * Generates a Call intent containing contract calls on the blockchain.
-   * @param call - The Call intent to generate
+   * Sends an intent containing one or more operations to the execution environment.
+   * @param intent - The intent to send
    */
-  export function call(call: Call): void {
-    _call(JSON.stringify(call))
+  export function sendIntent(intent: Intent): void {
+    _sendIntent(JSON.stringify(intent))
   }
 
   /**
-   * Generates a Swap intent for token exchange operations.
-   * @param swap - The Swap intent to generate
+   * Returns an aggregated price (by consensus function) for a token in USD at a specific timestamp.
+   * By default, returns the median USD price across multiple sources.
+   *
+   * @param token - The token to get the USD price for.
+   * @param timestamp - Optional. The timestamp for price lookup (defaults to current time if not provided).
+   * @param consensusFn - Optional. A function for aggregating the price values (default is median).
+   * @returns A `Result` containing either the consensus USD price or an error string.
    */
-  export function swap(swap: Swap): void {
-    _swap(JSON.stringify(swap))
-  }
+  export function tokenPriceQuery(
+    token: Token,
+    timestamp: Date | null = null,
+    consensusFn: (values: USD[]) => USD = Consensus.medianUSD
+  ): Result<USD, string> {
+    if (token.isUSD()) return Result.ok<USD, string>(USD.fromI32(1))
+    if (!(token instanceof BlockchainToken)) {
+      return Result.err<USD, string>('Price query not supported for token ' + token.toString())
+    }
 
-  /**
-   * Generates a Transfer intent for sending tokens to recipients.
-   * @param transfer - The Transfer intent to generate
-   */
-  export function transfer(transfer: Transfer): void {
-    _transfer(JSON.stringify(transfer))
-  }
+    const responseStr = _tokenPriceQuery(
+      JSON.stringify(TokenPriceQuery.fromToken(changetype<BlockchainToken>(token), timestamp))
+    )
+    const pricesResult = TokenPriceQueryResponse.fromJson<TokenPriceQueryResponse>(responseStr).toResult()
 
-  /**
-   * Tells the price of 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 price in USD
-   */
-  export function getPrice(token: Token, timestamp: Date | null = null): USD {
-    const price = _getPrice(join([serialize(token.address), serialize(token.chainId), serialize(timestamp ? timestamp.getTime().toString() : '')]))
-    return USD.fromBigInt(BigInt.fromString(price))
+    if (pricesResult.isError) return Result.err<USD, string>(pricesResult.error)
+
+    const prices = pricesResult.unwrap()
+    if (prices.length === 0) return Result.err<USD, string>('Prices not found for token ' + token.toString())
+
+    return Result.ok<USD, string>(consensusFn(prices))
   }
 
   /**
-   * Tells the balances of an address for the specified tokens and chains.
+   * Returns the balances of an address for the specified tokens and chains.
    * @param address - The address to query balances for
    * @param chainIds - Array of chain ids to search
    * @param usdMinAmount - Minimum USD value threshold for tokens (optional, defaults to zero)
-   * @param tokensList - List of tokens to include/exclude (optional, defaults to empty array)
+   * @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 TokenAmount objects representing the relevant tokens
+   * @param consensusFn - Optional. A function for aggregating the token amounts
+   * @returns Result containing either an array of TokenAmount objects representing the relevant tokens or an error string
    */
-  export function getRelevantTokens(
+  export function relevantTokensQuery(
     address: Address,
     chainIds: ChainId[],
     usdMinAmount: USD = USD.zero(),
-    tokensList: Token[] = [],
-    listType: ListType = ListType.DenyList
-  ): TokenAmount[] {
-    const response = _getRelevantTokens(
-      // NOTE: The runner expects an optional timestamp that the user will not be able to input
-      // that's why serialize('') is used
-      // this is a workaround until a decision is made regarding the timestamp
-      join([serialize(address), serializeArray(chainIds), serialize(usdMinAmount.value), serializeArray(tokensList), serialize(listType), serialize('')])
+    tokensList: BlockchainToken[] = [],
+    listType: ListType = ListType.DenyList,
+    consensusFn: (amounts: TokenBalanceQuery[][]) => TokenAmount[] = Consensus.uniqueTokenAmounts
+  ): Result<TokenAmount[], string> {
+    const responseStr = _relevantTokensQuery(
+      JSON.stringify(RelevantTokensQuery.init(address, chainIds, usdMinAmount, tokensList, listType))
     )
-    const rows = response.split('\n')
-    const tokenAmounts: TokenAmount[] = []
+    const responseResult = RelevantTokensQueryResponse.fromJson<RelevantTokensQueryResponse>(responseStr).toResult()
 
-    for (let i = 0; i < rows.length; i++) {
-      if (rows[i].length === 0) continue
-      tokenAmounts.push(TokenAmount.parse(rows[i]))
-    }
+    if (responseResult.isError) return Result.err<TokenAmount[], string>(responseResult.error)
 
-    return tokenAmounts
+    return Result.ok<TokenAmount[], string>(consensusFn(responseResult.unwrap()))
   }
 
   /**
-   * Generates a contract call of a read function on the blockchain and returns the result.
+   * Executes a read-only contract call on the blockchain and returns the result.
    * @param to - The contract address to call
    * @param chainId - The blockchain network identifier
    * @param timestamp - The timestamp for the call context (optional)
    * @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,
-    timestamp: Date | null,
-    data: string
-  ): string {
-    return _contractCall(
-      JSON.stringify(new CallQuery(to, chainId, timestamp, data))
-    )
+    data: string,
+    timestamp: Date | null = null
+  ): Result<string, string> {
+    const responseStr = _evmCallQuery(JSON.stringify(EvmCallQuery.from(to, chainId, timestamp, data)))
+    return EvmCallQueryResponse.fromJson<EvmCallQueryResponse>(responseStr).toResult()
   }
 
   /**
-   * Tells the current execution context containing environment information.
-   * @returns The Context object containing: user, settler, timestamp, and config ID
+   * Executes a subgraph query and returns the result.
+   * @param chainId - The blockchain network identifier
+   * @param subgraphId - The ID of the subgraph to be called
+   * @param query - The string representing the subgraph query to be executed
+   * @param timestamp - The timestamp for the query context (optional)
+   * @returns The subgraph query response
+   */
+  export function subgraphQuery(
+    chainId: ChainId,
+    subgraphId: string,
+    query: string,
+    timestamp: Date | null = null
+  ): Result<SubgraphQueryResult, string> {
+    const responseStr = _subgraphQuery(JSON.stringify(SubgraphQuery.from(chainId, subgraphId, query, timestamp)))
+    return SubgraphQueryResponse.fromJson<SubgraphQueryResponse>(responseStr).toResult()
+  }
+
+  /**
+   * Returns on-chain account info for Solana accounts.
+   * @param publicKeys - Accounts to read from chain
+   * @param timestamp - The timestamp for the call context (optional)
+   * @returns Result containing either the account info result or an error string
+   */
+  export function svmAccountsInfoQuery(
+    publicKeys: Address[],
+    timestamp: Date | null = null
+  ): Result<SvmAccountsInfoQueryResult, string> {
+    const responseStr = _svmAccountsInfoQuery(JSON.stringify(SvmAccountsInfoQuery.from(publicKeys, timestamp)))
+    return SvmAccountsInfoQueryResponse.fromJson<SvmAccountsInfoQueryResponse>(responseStr).toResult()
+  }
+
+  /**
+   * Returns the current execution context containing environment information.
+   * @returns The Context object containing: user, settler, timestamp, consensusThreshold and triggerPayload
    */
   export function getContext(): Context {
     const context = JSON.parse<SerializableContext>(_getContext())
     return Context.fromSerializable(context)
   }
+
+  /**
+   * Returns the native token balance of target account.
+   * @param chainId - Chain id to check balance
+   * @param target - Address to get balance from
+   * @returns The native token balance in wei
+   */
+  export function getNativeTokenBalance(chainId: ChainId, target: Address): Result<BigInt, string> {
+    if (chainId === ChainId.SOLANA_MAINNET) return Result.err<BigInt, string>('Solana not supported')
+    const data = '0xeffd663c' + evm.encode([EvmEncodeParam.fromValue('address', target)])
+    const response = evmCallQuery(Address.fromHexString(MIMIC_HELPER_ADDRESS), chainId, data)
+    if (response.isError) return Result.err<BigInt, string>(response.error)
+    const decodedResponse = evm.decode(new EvmDecodeParam('uint256', response.unwrap()))
+    const decoded = BigInt.fromString(decodedResponse)
+    return Result.ok<BigInt, string>(decoded)
+  }
+
+    /**
+   * Returns the code of the target account.
+   * @param chainId - Chain id to check code
+   * @param target - Address to get code from
+   * @returns The code of the target account
+   */
+  export function getCode(chainId: ChainId, target: Address): Result<Bytes, string> {
+    if (chainId === ChainId.SOLANA_MAINNET) return Result.err<Bytes, string>('Solana not supported')
+    const data = '0x7e105ce2' + evm.encode([EvmEncodeParam.fromValue('address', target)])
+    const response = evmCallQuery(Address.fromHexString(MIMIC_HELPER_ADDRESS), chainId, data)
+    if (response.isError) return Result.err<Bytes, string>(response.error)
+    const decodedResponse = evm.decode(new EvmDecodeParam('bytes', response.unwrap()))
+    const decoded = Bytes.fromHexString(decodedResponse)
+    return Result.ok<Bytes, string>(decoded)
+  }
 }

package/src/evm.ts

@@ -1,5 +1,6 @@
+import { JSON } from 'json-as/assembly'
+
 import { EvmDecodeParam, EvmEncodeParam } from './types'
-import { join, serialize, serializeArray } from './helpers'
 
 export namespace evm {
   @external('evm', '_encode')
@@ -10,14 +11,14 @@ export namespace evm {
 
   @external('evm', '_keccak')
   declare function _keccak(params: string): string
-  
+
   /**
    * Encodes parameters for EVM smart contract function calls using ABI encoding.
    * @param callParameters - Array of parameters to encode for the contract call
    * @returns The ABI-encoded data as a hex string
    */
   export function encode(callParameters: EvmEncodeParam[]): string {
-    return _encode(join([serializeArray(callParameters)]))
+    return _encode(JSON.stringify(callParameters))
   }
 
   /**
@@ -26,7 +27,7 @@ export namespace evm {
    * @returns The decoded data as a formatted string
    */
   export function decode(encodedData: EvmDecodeParam): string {
-    return _decode(serialize(encodedData))
+    return _decode(JSON.stringify(encodedData))
   }
 
   /**

package/src/helpers/BorshDeserializer.ts

@@ -0,0 +1,133 @@
+import { Address, ByteArray, Bytes } from '../types'
+import { Option } from '../types/Option'
+
+import { bytesToString } from './strings'
+
+/**
+ * Unsafe class to deserialize bytes into Rust-like types
+ * Should be used with caution! This will only throw if there are insufficient bytes for the type
+ */
+export class BorshDeserializer {
+  private _bytes: Uint8Array
+  private _offset: u32 = 0
+
+  constructor(bytes: Uint8Array) {
+    this._bytes = bytes
+  }
+
+  static fromHex(hex: string): BorshDeserializer {
+    return new BorshDeserializer(Bytes.fromHexString(hex))
+  }
+
+  static fromBytes(bytes: Uint8Array): BorshDeserializer {
+    return new BorshDeserializer(bytes)
+  }
+
+  tryBool(): bool {
+    if (this._offset >= this.getBytesLength()) throw new Error('Insufficient bytes for bool')
+    const value = this._bytes.at(this._offset)
+    this._offset += 1
+    return value === 1
+  }
+
+  tryU8(): u8 {
+    if (this._offset >= this.getBytesLength()) throw new Error('Insufficient bytes for u8')
+    const value = this._bytes.at(this._offset)
+    this._offset += 1
+    return value
+  }
+
+  tryU16(): u16 {
+    if (this._offset + 1 >= this.getBytesLength()) throw new Error('Insufficient bytes for u16')
+    const subarray = changetype<ByteArray>(this._bytes.subarray(this._offset, this._offset + 2))
+    this._offset += 2
+    return subarray.toU16()
+  }
+
+  tryU32(): u32 {
+    if (this._offset + 3 >= this.getBytesLength()) throw new Error('Insufficient bytes for u32')
+    const subarray = changetype<ByteArray>(this._bytes.subarray(this._offset, this._offset + 4))
+    this._offset += 4
+    return subarray.toU32()
+  }
+
+  tryU64(): u64 {
+    if (this._offset + 7 >= this.getBytesLength()) throw new Error('Insufficient bytes for u64')
+    const subarray = changetype<ByteArray>(this._bytes.subarray(this._offset, this._offset + 8))
+    this._offset += 8
+    return subarray.toU64()
+  }
+
+  tryPubkey(): Address {
+    if (this._offset + 31 >= this.getBytesLength()) throw new Error('Insufficient bytes for pubkey')
+    const pubkey = Address.fromBytes(Bytes.fromUint8Array(this._bytes.subarray(this._offset, this._offset + 32)))
+    this._offset += 32
+    return pubkey
+  }
+
+  tryString(): string {
+    const length = this.tryU32()
+    if (this._offset + length - 1 >= this.getBytesLength())
+      throw new Error(`Insufficient bytes for string of size ${length}`)
+    const str = bytesToString(this._bytes.subarray(this._offset, this._offset + length), true)
+    this._offset += length
+    return str
+  }
+
+  tryOptionBool(): Option<bool> {
+    const tag = this.tryU32()
+    if (tag === 0) return Option.none<bool>()
+    return Option.some<bool>(this.tryBool())
+  }
+
+  tryOptionU8(): Option<u8> {
+    const tag = this.tryU32()
+    if (tag === 0) return Option.none<u8>()
+    return Option.some<u8>(this.tryU8())
+  }
+
+  tryOptionU16(): Option<u16> {
+    const tag = this.tryU32()
+    if (tag === 0) return Option.none<u16>()
+    return Option.some<u16>(this.tryU16())
+  }
+
+  tryOptionU32(): Option<u32> {
+    const tag = this.tryU32()
+    if (tag === 0) return Option.none<u32>()
+    return Option.some<u32>(this.tryU32())
+  }
+
+  tryOptionU64(): Option<u64> {
+    const tag = this.tryU32()
+    if (tag === 0) return Option.none<u64>()
+    return Option.some<u64>(this.tryU64())
+  }
+
+  tryOptionPubkey(): Option<Address> {
+    const tag = this.tryU32()
+    if (tag === 0) return Option.none<Address>(Address.fromBytes(new Bytes(32)))
+    return Option.some<Address>(this.tryPubkey())
+  }
+
+  private getBytesLength(): u32 {
+    return this._bytes.length as u32
+  }
+
+  getOffset(): u32 {
+    return this._offset
+  }
+
+  setOffset(offset: u32): void {
+    if (offset > this.getBytesLength()) throw new Error('Offset overruns buffer length')
+    this._offset = offset
+  }
+
+  isEmpty(): bool {
+    return this._offset >= this.getBytesLength()
+  }
+
+  getLength(): u32 {
+    return this._bytes.length
+  }
+}

package/src/helpers/consensus.ts

@@ -0,0 +1,35 @@
+import { TokenBalanceQuery } from '../queries/RelevantTokensQuery'
+import { TokenAmount, USD } from '../tokens'
+import { BigInt } from '../types'
+
+import { median } from './math'
+
+/**
+ * Computes the median value from an array of USD values.
+ * @param values - Array of USD values to compute the median from
+ * @returns The median USD value
+ * @throws Error if the array is empty
+ */
+export function medianUSD(values: USD[]): USD {
+  return USD.fromBigInt(median(values.map<BigInt>((value: USD) => value.value)))
+}
+
+/**
+ * Deduplicates token balances by token address.
+ * Converts TokenBalanceQuery[][] to TokenAmount[] keeping only the first occurrence of each token address.
+ * @param balances - Array of arrays of TokenBalanceQuery to deduplicate
+ * @returns Array of unique TokenAmount objects
+ */
+export function uniqueTokenAmounts(balances: TokenBalanceQuery[][]): TokenAmount[] {
+  const resultMap: Map<string, TokenAmount> = new Map()
+  for (let i = 0; i < balances.length; i++) {
+    for (let j = 0; j < balances[i].length; j++) {
+      const tokenAmount = balances[i][j].toTokenAmount()
+      const mapKey = tokenAmount.token.address.toString()
+
+      if (resultMap.has(mapKey)) continue
+      resultMap.set(mapKey, tokenAmount)
+    }
+  }
+  return resultMap.values()
+}

package/src/helpers/constants.ts

@@ -1,5 +1,9 @@
 export const NULL_ADDRESS = '0x0000000000000000000000000000000000000000'
-export const NATIVE_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+export const EVM_NATIVE_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+export const SVM_NATIVE_ADDRESS = 'Nativeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+export const USD_ADDRESS = '0x0000000000000000000000000000000000000348'
+
+export const MAX_UINT256_HEX = '0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'
 
 export const STANDARD_DECIMALS: u8 = 18
 
@@ -7,3 +11,5 @@ export enum ListType {
   AllowList = 0,
   DenyList = 1,
 }
+
+export const MIMIC_HELPER_ADDRESS = '0x5cf82cbed1110fc2f75b3413d53abac492931804'

package/src/helpers/index.ts

@@ -1,3 +1,8 @@
+import * as Consensus from './consensus'
+import * as Math from './math'
+
+export * from './BorshDeserializer'
 export * from './constants'
 export * from './serialize'
 export * from './strings'
+export { Consensus, Math }

package/src/helpers/math.ts

@@ -0,0 +1,20 @@
+import { BigInt } from '../types'
+
+/**
+ * Computes the median value from an array of BigInt values.
+ * @param values - Array of BigInt values to compute the median from
+ * @returns The median BigInt value
+ * @throws Error if the array is empty
+ */
+export function median(values: BigInt[]): BigInt {
+  if (values.length === 0) throw new Error('Cannot compute median of empty array')
+
+  const sorted = values.sort((a: BigInt, b: BigInt) => BigInt.compare(a, b))
+  const len = sorted.length
+
+  if (len % 2 === 1) return sorted[len / 2]
+
+  const left = sorted[len / 2 - 1]
+  const right = sorted[len / 2]
+  return left.plus(right).div(BigInt.fromI32(2))
+}

package/src/helpers/serialize.ts

@@ -1,4 +1,4 @@
-const SEPARATOR = ','
+import { Bytes } from '../types'
 
 export interface Stringable {
   toString(): string
@@ -8,133 +8,13 @@ export interface Serializable {
   serialize(): string
 }
 
+export interface Byteable {
+  toBytes(): Bytes
+}
+
 export function serialize<T extends Stringable>(elem: T): string {
   // eslint-disable-next-line
   // @ts-ignore
   if (elem instanceof Serializable) return elem.serialize()
   return elem.toString()
 }
-
-export function serializeArray<T extends Stringable>(array: T[]): string {
-  const serializedElems: (string | null)[] = []
-  for (let i = 0; i < array.length; i++) {
-    serializedElems.push(serialize(array[i]))
-  }
-  return 'Array(' + join(serializedElems) + ')'
-}
-
-export function join(lst: (string | null)[]): string {
-  return lst.join(SEPARATOR)
-}
-
-/**
- * Parses a CSV string into an array of tokens, handling nested structures,
- * null values, and stripping one layer of outer parentheses if they wrap the entire string.
- *
- * @param csvString - String containing comma-separated values, nested structures (e.g., "(1,2)"), and nulls
- * @returns Array of strings (trimmed) and nulls, preserving internal nesting
- * @throws {Error} If parentheses are unbalanced
- */
-export function parseCSV(csvString: string): (string | null)[] {
-  const tokens: (string | null)[] = []
-  const currentTokenChars: string[] = []
-  const len = csvString.length
-  let depth: i32 = 0
-  let isEmpty = true
-
-  let shouldStripOuter = false
-  if (len > 1 && csvString.charAt(0) == '(' && csvString.charAt(len - 1) == ')') {
-    let balance = 0
-    let firstParenMatchesLast = true
-    for (let k = 0; k < len; k++) {
-      if (csvString.charAt(k) == '(') {
-        balance++
-      } else if (csvString.charAt(k) == ')') {
-        balance--
-      }
-      if (balance == 0 && k < len - 1) {
-        firstParenMatchesLast = false
-        break
-      }
-    }
-    if (firstParenMatchesLast && balance == 0) {
-      shouldStripOuter = true
-    }
-  }
-
-  for (let i = 0; i < len; i++) {
-    const char = csvString.charAt(i)
-    const charCode = char.charCodeAt(0)
-
-    switch (charCode) {
-      case '('.charCodeAt(0):
-        if (shouldStripOuter && i == 0) {
-          depth++
-          break
-        }
-        depth++
-        currentTokenChars.push(char)
-        isEmpty = false
-        break
-
-      case ')'.charCodeAt(0):
-        if (shouldStripOuter && i == len - 1) {
-          depth--
-          break
-        }
-        depth--
-        if (depth < 0) throw new Error(`Unbalanced parentheses at position ${i}`)
-        currentTokenChars.push(char)
-        isEmpty = false
-        break
-
-      case SEPARATOR.charCodeAt(0):
-        const isTopLevelComma = (shouldStripOuter && depth == 1) || (!shouldStripOuter && depth == 0)
-        if (isTopLevelComma) {
-          if (isEmpty) {
-            tokens.push(null)
-          } else {
-            tokens.push(currentTokenChars.join('').trim())
-          }
-          currentTokenChars.length = 0
-          isEmpty = true
-        } else {
-          currentTokenChars.push(char)
-          isEmpty = false
-        }
-        break
-
-      default:
-        currentTokenChars.push(char)
-        isEmpty = false
-        break
-    }
-  }
-
-  if (depth != 0) throw new Error('Unbalanced parentheses at the end of the string')
-
-  if (len > 0) {
-    if (isEmpty) {
-      tokens.push(null)
-    } else {
-      tokens.push(currentTokenChars.join('').trim())
-    }
-  }
-
-  return tokens
-}
-
-/**
- * Parses a CSV string into an array of strings, throwing an error if any null values are present.
- *
- * @param csvString - String containing comma-separated values
- * @returns Array of strings
- * @throws {Error} If null values are present
- */
-
-export function parseCSVNotNullable(csvString: string): string[] {
-  const tokens = parseCSV(csvString)
-  if (tokens.some((token) => token === null)) throw new Error('Null value found in CSV string')
-
-  return changetype<string[]>(tokens)
-}