@mimicprotocol/lib-ts 0.0.1-rc.18 → 0.0.1-rc.19

package/index.ts

@@ -4,5 +4,6 @@ export * from './src/evm'
 export * from './src/helpers'
 export * from './src/intents'
 export * from './src/log'
+export * from './src/svm'
 export * from './src/tokens'
 export * from './src/types'

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@mimicprotocol/lib-ts",
-  "version": "0.0.1-rc.18",
+  "version": "0.0.1-rc.19",
   "license": "GPL-3.0",
   "private": false,
   "type": "module",
   "scripts": {
     "build": "asc index.ts -b build/lib.wasm --disableWarning 235 --noEmit --transform json-as/transform",
     "test": "asp",
-    "lint": "eslint . --ignore-pattern 'src/environment.ts' --ignore-pattern 'src/evm.ts' --ignore-pattern 'src/log.ts'"
+    "lint": "eslint . --ignore-pattern 'src/environment.ts' --ignore-pattern 'src/evm.ts' --ignore-pattern 'src/svm.ts' --ignore-pattern 'src/log.ts'"
   },
   "files": [
     "src",

package/src/context/Context.ts

@@ -1,4 +1,5 @@
-import { Address, ChainId } from '../types'
+import { evm } from '../evm'
+import { Address, BigInt, ChainId, EvmDecodeParam, JSON } from '../types'
 import { TriggerType } from '../types/TriggerType'
 
 @json
@@ -20,12 +21,50 @@ export class Settler {
   }
 }
 
+@json
+export class SerializableTrigger {
+  constructor(
+    public type: u8,
+    public data: string
+  ) {}
+}
+
+export class EventTriggerData {
+  constructor(
+    public blockHash: string,
+    public index: BigInt,
+    public topics: string[],
+    public eventData: string
+  ) {}
+}
+
 @json
 export class Trigger {
   constructor(
     public type: TriggerType,
     public data: string
   ) {}
+
+  static fromSerializable(serializable: SerializableTrigger): Trigger {
+    return new Trigger(serializable.type, serializable.data)
+  }
+
+  getCronData(): BigInt {
+    return Trigger.deserializeCronTriggerData(this.data)
+  }
+
+  getEventData(): EventTriggerData {
+    return Trigger.deserializeEventTriggerData(this.data)
+  }
+
+  static deserializeCronTriggerData(data: string): BigInt {
+    return BigInt.fromString(evm.decode(new EvmDecodeParam('uint256', data)))
+  }
+
+  static deserializeEventTriggerData(data: string): EventTriggerData {
+    const fields = JSON.parse<string[]>(evm.decode(new EvmDecodeParam('(bytes32,uint256,bytes32[],bytes)', data)))
+    return new EventTriggerData(fields[0], BigInt.fromString(fields[1]), JSON.parse<string[]>(fields[2]), fields[3])
+  }
 }
 
 @json
@@ -36,7 +75,7 @@ export class SerializableContext {
     public user: string,
     public settlers: SerializableSettler[],
     public configSig: string,
-    public trigger: Trigger
+    public trigger: SerializableTrigger
   ) {}
 }
 
@@ -57,7 +96,7 @@ export class Context {
       Address.fromString(serializable.user),
       serializable.settlers.map<Settler>((s) => Settler.fromSerializable(s)),
       serializable.configSig,
-      serializable.trigger
+      Trigger.fromSerializable(serializable.trigger)
     )
   }
 

package/src/environment.ts

@@ -3,7 +3,18 @@ import { JSON } from 'json-as/assembly'
 import { Context, SerializableContext } from './context'
 import { ListType } from './helpers'
 import { Swap, Transfer, Call } from './intents'
-import { Call as CallQuery, GetPrice, GetRelevantTokens, GetRelevantTokensResponse } from './queries'
+import {
+  Call as CallQuery,
+  GetAccountsInfo,
+  GetAccountsInfoResponse,
+  GetPrice,
+  GetRelevantTokens,
+  GetRelevantTokensResponse,
+  RelevantTokenBalance,
+  SerializableGetAccountsInfoResponse,
+  SubgraphQuery,
+  SubgraphQueryResponse,
+} from './queries'
 import { BlockchainToken, Token, TokenAmount, USD } from './tokens'
 import { Address, BigInt, ChainId } from './types'
 
