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

package/src/queries/TokenPriceQuery.ts

@@ -0,0 +1,47 @@
+import { BlockchainToken, USD } from '../tokens'
+import { BigInt, Result } from '../types'
+
+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
+  }
+
+  toResult(): Result<USD[], string> {
+    return this.buildResult<string[], USD[]>(this.data, 'Unknown error getting price', (data) =>
+      data.map<USD>((price) => USD.fromBigInt(BigInt.fromString(price)))
+    )
+  }
+}

package/src/queries/index.ts

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

package/src/storage/index.ts

@@ -0,0 +1 @@
+export * from './storage'

package/src/storage/storage.ts

@@ -0,0 +1,40 @@
+import { environment } from '../environment'
+import { evm } from '../evm'
+import { MIMIC_HELPER_ADDRESS } from '../helpers'
+import { EvmCall, EvmCallBuilder } from '../intents'
+import { Address, Bytes, ChainId, EvmDecodeParam, EvmEncodeParam, Result } from '../types'
+
+const ADDRESS = Address.fromHexString(MIMIC_HELPER_ADDRESS)
+const DEFAULT_CHAIN_ID = ChainId.OPTIMISM
+
+export namespace storage {
+  export function createSetDataCall(
+    smartAccount: Address,
+    key: string,
+    data: Bytes,
+    chainId: ChainId = DEFAULT_CHAIN_ID
+  ): EvmCall {
+    const encodedData = Bytes.fromHexString(
+      '0x1c1bbd37' +
+        evm.encode([EvmEncodeParam.fromValue('string', Bytes.fromUTF8(key)), EvmEncodeParam.fromValue('bytes', data)])
+    )
+    return EvmCallBuilder.forChain(chainId).addUser(smartAccount).addCall(ADDRESS, encodedData).build()
+  }
+
+  export function getData(
+    smartAccount: Address,
+    key: string,
+    chainId: ChainId = DEFAULT_CHAIN_ID
+  ): Result<Bytes, string> {
+    const encodedData =
+      '0x53f71fd3' +
+      evm.encode([
+        EvmEncodeParam.fromValue('address', smartAccount),
+        EvmEncodeParam.fromValue('string', Bytes.fromUTF8(key)),
+      ])
+    const response = environment.evmCallQuery(ADDRESS, chainId, encodedData)
+    if (response.isError) return Result.err<Bytes, string>(response.error)
+    const decoded = Bytes.fromHexString(evm.decode(new EvmDecodeParam('bytes', response.unwrap())))
+    return Result.ok<Bytes, string>(decoded)
+  }
+}

package/src/svm.ts

@@ -0,0 +1,27 @@
+import { JSON } from 'json-as'
+
+import {
+  Address,
+  SerializableSvmFindProgramAddressResult,
+  SvmFindProgramAddressParams,
+  SvmFindProgramAddressResult,
+  SvmPdaSeed,
+} from './types'
+
+export namespace svm {
+  @external('svm', '_findProgramAddress')
+  declare function _findProgramAddress(params: string): string
+
+  /**
+   * Calculates PDA address
+   * @param seeds - SvmPdaSeed array of seeds
+   * @param programId - Base programId to be derived of
+   * @returns The PDA address and bump
+   */
+  export function findProgramAddress(seeds: SvmPdaSeed[], programId: Address): SvmFindProgramAddressResult {
+    const params = new SvmFindProgramAddressParams(seeds, programId.toBase58String())
+    const result = _findProgramAddress(JSON.stringify(params))
+    const parsed = JSON.parse<SerializableSvmFindProgramAddressResult>(result)
+    return SvmFindProgramAddressResult.fromSerializable(parsed)
+  }
+}

package/src/tokens/BlockchainToken.ts

