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

package/src/tokens/Token.ts

@@ -1,191 +1,91 @@
-import { environment } from '../environment'
-import { evm } from '../evm'
-import { join, NATIVE_ADDRESS, parseCSV, Serializable, serialize } from '../helpers'
-import { Address, ChainId, EvmDecodeParam } from '../types'
+import { Address, ChainId } from '../types'
 
 /**
  * Represents a token on a blockchain network including data like symbol, decimals, and address.
- * Supports both ERC-20 and native tokens.
+ * Supports both ERC-20, SPL, and denomination tokens.
  */
-export class Token implements Serializable {
-  public static readonly EMPTY_DECIMALS: u8 = u8.MAX_VALUE
-  public static readonly EMPTY_SYMBOL: string = ''
-  private static readonly SERIALIZED_PREFIX: string = 'Token'
-
-  private _symbol: string
-  private _address: Address
-  private _chainId: ChainId
-  private _decimals: u8
-  private _timestamp: Date | null = null
-
-  /**
-   * Creates a Token instance from an Address object.
-   * @param address - The contract address of the token
-   * @param chainId - The blockchain network identifier
-   * @param decimals - Number of decimal places (optional, will be queried if not provided)
-   * @param symbol - Token symbol (optional, will be queried if not provided)
-   * @param timestamp - Timestamp for historical queries (optional)
-   * @returns A new Token instance
-   */
-  static fromAddress(
-    address: Address,
-    chainId: ChainId,
-    decimals: u8 = Token.EMPTY_DECIMALS,
-    symbol: string = Token.EMPTY_SYMBOL,
-    timestamp: Date | null = null
-  ): Token {
-    return new Token(address, chainId, decimals, symbol, timestamp)
-  }
-
-  /**
-   * Creates a Token instance from a string address.
-   * @param address - The contract address as a hex string
-   * @param chainId - The blockchain network identifier
-   * @param decimals - Number of decimal places (optional, will be queried if not provided)
-   * @param symbol - Token symbol (optional, will be queried if not provided)
-   * @param timestamp - Timestamp for historical queries (optional)
-   * @returns A new Token instance
-   */
-  static fromString(
-    address: string,
-    chainId: ChainId,
-    decimals: u8 = Token.EMPTY_DECIMALS,
-    symbol: string = Token.EMPTY_SYMBOL,
-    timestamp: Date | null = null
-  ): Token {
-    return Token.fromAddress(Address.fromString(address), chainId, decimals, symbol, timestamp)
-  }
-
-  /**
-   * Creates a Token instance representing the native token of the specified chain.
-   * @param chainId - The blockchain network identifier
-   * @returns A new Token instance for the native token
-   */
-  static native(chainId: ChainId): Token {
-    switch (chainId) {
-      case ChainId.ETHEREUM:
-      case ChainId.OPTIMISM:
-        return Token.fromString(NATIVE_ADDRESS, chainId, 18, 'ETH')
-      case ChainId.POLYGON:
-        return Token.fromString(NATIVE_ADDRESS, chainId, 18, 'POL')
-      default:
-        throw new Error(`Unsupported chainId: ${chainId}`)
-    }
-  }
-
-  /**
-   * Parses a serialized Token string and creates a Token instance.
-   * @param serialized - The serialized token string in format: Token(address,chainId)
-   * @returns A new Token instance parsed from the serialized data
-   */
-  static parse(serialized: string): Token {
-    const isToken = serialized.startsWith(`${Token.SERIALIZED_PREFIX}(`) && serialized.endsWith(')')
-    if (!isToken) throw new Error('Invalid serialized token')
-
-    const elements = parseCSV(serialized.slice(Token.SERIALIZED_PREFIX.length + 1, -1))
-    const areNull = elements.some((element) => element === null)
-    if (areNull) throw new Error('Invalid serialized token')
-
-    const address = elements[0]!
-    const chainId = i32.parse(elements[1]!)
-
-    return Token.fromString(address, chainId)
-  }
+export abstract class Token {
+  protected _symbol: string
+  protected _address: Address
+  protected _decimals: u8
 
   /**
    * Creates a new Token instance.
-   * @param address - The contract address of the token
-   * @param chainId - The blockchain network identifier
-   * @param decimals - Number of decimal places (optional, will be queried if not provided)
-   * @param symbol - Token symbol (optional, will be queried if not provided)
-   * @param timestamp - Timestamp for historical queries (optional)
+   * @param address - The address of the token
+   * @param decimals - Number of decimal places
+   * @param symbol - Token symbol
    */
-  constructor(
-    address: Address,
-    chainId: ChainId,
-    decimals: u8 = Token.EMPTY_DECIMALS,
-    symbol: string = Token.EMPTY_SYMBOL,
-    timestamp: Date | null = null
-  ) {
+  constructor(address: Address, decimals: u8, symbol: string) {
     this._address = address
-    this._chainId = chainId
-    this._timestamp = timestamp
-    this._symbol = symbol
     this._decimals = decimals
-    // Ensure symbol and decimals are set for native tokens.
-    // Since queries return only the address and chainId, missing metadata must be filled
-    // to prevent the symbol and decimals getters from failing for native tokens.
-    if (
-      this._address.equals(Address.fromString(NATIVE_ADDRESS)) &&
-      (this._symbol === Token.EMPTY_SYMBOL || this._decimals === Token.EMPTY_DECIMALS)
-    ) {
-      const nativeToken = Token.native(this._chainId)
-      if (this._symbol === Token.EMPTY_SYMBOL) {
-        this._symbol = nativeToken.symbol
-      }
-      if (this._decimals === Token.EMPTY_DECIMALS) {
-        this._decimals = nativeToken.decimals
-      }
-    }
+    this._symbol = symbol
   }
 
+  /**
+   * Gets the contract address of the token.
+   * The address is returned as a cloned `Address` object to ensure immutability of the internal state.
+   * @returns A cloned `Address` object representing the token’s address.
+   */
   get address(): Address {
     return this._address.clone()
   }
 
-  get chainId(): ChainId {
-    return this._chainId
-  }
-
+  /**
+   * Gets the token’s symbol (e.g., "ETH", "USDC").
+   * @returns A string containing the token symbol.
+   */
   get symbol(): string {
-    if (this._symbol === Token.EMPTY_SYMBOL) {
-      const response = environment.contractCall(this.address, this.chainId, this._timestamp, '0x95d89b41')
-      this._symbol = evm.decode(new EvmDecodeParam('string', response))
-    }
     return this._symbol
   }
 
+  /**
+   * Gets the token’s decimals (number of decimal places used).
+   * @returns A `u8` representing the number of decimals of the token.
+   */
   get decimals(): u8 {
-    if (this._decimals == Token.EMPTY_DECIMALS) {
-      const result = environment.contractCall(this.address, this.chainId, this._timestamp, '0x313ce567')
-      this._decimals = u8.parse(evm.decode(new EvmDecodeParam('uint8', result)))
-    }
     return this._decimals
   }
 
-  set decimals(value: u8) {
-    this._decimals = value
-  }
-
-  set symbol(value: string) {
-    this._symbol = value
-  }
-
-  set timestamp(value: Date) {
-    this._timestamp = value
-  }
-
   /**
    * Checks if this token is equal to another token.
-   * Tokens are considered equal if they have the same address on the same chain.
+   * Tokens are considered equal if they have the same address.
    * @param other - The token to compare with
-   * @returns True if both tokens represent the same asset
+   * @returns True if both tokens have the same address
    */
   equals(other: Token): boolean {
-    const isSameChain = this.chainId === other.chainId
-    const isSameAddress = this.address.equals(other.address)
-    return isSameChain && isSameAddress
+    return this.address.equals(other.address)
   }
 
+  /**
+   * Checks if this token is the USD denomination.
+   * @returns True if the token is the USD denomination
+   */
+  abstract isUSD(): boolean
+
+  /**
+   * Checks if this token is the native token.
+   * @returns True if the token is the native token
+   */
+  abstract isNative(): boolean
+
+  /**
+   * Checks if this token belongs to the requested chain.
+   * @param chain - The chain ID asking for
+   * @returns True if the token belongs to the requested chain
+   */
+  abstract hasChain(chain: ChainId): boolean
+
   /**
    * Tells the string representation of this token.
-   * @returns The token symbol
+   * @returns The string representation of the token
    */
-  toString(): string {
-    return this.symbol
-  }
+  abstract toString(): string
+}
 
-  serialize(): string {
-    return `${Token.SERIALIZED_PREFIX}(${join([serialize(this.address), serialize(this.chainId)])})`
-  }
+@json
+export class SerializableToken {
+  constructor(
+    public address: string,
+    public chainId: i32
+  ) {}
 }

package/src/tokens/TokenAmount.ts

@@ -1,20 +1,28 @@
 import { environment } from '../environment'
-import { join, parseCSV, Serializable, serialize } from '../helpers'
-import { BigInt } from '../types'
+import { BigInt, JSON, Result } from '../types'
 
-import { Token } from './Token'
+import { BlockchainToken } from './BlockchainToken'
+import { SerializableToken, Token } from './Token'
 import { USD } from './USD'
 
+const BPS_SCALE = BigInt.fromI32(10_000)
+
 /**
  * Represents an amount of a specific token, combining the token metadata with a quantity.
  * Supports arithmetic operations, comparisons, and conversions between tokens and USD.
  */
-export class TokenAmount implements Serializable {
-  private static readonly SERIALIZED_PREFIX: string = 'TokenAmount'
-
+export class TokenAmount {
   private _token: Token
   private _amount: BigInt
 
+  /**
+   * Creates a TokenAmount instance representing zero.
+   * @returns A new TokenAmount instance with amount 0
+   */
+  static zero(token: Token): TokenAmount {
+    return this.fromBigInt(token, BigInt.zero())
+  }
+
   /**
    * Creates a TokenAmount from a decimal string representation.
    * @param token - The token to create an amount for
@@ -46,22 +54,14 @@ export class TokenAmount implements Serializable {
   }
 
   /**
-   * Parses a serialized TokenAmount string and creates a TokenAmount instance.
-   * @param serialized - The serialized string in format: TokenAmount(token,amount)
-   * @returns A new TokenAmount instance parsed from the serialized data
+   * Creates a TokenAmount from a serialized string.
+   * @param serialized - The serialized string to parse
+   * @returns A new TokenAmount instance
    */
-  static parse(serialized: string): TokenAmount {
-    const isTokenAmount = serialized.startsWith(`${TokenAmount.SERIALIZED_PREFIX}(`) && serialized.endsWith(')')
-    if (!isTokenAmount) throw new Error('Invalid serialized token amount')
-
-    const elements = parseCSV(serialized.slice(TokenAmount.SERIALIZED_PREFIX.length + 1, -1))
-    const areNull = elements.some((element) => element === null)
-    if (areNull) throw new Error('Invalid serialized token amount')
-
-    const token = Token.parse(elements[0]!)
-    const amount = BigInt.parse(elements[1]!)
-
-    return new TokenAmount(token, amount)
+  static fromSerializable(serialized: string): TokenAmount {
+    const data = JSON.parse<SerializableTokenAmount>(serialized)
+    const token = BlockchainToken.fromString(data.token.address, data.token.chainId)
+    return TokenAmount.fromStringDecimal(token, data.amount)
   }
 
   /**
@@ -217,11 +217,14 @@ export class TokenAmount implements Serializable {
    * 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.unwrap()
     const amountUsd = this.amount.times(tokenPrice.value).downscale(this.decimals)
-    return USD.fromBigInt(amountUsd)
+    return Result.ok<USD, string>(USD.fromBigInt(amountUsd))
   }
 
   /**
@@ -229,13 +232,39 @@ export class TokenAmount implements Serializable {
    * @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.unwrap().toTokenAmount(other)
   }
 
-  serialize(): string {
-    return `${TokenAmount.SERIALIZED_PREFIX}(${join([serialize(this.token), serialize(this.amount)])})`
+  /**
+   * Calculates the minimum output amount using basis points (bps).
+   * Formula: minAmountOut = amountOut * (10000 - bps) / 10000
+   *
+   * @param slippage - Slippage in basis points (0-10000). Example: 50 = 0.5%
+   * @returns A new TokenAmount representing the minimum output amount
+   */
+  applySlippageBps(slippage: i32): TokenAmount {
+    const slippageBI = BigInt.fromI32(slippage)
+    if (slippageBI.isNegative() || slippageBI.gt(BPS_SCALE))
+      throw new Error(`Slippage bps must be between 0 and ${BPS_SCALE}`)
+    return this.applySlippage(slippageBI)
+  }
+
+  /**
+   * Calculates the minimum output amount from a percentage string.
+   * Formula: minAmountOut = amountOut * (100 - percent) / 100
+   *
+   * @param slippage - Slippage percentage as a decimal string. Example: '0.5' = 0.5%
+   * @returns A new TokenAmount representing the minimum output amount
+   */
+  applySlippagePercentage(slippage: string): TokenAmount {
+    const bps = BigInt.fromStringDecimal(slippage, 2)
+    if (bps.isNegative() || bps.gt(BPS_SCALE)) throw new Error('Slippage percentage must be between 0 and 100')
+    return this.applySlippage(bps)
   }
 
   private amountCompare(other: TokenAmount): i32 {
@@ -245,4 +274,17 @@ export class TokenAmount implements Serializable {
   private checkToken(other: Token, action: string): void {
     if (!this.token.equals(other)) throw new Error(`Cannot ${action} different tokens`)
   }
+
+  private applySlippage(value: BigInt): TokenAmount {
+    const factor = BPS_SCALE.minus(value)
+    return this.times(factor).div(BPS_SCALE)
+  }
+}
+
+@json
+export class SerializableTokenAmount {
+  constructor(
+    public token: SerializableToken,
+    public amount: string
+  ) {}
 }

package/src/tokens/TokenProvider.ts

@@ -0,0 +1,54 @@
+import { ChainId } from '../types'
+
+import { BlockchainToken } from './BlockchainToken'
+
+/**
+ * Represents a token provider that can resolve to a specific BlockchainToken instance
+ * based on the provided chain ID.
+ * This allows for convenient access to common tokens across different chains.
+ * Supports both ERC20Token (EVM chains) and SPLToken (Solana).
+ */
+export class TokenProvider {
+  private _symbol: string
+  private _registry: Map<ChainId, BlockchainToken>
+
+  /**
+   * Creates a new TokenProvider instance.
+   * @param symbol - The token symbol (e.g., "USDC", "USDT")
+   */
+  constructor(symbol: string) {
+    this._symbol = symbol
+    this._registry = new Map<ChainId, BlockchainToken>()
+  }
+
+  /**
+   * Registers a token for a specific chain.
+   * @param chainId - The chain ID to register the token for
+   * @param token - The BlockchainToken instance for this chain (ERC20Token or SPLToken)
+   * @returns The TokenProvider instance for method chaining
+   */
+  register(chainId: ChainId, token: BlockchainToken): TokenProvider {
+    this._registry.set(chainId, token)
+    return this
+  }
+
+  /**
+   * Resolves the token provider to a specific BlockchainToken instance for the given chain.
+   * @param chainId - The chain ID to resolve the token for
+   * @returns The BlockchainToken instance for the specified chain
+   * @throws Error if the token is not supported on the requested chain
+   */
+  on(chainId: i32): BlockchainToken {
+    if (!this.isSupported(chainId)) throw new Error(`Token ${this._symbol} is not registered on chain ${chainId}`)
+    return this._registry.get(chainId)
+  }
+
+  /**
+   * Checks if the token is supported on the given chain.
+   * @param chainId - The chain ID to check
+   * @returns True if the token is supported on the chain, false otherwise
+   */
+  isSupported(chainId: i32): bool {
+    return this._registry.has(chainId)
+  }
+}

package/src/tokens/Tokens.ts

@@ -0,0 +1,186 @@
+import { Arbitrum, Avalanche, Base, BaseSepolia, BNB, Ethereum, Gnosis, Optimism, Polygon, Sonic } from '../chains'
+
+import { TokenProvider } from './TokenProvider'
+
+/**
+ * Token providers that can resolve to chain-specific BlockchainToken instances.
+ * Use the `.on(chainId)` method to get the token for a specific chain.
+ *
+ * @example
+ * ```typescript
+ * import { Tokens, Ethereum } from '@mimicprotocol/lib-ts'
+ *
+ * const usdc = Tokens.USDC.on(inputs.chainId)
+ * const weth = Tokens.WETH.on(Ethereum.CHAIN_ID)
+ * ```
+ */
+export class Tokens {
+  private static _instance: Tokens | null = null
+
+  private readonly usdc: TokenProvider = new TokenProvider('USDC')
+  private readonly usdt: TokenProvider = new TokenProvider('USDT')
+  private readonly dai: TokenProvider = new TokenProvider('DAI')
+  private readonly wbtc: TokenProvider = new TokenProvider('WBTC')
+  private readonly weth: TokenProvider = new TokenProvider('WETH')
+  private readonly eth: TokenProvider = new TokenProvider('ETH')
+  private readonly avax: TokenProvider = new TokenProvider('AVAX')
+  private readonly wavax: TokenProvider = new TokenProvider('WAVAX')
+  private readonly pol: TokenProvider = new TokenProvider('POL')
+  private readonly wpol: TokenProvider = new TokenProvider('WPOL')
+  private readonly bnb: TokenProvider = new TokenProvider('BNB')
+  private readonly wbnb: TokenProvider = new TokenProvider('WBNB')
+  private readonly xdai: TokenProvider = new TokenProvider('xDAI')
+  private readonly sonic: TokenProvider = new TokenProvider('SONIC')
+  private readonly wxdai: TokenProvider = new TokenProvider('WXDAI')
+  private readonly wsonic: TokenProvider = new TokenProvider('WSONIC')
+
+  private constructor() {
+    // Ethereum
+    this.usdc.register(Ethereum.CHAIN_ID, Ethereum.USDC)
+    this.usdt.register(Ethereum.CHAIN_ID, Ethereum.USDT)
+    this.dai.register(Ethereum.CHAIN_ID, Ethereum.DAI)
+    this.wbtc.register(Ethereum.CHAIN_ID, Ethereum.WBTC)
+    this.weth.register(Ethereum.CHAIN_ID, Ethereum.WETH)
+    this.eth.register(Ethereum.CHAIN_ID, Ethereum.ETH)
+
+    // Arbitrum
+    this.usdc.register(Arbitrum.CHAIN_ID, Arbitrum.USDC)
+    this.usdt.register(Arbitrum.CHAIN_ID, Arbitrum.USDT)
+    this.dai.register(Arbitrum.CHAIN_ID, Arbitrum.DAI)
+    this.wbtc.register(Arbitrum.CHAIN_ID, Arbitrum.WBTC)
+    this.weth.register(Arbitrum.CHAIN_ID, Arbitrum.WETH)
+    this.eth.register(Arbitrum.CHAIN_ID, Arbitrum.ETH)
+
+    // Avalanche
+    this.usdc.register(Avalanche.CHAIN_ID, Avalanche.USDC)
+    this.usdt.register(Avalanche.CHAIN_ID, Avalanche.USDT)
+    this.dai.register(Avalanche.CHAIN_ID, Avalanche.DAI)
+    this.wbtc.register(Avalanche.CHAIN_ID, Avalanche.WBTC)
+    this.weth.register(Avalanche.CHAIN_ID, Avalanche.WETH)
+    this.avax.register(Avalanche.CHAIN_ID, Avalanche.AVAX)
+    this.wavax.register(Avalanche.CHAIN_ID, Avalanche.WAVAX)
+
+    // Base
+    this.usdc.register(Base.CHAIN_ID, Base.USDC)
+    this.usdt.register(Base.CHAIN_ID, Base.USDT)
+    this.dai.register(Base.CHAIN_ID, Base.DAI)
+    this.wbtc.register(Base.CHAIN_ID, Base.WBTC)
+    this.weth.register(Base.CHAIN_ID, Base.WETH)
+    this.eth.register(Base.CHAIN_ID, Base.ETH)
+
+    // BNB
+    this.usdc.register(BNB.CHAIN_ID, BNB.USDC)
+    this.usdt.register(BNB.CHAIN_ID, BNB.USDT)
+    this.dai.register(BNB.CHAIN_ID, BNB.DAI)
+    this.wbtc.register(BNB.CHAIN_ID, BNB.WBTC)
+    this.weth.register(BNB.CHAIN_ID, BNB.WETH)
+    this.bnb.register(BNB.CHAIN_ID, BNB.BNB)
+    this.wbnb.register(BNB.CHAIN_ID, BNB.WBNB)
+
+    // Optimism
+    this.usdc.register(Optimism.CHAIN_ID, Optimism.USDC)
+    this.usdt.register(Optimism.CHAIN_ID, Optimism.USDT)
+    this.dai.register(Optimism.CHAIN_ID, Optimism.DAI)
+    this.wbtc.register(Optimism.CHAIN_ID, Optimism.WBTC)
+    this.weth.register(Optimism.CHAIN_ID, Optimism.WETH)
+    this.eth.register(Optimism.CHAIN_ID, Optimism.ETH)
+
+    // Gnosis
+    this.usdc.register(Gnosis.CHAIN_ID, Gnosis.USDC)
+    this.usdt.register(Gnosis.CHAIN_ID, Gnosis.USDT)
+    this.wbtc.register(Gnosis.CHAIN_ID, Gnosis.WBTC)
+    this.weth.register(Gnosis.CHAIN_ID, Gnosis.WETH)
+    this.xdai.register(Gnosis.CHAIN_ID, Gnosis.xDAI)
+    this.wxdai.register(Gnosis.CHAIN_ID, Gnosis.WXDAI)
+
+    // Polygon
+    this.usdc.register(Polygon.CHAIN_ID, Polygon.USDC)
+    this.usdt.register(Polygon.CHAIN_ID, Polygon.USDT)
+    this.dai.register(Polygon.CHAIN_ID, Polygon.DAI)
+    this.wbtc.register(Polygon.CHAIN_ID, Polygon.WBTC)
+    this.weth.register(Polygon.CHAIN_ID, Polygon.WETH)
+    this.pol.register(Polygon.CHAIN_ID, Polygon.POL)
+    this.wpol.register(Polygon.CHAIN_ID, Polygon.WPOL)
+
+    // Sonic
+    this.usdc.register(Sonic.CHAIN_ID, Sonic.USDC)
+    this.usdt.register(Sonic.CHAIN_ID, Sonic.USDT)
+    this.weth.register(Sonic.CHAIN_ID, Sonic.WETH)
+    this.sonic.register(Sonic.CHAIN_ID, Sonic.SONIC)
+    this.wsonic.register(Sonic.CHAIN_ID, Sonic.WSONIC)
+
+    // BaseSepolia
+    this.eth.register(BaseSepolia.CHAIN_ID, BaseSepolia.ETH)
+  }
+
+  private static getInstance(): Tokens {
+    if (Tokens._instance === null) {
+      Tokens._instance = new Tokens()
+    }
+    return Tokens._instance!
+  }
+
+  static get USDC(): TokenProvider {
+    return Tokens.getInstance().usdc
+  }
+
+  static get USDT(): TokenProvider {
+    return Tokens.getInstance().usdt
+  }
+
+  static get DAI(): TokenProvider {
+    return Tokens.getInstance().dai
+  }
+
+  static get WBTC(): TokenProvider {
+    return Tokens.getInstance().wbtc
+  }
+
+  static get WETH(): TokenProvider {
+    return Tokens.getInstance().weth
+  }
+
+  static get ETH(): TokenProvider {
+    return Tokens.getInstance().eth
+  }
+
+  static get AVAX(): TokenProvider {
+    return Tokens.getInstance().avax
+  }
+
+  static get WAVAX(): TokenProvider {
+    return Tokens.getInstance().wavax
+  }
+
+  static get POL(): TokenProvider {
+    return Tokens.getInstance().pol
+  }
+
+  static get WPOL(): TokenProvider {
+    return Tokens.getInstance().wpol
+  }
+
+  static get BNB(): TokenProvider {
+    return Tokens.getInstance().bnb
+  }
+
+  static get WBNB(): TokenProvider {
+    return Tokens.getInstance().wbnb
+  }
+
+  static get XDAI(): TokenProvider {
+    return Tokens.getInstance().xdai
+  }
+
+  static get SONIC(): TokenProvider {
+    return Tokens.getInstance().sonic
+  }
+
+  static get WXDAI(): TokenProvider {
+    return Tokens.getInstance().wxdai
+  }
+
+  static get WSONIC(): TokenProvider {
+    return Tokens.getInstance().wsonic
+  }
+}

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.
@@ -42,7 +42,6 @@ export class USD {
    * @returns A new USD instance
    */
   static fromBigInt(amount: BigInt): USD {
-    if (amount.isNegative()) throw new Error('USD cannot be negative')
     return new USD(amount)
   }
 
@@ -51,6 +50,7 @@ export class USD {
    * @param amount - The amount in 18 decimals precision (must be non-negative)
    */
   constructor(amount: BigInt) {
+    if (amount.isNegative()) throw new Error('USD cannot be negative')
     this._value = amount.clone()
   }
 
@@ -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.unwrap()
     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/tokens/index.ts

@@ -1,3 +1,9 @@
+export * from './BlockchainToken'
+export * from './DenominationToken'
+export * from './ERC20Token'
+export * from './SPLToken'
 export * from './Token'
 export * from './TokenAmount'
+export * from './TokenProvider'
+export * from './Tokens'
 export * from './USD'