@@ -26,6 +37,12 @@ export namespace environment {
   @external('environment', '_contractCall')
   declare function _contractCall(params: string): string
 
+  @external('environment', '_subgraphQuery')
+  declare function _subgraphQuery(params: string): string
+
+  @external('environment', '_getAccountsInfo')
+  declare function _getAccountsInfo(params: string): string
+
   @external('environment', '_getContext')
   declare function _getContext(): string
 
@@ -96,12 +113,12 @@ 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)
-   * @param timestamp - The timestamp for relevant tokens query (optional, defaults to current time)
-   * @returns Array of TokenAmount objects representing the relevant tokens
+   * @returns Array of RelevantTokenBalance objects representing the relevant tokens
    */
-  export function getRawRelevantTokens(address: Address, chainIds: ChainId[], usdMinAmount: USD, tokensList: BlockchainToken[], listType: ListType, timestamp: Date | null): GetRelevantTokensResponse[][] {
-    const responseStr = _getRelevantTokens(JSON.stringify(GetRelevantTokens.init(address, chainIds, usdMinAmount, tokensList, listType, timestamp)))
-    return JSON.parse<GetRelevantTokensResponse[][]>(responseStr)
+  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)
   }
 
   /**
@@ -111,7 +128,6 @@ 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)
-   * @param timestamp - The timestamp for relevant tokens qery (optional, defaults to current time)
    * @returns Array of TokenAmount objects representing the relevant tokens
    */
   export function getRelevantTokens(
@@ -119,10 +135,9 @@ export namespace environment {
     chainIds: ChainId[],
     usdMinAmount: USD = USD.zero(),
     tokensList: BlockchainToken[] = [],
-    listType: ListType = ListType.DenyList,
-    timestamp: Date | null = null
+    listType: ListType = ListType.DenyList
   ): TokenAmount[] {
-    const response = getRawRelevantTokens(address, chainIds, usdMinAmount, tokensList, listType, timestamp)
+    const response = getRawRelevantTokens(address, chainIds, usdMinAmount, tokensList, listType)
     const resultMap: Map<string, TokenAmount> = new Map()
     for (let i = 0; i < response.length; i++) {
       for (let j = 0; j < response[i].length; j++) {
@@ -155,6 +170,46 @@ export namespace environment {
     )
   }
 
+  /**
+   * Generates 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,
+  ): SubgraphQueryResponse {
+    const responseStr = _subgraphQuery(JSON.stringify(SubgraphQuery.from(chainId, subgraphId, query, timestamp)))
+    return JSON.parse<SubgraphQueryResponse>(responseStr)
+  }
+   
+  /**
+   * 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
+   */
+
+  export function getAccountsInfo(
+    publicKeys: Address[],
+    timestamp: Date | 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)
+  }
+
   /**
    * Tells the current execution context containing environment information.
    * @returns The Context object containing: user, settler, timestamp, and config ID

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/index.ts

@@ -1,3 +1,4 @@
+export * from './BorshDeserializer'
 export * from './constants'
 export * from './serialize'
 export * from './strings'

package/src/helpers/serialize.ts

@@ -1,5 +1,4 @@
-import { evm } from '../evm'
-import { BigInt, EvmDecodeParam } from '../types'
+import { Bytes } from '../types'
 
 export interface Stringable {
   toString(): string
@@ -9,13 +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 deserializeCronTriggerData(data: string): BigInt {
-  return BigInt.fromString(evm.decode(new EvmDecodeParam('uint256', data)))
-}

package/src/helpers/strings.ts

@@ -2,8 +2,8 @@ import { decode, encode } from 'as-base58/assembly/index'
 
 import { ByteArray } from '../types'
 
-export function bytesToString(bytes: Uint8Array): string {
-  return String.UTF8.decodeUnsafe(bytes.dataStart, bytes.length)
+export function bytesToString(bytes: Uint8Array, nullTerminated: bool = false): string {
+  return String.UTF8.decodeUnsafe(bytes.dataStart, bytes.length, nullTerminated)
 }
 
 export function bytesToHexString(bytes: Uint8Array): string {
@@ -21,6 +21,11 @@ export function bytesFromBase58String(base58: string): ByteArray {
   return changetype<ByteArray>(decode(base58))
 }
 
+export function stringToBool(str: string): bool {
+  if (str !== 'true' && str !== 'false') throw new Error(`Invalid boolean: ${str}`)
+  return str === 'true'
+}
+
 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/intents/Call.ts

@@ -1,7 +1,6 @@
 import { environment } from '../environment'
 import { TokenAmount } from '../tokens'
-import { ChainId } from '../types'
-import { Address, BigInt, Bytes } from '../types'
+import { Address, BigInt, Bytes, ChainId } from '../types'
 
 import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from './Intent'
 

package/src/queries/GetAccountsInfo.ts

@@ -0,0 +1,46 @@
+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/GetRelevantTokens.ts

@@ -6,7 +6,7 @@ import { Address, BigInt, ChainId } from '../types'
 class TokenQuery {
   constructor(
     public address: string,
-    public chainId: i32
+    public chainId: ChainId
   ) {}
 
   static fromToken(token: BlockchainToken): TokenQuery {
@@ -15,7 +15,7 @@ class TokenQuery {
 }
 
 @json
-class GetRelevantTokensBase {
+export class GetRelevantTokens {
   constructor(
     public readonly owner: string,
     public readonly chainIds: ChainId[],
@@ -23,51 +23,23 @@ class GetRelevantTokensBase {
     public readonly tokens: TokenQuery[],
     public readonly tokenFilter: ListType
   ) {}
-}
-
-@json
-export class GetRelevantTokens extends GetRelevantTokensBase {
-  public readonly timestamp: i64
-
-  constructor(
-    owner: string,
-    chainIds: ChainId[],
-    usdMinAmount: string,
-    tokens: TokenQuery[],
-    tokenFilter: ListType,
-    timestamp: i64
-  ) {
-    super(owner, chainIds, usdMinAmount, tokens, tokenFilter)
-    this.timestamp = timestamp
-  }
 
   static init(
     owner: Address,
     chainIds: ChainId[],
     usdMinAmount: USD,
     tokens: BlockchainToken[],
-    tokenFilter: ListType,
-    timestamp: Date | null = null
-  ): GetRelevantTokensBase {
+    tokenFilter: ListType
+  ): GetRelevantTokens {
     const ownerStr = owner.toString()
     const usdMinAmountStr = usdMinAmount.toString()
     const tokensQueries = tokens.map<TokenQuery>((token) => TokenQuery.fromToken(token))
-
-    return timestamp
-      ? new GetRelevantTokens(
-          ownerStr,
-          chainIds,
-          usdMinAmountStr,
-          tokensQueries,
-          tokenFilter,
-          changetype<Date>(timestamp).getTime()
-        )
-      : new GetRelevantTokensBase(ownerStr, chainIds, usdMinAmountStr, tokensQueries, tokenFilter)
+    return new GetRelevantTokens(ownerStr, chainIds, usdMinAmountStr, tokensQueries, tokenFilter)
   }
 }
 
 @json
-export class GetRelevantTokensResponse {
+export class RelevantTokenBalance {
   constructor(
     public token: TokenQuery,
     public amount: string
@@ -80,3 +52,11 @@ export class GetRelevantTokensResponse {
     )
   }
 }
+
+@json
+export class GetRelevantTokensResponse {
+  constructor(
+    public timestamp: i64,
+    public balances: RelevantTokenBalance[]
+  ) {}
+}

package/src/queries/SubgraphQuery.ts

@@ -0,0 +1,34 @@
+import { ChainId } from '../types'
+
+@json
+class SubgraphQueryBase {
+  constructor(
+    public readonly chainId: ChainId,
+    public readonly subgraphId: string,
+    public readonly query: string
+  ) {}
+}
+
+@json
+export class SubgraphQuery extends SubgraphQueryBase {
+  public readonly timestamp: i64
+
+  constructor(chainId: ChainId, timestamp: i64, subgraphId: string, query: string) {
+    super(chainId, subgraphId, query)
+    this.timestamp = timestamp
+  }
+
+  static from(chainId: ChainId, subgraphId: string, query: string, timestamp: Date | null): SubgraphQueryBase {
+    return timestamp
+      ? new SubgraphQuery(chainId, changetype<Date>(timestamp).getTime(), subgraphId, query)
+      : new SubgraphQueryBase(chainId, subgraphId, query)
+  }
+}
+
+@json
+export class SubgraphQueryResponse {
+  constructor(
+    public blockNumber: i64,
+    public data: string
+  ) {}
+}

package/src/queries/index.ts

@@ -1,3 +1,5 @@
 export * from './Call'
+export * from './GetAccountsInfo'
 export * from './GetPrice'
 export * from './GetRelevantTokens'
+export * from './SubgraphQuery'

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/SPLToken.ts

@@ -1,5 +1,7 @@
+import { environment } from '../environment'
 import { SVM_NATIVE_ADDRESS } from '../helpers'
-import { Address, ChainId } from '../types'
+import { svm } from '../svm'
+import { Address, ChainId, SvmMint, SvmPdaSeed, SvmTokenMetadataData } from '../types'
 
 import { BlockchainToken } from './BlockchainToken'
 import { Token } from './Token'
@@ -27,8 +29,8 @@ export class SPLToken extends BlockchainToken {
   static fromAddress(
     address: Address,
     chainId: ChainId = ChainId.SOLANA_MAINNET,
-    decimals: u8 = BlockchainToken.EMPTY_DECIMALS,
-    symbol: string = BlockchainToken.EMPTY_SYMBOL
+    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)
@@ -45,8 +47,8 @@ export class SPLToken extends BlockchainToken {
   static fromString(
     address: string,
     chainId: ChainId = ChainId.SOLANA_MAINNET,
-    decimals: u8 = BlockchainToken.EMPTY_DECIMALS,
-    symbol: string = BlockchainToken.EMPTY_SYMBOL
+    decimals: u8 = SPLToken.EMPTY_DECIMALS,
+    symbol: string = SPLToken.EMPTY_SYMBOL
   ): SPLToken {
     return SPLToken.fromAddress(Address.fromString(address), chainId, decimals, symbol)
   }
@@ -57,11 +59,60 @@ export class SPLToken extends BlockchainToken {
    * @param decimals - Number of decimal places
    * @param symbol - Token symbol
    */
-  constructor(address: Address, decimals: u8, symbol: string) {
+  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) {
+      const result = environment.getAccountsInfo([this.address], null)
+      const decimals = SvmMint.fromHex(result.accountsInfo[0].data).decimals
+      this._decimals = decimals
+    }
+    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) {
+      const result = environment.getAccountsInfo([this.getMetadataAddress()], null)
+      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
+    }
+    return this._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.

package/src/types/Address.ts

@@ -8,6 +8,7 @@ import { EVM_NATIVE_ADDRESS, isHex, USD_ADDRESS } from '../helpers'
 
 import { ByteArray } from './ByteArray'
 import { Bytes } from './Bytes'
+import { Option } from './Option'
 
 /**
  * Represents an EVM or SVM address, a fixed-length 20 or 32-byte value.
@@ -21,6 +22,15 @@ export class Address extends Bytes {
     return changetype<Address>(self)
   }
 
+  /**
+   * Returns a None variant for the Option type, representing no address
+   * @param length 32 by default (SVM)
+   * @returns Option.none with empty bytes
+   */
+  static none(length: u32 = 32): Option<Address> {
+    return Option.none<Address>(Address.fromBytes(new Bytes(length)))
+  }
+
   /**
    * Returns the USD denomination address.
    */
@@ -111,4 +121,11 @@ export class Address extends Bytes {
   toString(): string {
     return this.isEVM() ? super.toHexString() : super.toBase58String()
   }
+
+  /**
+   * Returns the address as its underlying bytes
+   */
+  toBytes(): Bytes {
+    return changetype<Bytes>(this.slice(0))
+  }
 }

package/src/types/ByteArray.ts

@@ -176,6 +176,29 @@ export class ByteArray extends Uint8Array implements Serializable {
     return !(this == other)
   }
 
+  /**
+   * Interprets the byte array as a little-endian U16.
+   * Throws in case of overflow.
+   */
+  toU16(): u16 {
+    for (let i = 2; i < this.length; i++) {
+      if (this[i] != 0) {
+        assert(false, 'overflow converting ' + this.toHexString() + ' to u16')
+      }
+    }
+    const paddedBytes = new Bytes(2)
+    paddedBytes[0] = 0
+    paddedBytes[1] = 0
+    const minLen = paddedBytes.length < this.length ? paddedBytes.length : this.length
+    for (let i = 0; i < minLen; i++) {
+      paddedBytes[i] = this[i]
+    }
+    let x: u16 = 0
+    x = (x | paddedBytes[1]) << 8
+    x = x | paddedBytes[0]
+    return x
+  }
+
   /**
    * Interprets the byte array as a little-endian U32.
    * Throws in case of overflow.

package/src/types/Option.ts

@@ -0,0 +1,35 @@
+/**
+ * Simple wrapper for Option<T> Rust types
+ * To be used in tandem with BorshDeserializer
+ */
+export class Option<T> {
+  constructor(
+    private _value: T,
+    public readonly isSome: bool
+  ) {}
+
+  static some<T>(value: T): Option<T> {
+    return new Option<T>(value, true)
+  }
+
+  static none<T>(defaultValue: T = 0 as T): Option<T> {
+    return new Option<T>(defaultValue, false)
+  }
+
+  unwrap(): T {
+    if (this.isSome) return this._value
+    throw new Error("Can't unwrap None variant")
+  }
+
+  eq(other: Option<T>): bool {
+    if (this.isSome != other.isSome) return false
+    if (!this.isSome && !other.isSome) return true
+    return this._value == other._value
+  }
+
+  toString(): string {
+    if (!this.isSome) return 'None'
+    // @ts-expect-error: AssemblyScript lacks runtime reflection, so we assume toString exists
+    return `Some(${this._value.toString ? this._value.toString() : '[Object]'})`
+  }
+}

package/src/types/TriggerType.ts

@@ -1,4 +1,4 @@
 export enum TriggerType {
-  CRON,
-  EVENT,
+  CRON = 0,
+  EVENT = 1,
 }

package/src/types/{EvmEncodeParam.ts → evm/EvmEncodeParam.ts}

@@ -1,6 +1,6 @@
 import { JSON } from 'json-as'
 
-import { serialize, Stringable } from '../helpers'
+import { serialize, Stringable } from '../../helpers'
 
 @json
 export class EvmEncodeParam {

package/src/types/evm/index.ts

@@ -0,0 +1,2 @@
+export * from './EvmDecodeParam'
+export * from './EvmEncodeParam'

package/src/types/index.ts

@@ -5,6 +5,7 @@ export * from './BigInt'
 export * from './ByteArray'
 export * from './Bytes'
 export * from './ChainId'
-export * from './EvmDecodeParam'
-export * from './EvmEncodeParam'
+export * from './evm'
+export * from './Option'
+export * from './svm'
 export { JSON }

package/src/types/svm/SvmAccountInfo.ts

@@ -0,0 +1,32 @@
+import { stringToBool } from '../../helpers'
+
+export class SvmAccountInfo {
+  constructor(
+    public owner: string,
+    public lamports: string,
+    public data: string,
+    public rentEpoch: string,
+    public executable: bool
+  ) {}
+
+  static fromSerializable(serializable: SerializableSvmAccountInfo): SvmAccountInfo {
+    return new SvmAccountInfo(
+      serializable.owner,
+      serializable.lamports,
+      serializable.data,
+      serializable.rentEpoch,
+      stringToBool(serializable.executable)
+    )
+  }
+}
+
+@json
+export class SerializableSvmAccountInfo {
+  constructor(
+    public owner: string,
+    public lamports: string,
+    public data: string,
+    public rentEpoch: string,
+    public executable: string
+  ) {}
+}

package/src/types/svm/SvmFindProgramAddress.ts

@@ -0,0 +1,32 @@
+import { Address } from './../Address'
+import { SvmPdaSeed } from './SvmPdaSeed'
+
+@json
+export class SvmFindProgramAddressParams {
+  public readonly seeds: SvmPdaSeed[]
+  public readonly programId: string
+
+  constructor(seeds: SvmPdaSeed[], programId: string) {
+    this.seeds = seeds.slice()
+    this.programId = programId
+  }
+}
+
+export class SvmFindProgramAddressResult {
+  constructor(
+    public address: Address,
+    public bump: u8
+  ) {}
+
+  static fromSerializable(serializable: SerializableSvmFindProgramAddressResult): SvmFindProgramAddressResult {
+    return new SvmFindProgramAddressResult(Address.fromString(serializable.address), serializable.bump)
+  }
+}
+
+@json
+export class SerializableSvmFindProgramAddressResult {
+  constructor(
+    public address: string,
+    public bump: u8
+  ) {}
+}

package/src/types/svm/SvmMint.ts

@@ -0,0 +1,44 @@
+import { BorshDeserializer } from '../../helpers'
+
+import { Address } from './../Address'
+import { Bytes } from './../Bytes'
+import { Option } from './../Option'
+
+/**
+ * State layout for Mint TokenProgram PDAs
+ */
+export class SvmMint {
+  static DECIMALS_OFFSET: u32 = 44
+
+  constructor(
+    public mintAuthority: Option<Address>,
+    public supply: u64,
+    public decimals: u8,
+    public isInitialized: bool,
+    public freezeAuthority: Option<Address>
+  ) {}
+
+  static fromHex(hex: string): SvmMint {
+    return this.fromBytes(Bytes.fromHexString(hex))
+  }
+
+  static fromBytes(bytes: Bytes): SvmMint {
+    const deserializer = BorshDeserializer.fromBytes(bytes)
+
+    const mintAuthorityFlag = deserializer.tryU32() === 1
+    const mintAuthority = deserializer.tryPubkey()
+    const supply = deserializer.tryU64()
+    const decimals = deserializer.tryU8()
+    const isInitialized = deserializer.tryBool()
+    const freezeAuthorityFlag = deserializer.tryU32() === 1
+    const freezeAuthority = deserializer.tryPubkey()
+
+    return new SvmMint(
+      mintAuthorityFlag ? Option.some(mintAuthority) : Address.none(),
+      supply,
+      decimals,
+      isInitialized,
+      freezeAuthorityFlag ? Option.some(freezeAuthority) : Address.none()
+    )
+  }
+}

package/src/types/svm/SvmPdaSeed.ts

@@ -0,0 +1,19 @@
+import { Byteable, bytesToHexString } from '../../helpers'
+
+/**
+ * Type for findProgramAddress seeds
+ * As we need all seeds to be decoded as bytes in the same way as in Rust,
+ * this class provides a simple interface for end-users to abstract all this
+ */
+@json
+export class SvmPdaSeed {
+  constructor(public readonly hex: string) {}
+
+  static fromString(str: string): SvmPdaSeed {
+    return new SvmPdaSeed(bytesToHexString(Uint8Array.wrap(String.UTF8.encode(str))))
+  }
+
+  static from<T extends Byteable>(t: T): SvmPdaSeed {
+    return new SvmPdaSeed(bytesToHexString(t.toBytes()))
+  }
+}

package/src/types/svm/SvmTokenMetadataData.ts

@@ -0,0 +1,29 @@
+import { BorshDeserializer } from '../../helpers'
+
+import { Bytes } from './../Bytes'
+
+/**
+ * Partial state layout for Data Metaplex PDA (Metadata PDA "data" field)
+ */
+export class SvmTokenMetadataData {
+  static DATA_OFFSET: u32 = 65
+  // eslint-disable-next-line no-secrets/no-secrets
+  static METADATA_PROGRAM_ID: string = 'metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s'
+
+  constructor(
+    public name: string,
+    public symbol: string,
+    public uri: string
+  ) {}
+
+  static fromTokenMetadataHex(hex: string): SvmTokenMetadataData {
+    return this.fromTokenMetadataBytes(Bytes.fromHexString(hex))
+  }
+
+  static fromTokenMetadataBytes(bytes: Bytes): SvmTokenMetadataData {
+    const deserializer = BorshDeserializer.fromBytes(bytes)
+    deserializer.setOffset(this.DATA_OFFSET)
+
+    return new SvmTokenMetadataData(deserializer.tryString(), deserializer.tryString(), deserializer.tryString())
+  }
+}

package/src/types/svm/index.ts

@@ -0,0 +1,5 @@
+export * from './SvmAccountInfo'
+export * from './SvmFindProgramAddress'
+export * from './SvmMint'
+export * from './SvmPdaSeed'
+export * from './SvmTokenMetadataData'