@@ -0,0 +1,108 @@
+import { Address, ChainId, JSON } from '../types'
+
+import { ERC20Token } from './ERC20Token'
+import { SPLToken } from './SPLToken'
+import { SerializableToken, Token } from './Token'
+
+/**
+ * Represents a token on a blockchain network
+ */
+export abstract class BlockchainToken extends Token {
+  public static readonly EMPTY_SYMBOL: string = ''
+  public static readonly EMPTY_DECIMALS: u8 = u8.MAX_VALUE
+
+  private _chainId: ChainId
+
+  /**
+   * Creates a Blockchain 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)
+   * @returns A new Token instance
+   */
+  static fromAddress(
+    address: Address,
+    chainId: ChainId,
+    decimals: u8 = BlockchainToken.EMPTY_DECIMALS,
+    symbol: string = BlockchainToken.EMPTY_SYMBOL
+  ): BlockchainToken {
+    if (address.isEVM()) return ERC20Token.fromAddress(address, chainId, decimals, symbol)
+    if (chainId != ChainId.SOLANA_MAINNET) throw new Error(`SVM tokens are only supported for Solana mainnet.`)
+    return SPLToken.fromAddress(address, ChainId.SOLANA_MAINNET, decimals, symbol)
+  }
+
+  /**
+   * Creates a Token instance from a string address.
+   * @param address - The contract address as a hex string
+   * @param chainId - The blockchain network identifier
+   * @param symbol - Token symbol (optional, will be queried if not provided)
+   * @param decimals - Number of decimal places (optional, will be queried if not provided)
+   * @returns A new Blockchain Token instance
+   */
+  static fromString(
+    address: string,
+    chainId: ChainId,
+    decimals: u8 = BlockchainToken.EMPTY_DECIMALS,
+    symbol: string = BlockchainToken.EMPTY_SYMBOL
+  ): BlockchainToken {
+    return BlockchainToken.fromAddress(Address.fromString(address), chainId, decimals, symbol)
+  }
+
+  /**
+   * Creates a BlockchainToken from a serialized string.
+   * @param serialized - The serialized string to parse
+   * @returns A new BlockchainToken instance
+   */
+  static fromSerializable(serialized: string): BlockchainToken {
+    const data = JSON.parse<SerializableToken>(serialized)
+    return BlockchainToken.fromString(data.address, data.chainId)
+  }
+
+  /**
+   * Creates a new BlockchainToken instance
+   * @param address The token address in the corresponding blockchain (contract, mint, etc.)
+   * @param decimals - Number of decimal places
+   * @param symbol - Token symbol
+   * @param chainId - The blockchain network identifier
+   */
+  constructor(address: Address, decimals: u8, symbol: string, chainId: ChainId) {
+    super(address, decimals, symbol)
+    this._chainId = chainId
+  }
+
+  /**
+   * Gets the blockchain network identifier where this token is deployed.
+   * This value is assigned during construction and remains constant throughout the token's lifecycle.
+   * @returns The `ChainId` representing the token's network.
+   */
+  get chainId(): ChainId {
+    return this._chainId
+  }
+
+  /**
+   * Checks if this token is the USD denomination.
+   * @returns False always
+   */
+  isUSD(): boolean {
+    return false
+  }
+
+  /**
+   * Checks if this token belongs to the requested chain.
+   * @param chain - The chain ID asking for
+   * @returns True if chains are equal
+   */
+  hasChain(chain: ChainId): boolean {
+    return this._chainId === chain
+  }
+
+  /**
+   * Tells the string representation of this token.
+   * @returns The token address and chain ID along with symbol if present
+   */
+  toString(): string {
+    const description = 'Token ' + this.address.toString() + ' on chain ' + this.chainId.toString()
+    return description + (this._symbol ? ' (' + this._symbol + ')' : '')
+  }
+}

package/src/tokens/DenominationToken.ts

@@ -0,0 +1,70 @@
+import { Address, ChainId } from '../types'
+
+import { Token } from './Token'
+
+/**
+ * Represents a denomination token including data like symbol, decimals, and address.
+ */
+export class DenominationToken extends Token {
+  /**
+   * Creates a Denomination Token instance representing USD.
+   * @returns A new Denomination Token instance for USD
+   */
+  static USD(): DenominationToken {
+    return new DenominationToken(Address.USD(), 18, 'USD')
+  }
+
+  /**
+   * Creates a new Denomination Token instance.
+   * @param address - The contract address of the token
+   * @param decimals - Number of decimal places
+   * @param symbol - Token symbol
+   */
+  constructor(address: Address, decimals: u8, symbol: string) {
+    super(address, decimals, symbol)
+  }
+
+  /**
+   * Checks if this token is equal to another token.
+   * Denomination Tokens are considered equal if they have the same address.
+   * @param other - The token to compare with
+   * @returns True if both tokens represent the denomination token
+   */
+  equals(other: Token): boolean {
+    return other instanceof DenominationToken && super.equals(other)
+  }
+
+  /**
+   * Checks if this token is the USD denomination.
+   * @returns True if the token is the USD denomination
+   */
+  isUSD(): boolean {
+    return this.equals(DenominationToken.USD())
+  }
+
+  /**
+   * Checks if this token is the native token.
+   * @returns True if the token is the native token
+   */
+  isNative(): boolean {
+    return false
+  }
+
+  /**
+   * Checks if this token belongs to the requested chain.
+   * @param chain - The chain ID asking for
+   * @returns True always, denomination tokens are chain-agnostic.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  hasChain(chain: ChainId): boolean {
+    return true
+  }
+
+  /**
+   * Tells the string representation of this token.
+   * @returns The token symbol
+   */
+  toString(): string {
+    return this.symbol
+  }
+}

package/src/tokens/ERC20Token.ts

@@ -0,0 +1,192 @@
+import { environment } from '../environment'
+import { evm } from '../evm'
+import { EVM_NATIVE_ADDRESS } from '../helpers/constants'
+import { log } from '../log'
+import { Address, ChainId, EvmDecodeParam } from '../types'
+
+import { BlockchainToken } from './BlockchainToken'
+import { Token } from './Token'
+
+/**
+ * Represents an ERC-20 token on a blockchain network including data like symbol, decimals, and address.
+ */
+export class ERC20Token extends BlockchainToken {
+  public static readonly EMPTY_DECIMALS: u8 = u8.MAX_VALUE
+  public static readonly EMPTY_SYMBOL: string = ''
+
+  private _timestamp: Date | null = null
+
+  /**
+   * 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): ERC20Token {
+    switch (chainId) {
+      case ChainId.ETHEREUM:
+      case ChainId.BASE:
+      case ChainId.BASE_SEPOLIA:
+      case ChainId.ARBITRUM:
+      case ChainId.OPTIMISM:
+        return ERC20Token.fromString(EVM_NATIVE_ADDRESS, chainId, 18, 'ETH')
+      case ChainId.BNB:
+        return ERC20Token.fromString(EVM_NATIVE_ADDRESS, chainId, 18, 'BNB')
+      case ChainId.GNOSIS:
+        return ERC20Token.fromString(EVM_NATIVE_ADDRESS, chainId, 18, 'xDAI')
+      case ChainId.POLYGON:
+        return ERC20Token.fromString('0x0000000000000000000000000000000000001010', chainId, 18, 'POL')
+      case ChainId.AVALANCHE:
+        return ERC20Token.fromString(EVM_NATIVE_ADDRESS, chainId, 18, 'AVAX')
+      case ChainId.SONIC:
+        return ERC20Token.fromString(EVM_NATIVE_ADDRESS, chainId, 18, 'SONIC')
+      default:
+        throw new Error(`Unsupported chainId: ${chainId}`)
+    }
+  }
+
+  /**
+   * 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 = ERC20Token.EMPTY_DECIMALS,
+    symbol: string = ERC20Token.EMPTY_SYMBOL,
+    timestamp: Date | null = null
+  ): ERC20Token {
+    return new ERC20Token(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 = ERC20Token.EMPTY_DECIMALS,
+    symbol: string = ERC20Token.EMPTY_SYMBOL,
+    timestamp: Date | null = null
+  ): ERC20Token {
+    return ERC20Token.fromAddress(Address.fromString(address), chainId, decimals, symbol, timestamp)
+  }
+
+  /**
+   * 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)
+   */
+  constructor(
+    address: Address,
+    chainId: ChainId,
+    decimals: u8 = ERC20Token.EMPTY_DECIMALS,
+    symbol: string = ERC20Token.EMPTY_SYMBOL,
+    timestamp: Date | null = null
+  ) {
+    if (!address.isEVM()) throw new Error(`Address ${address} must be an EVM address.`)
+    super(address, decimals, symbol, chainId)
+    this._timestamp = timestamp
+
+    // Ensure symbol and decimals are set for native or denomination 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.
+    const hasMissingSymbol = this._symbol === ERC20Token.EMPTY_SYMBOL
+    const hasMissingDecimals = this._decimals === ERC20Token.EMPTY_DECIMALS
+    const hasMissingSymbolOrDecimals = hasMissingSymbol || hasMissingDecimals
+    if (address.isNative() && hasMissingSymbolOrDecimals) {
+      const nativeToken = ERC20Token.native(this.chainId)
+      if (hasMissingSymbol) this._symbol = nativeToken.symbol
+      if (hasMissingDecimals) this._decimals = nativeToken.decimals
+    }
+  }
+
+  /**
+   * Gets the token’s symbol (e.g., "ETH", "USDC").
+   * If the symbol was not provided during construction, it will be lazily fetched
+   * 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) 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 `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) this._getDecimals()
+    return this._decimals
+  }
+
+  /**
+   * Checks if this token is equal to another token.
+   * ERC20 Tokens are considered equal if they have the same address on the same chain.
+   * @param other - The token to compare with
+   * @returns True if both tokens represent the same asset
+   */
+  equals(other: Token): boolean {
+    return other instanceof ERC20Token && super.equals(other) && this.hasChain((other as ERC20Token).chainId)
+  }
+
+  /**
+   * Checks if this token is the native token.
+   * @returns True if the token is the native token
+   */
+  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.unwrap()))
+  }
+
+  /**
+   * 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.unwrap())))
+  }
+}

package/src/tokens/SPLToken.ts

@@ -0,0 +1,162 @@
+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'
+
+import { BlockchainToken } from './BlockchainToken'
+import { Token } from './Token'
+
+/**
+ * Represents a SPL token on the Solana network including data like symbol, decimals, and address.
+ */
+export class SPLToken extends BlockchainToken {
+  /**
+   * Creates a Token instance representing the native SOL token.
+   * @returns A new Token instance for the native token
+   */
+  static native(): SPLToken {
+    return SPLToken.fromString(SVM_NATIVE_ADDRESS, ChainId.SOLANA_MAINNET, 9, 'SOL')
+  }
+
+  /**
+   * Creates a Token instance from an Address object.
+   * @param address - The token mint address
+   * @param chainId - The blockchain network identifier (optional)
+   * @param decimals - Number of decimal places (optional)
+   * @param symbol - Token symbol (optional)
+   * @returns A new Token instance
+   */
+  static fromAddress(
+    address: Address,
+    chainId: ChainId = ChainId.SOLANA_MAINNET,
+    decimals: u8 = SPLToken.EMPTY_DECIMALS,
+    symbol: string = SPLToken.EMPTY_SYMBOL
+  ): SPLToken {
+    if (chainId != ChainId.SOLANA_MAINNET) throw new Error(`SPL tokens are only supported for Solana mainnet.`)
+    return new SPLToken(address, decimals, symbol)
+  }
+
+  /**
+   * Creates a Token instance from a string address.
+   * @param address - The token mint address as a base58 string
+   * @param chainId - The blockchain network identifier (optional)
+   * @param decimals - Number of decimal places (optional)
+   * @param symbol - Token symbol (optional)
+   * @returns A new Token instance
+   */
+  static fromString(
+    address: string,
+    chainId: ChainId = ChainId.SOLANA_MAINNET,
+    decimals: u8 = SPLToken.EMPTY_DECIMALS,
+    symbol: string = SPLToken.EMPTY_SYMBOL
+  ): SPLToken {
+    return SPLToken.fromAddress(Address.fromString(address), chainId, decimals, symbol)
+  }
+
+  /**
+   * Creates a new Token instance.
+   * @param address - The token mint address
+   * @param decimals - Number of decimal places
+   * @param symbol - Token symbol
+   */
+  constructor(address: Address, decimals: u8 = SPLToken.EMPTY_DECIMALS, symbol: string = SPLToken.EMPTY_SYMBOL) {
+    if (!address.isSVM()) throw new Error(`Address ${address} must be an SVM address.`)
+    super(address, decimals, symbol, ChainId.SOLANA_MAINNET)
+  }
+
+  /**
+   * Gets the token’s decimals (number of decimal places used).
+   * If decimals were not provided during construction, they will be lazily fetched
+   * 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 == SPLToken.EMPTY_DECIMALS) this._getDecimals()
+    return this._decimals
+  }
+
+  /**
+   * Gets the token’s symbol (e.g., "SOL", "USDC").
+   * If the symbol was not provided during construction, it will be lazily fetched
+   * If the token doesn't have a symbol (TokenMetadata standard), an abbreviated address is returned
+   * The symbol is cached in the instance for future accesses.
+   * @returns A string containing the token symbol.
+   */
+  get symbol(): string {
+    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.unwrap().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.unwrap().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.unwrap().accountsInfo[0].data).symbol
+  }
+
+  /**
+   * Derives Metaplex Metadata address for this given token
+   */
+  private getMetadataAddress(): Address {
+    return svm.findProgramAddress(
+      [
+        SvmPdaSeed.fromString('metadata'),
+        SvmPdaSeed.from(Address.fromString(SvmTokenMetadataData.METADATA_PROGRAM_ID)),
+        SvmPdaSeed.from(this._address),
+      ],
+      Address.fromBase58String(SvmTokenMetadataData.METADATA_PROGRAM_ID)
+    ).address
+  }
+
+  /**
+   * Checks if this token is equal to another token.
+   * SPL 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
+   */
+  equals(other: Token): boolean {
+    return other instanceof SPLToken && super.equals(other)
+  }
+
+  /**
+   * Checks if this token is the native token.
+   * @returns True if the token is the native token
+   */
+  isNative(): boolean {
+    return this.equals(SPLToken.native())
+  }
+}