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

package/src/types/Address.ts

@@ -4,27 +4,54 @@
 // Copyright (c) 2018 Graph Protocol, Inc. and contributors.
 // Modified by Mimic Protocol, 2025.
 
+import { EVM_NATIVE_ADDRESS, USD_ADDRESS } from '../helpers/constants'
+import { isHex } from '../helpers/strings'
+
 import { ByteArray } from './ByteArray'
 import { Bytes } from './Bytes'
+import { Option } from './Option'
 
 /**
- * Represents an Ethereum address, a fixed-length 20-byte value.
+ * Represents an EVM or SVM address, a fixed-length 20 or 32-byte value.
  */
 export class Address extends Bytes {
   /**
-   * Returns a zero address (20 bytes filled with zeroes).
+   * Returns a zero address (default 20 bytes filled with zeroes).
    */
-  static zero(): Address {
-    const self = new ByteArray(20)
+  static zero(length: i32 = 20): Address {
+    const self = new ByteArray(length)
     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.
+   */
+  static USD(): Address {
+    return Address.fromString(USD_ADDRESS)
+  }
+
+  /**
+   * Returns the native address.
+   */
+  static native(): Address {
+    return Address.fromString(EVM_NATIVE_ADDRESS)
+  }
+
   /**
    * Converts a string representation of an address to an Address instance.
-   * It is assumed that the string is a hex string.
+   * If hex, EVM address is returned. Otherwise, base58 (SVM) is assumed.
    */
   static fromString(str: string): Address {
-    return this.fromHexString(str)
+    return isHex(str) ? this.fromHexString(str) : this.fromBase58String(str)
   }
 
   /**
@@ -35,26 +62,71 @@ export class Address extends Bytes {
     return this.fromBytes(bytes)
   }
 
+  /**
+   * Converts a base58 string representation of an address to an Address instance.
+   */
+  static fromBase58String(str: string): Address {
+    const bytes = Bytes.fromBase58String(str)
+    return this.fromBytes(bytes)
+  }
+
   /**
    * Converts a Bytes instance to an Address.
-   * Throws an error if the input is not exactly 20 bytes long.
+   * Throws an error if the input is not exactly 20 or 32 bytes long.
    */
   static fromBytes(bytes: Bytes): Address {
-    if (bytes.length != 20) throw new Error(`Bytes of length ${bytes.length} can not be converted to 20 byte addresses`)
+    if (bytes.length != 20 && bytes.length != 32)
+      throw new Error(`Bytes of length ${bytes.length} can not be converted to 20 or 32 byte addresses`)
     return changetype<Address>(bytes)
   }
 
   /**
-   * Returns the address in hexadecimal. This method is overridden to avoid
+   * Returns a copy of this address.
+   */
+  clone(): Address {
+    return changetype<Address>(this.slice(0))
+  }
+
+  /**
+   * Tells whether this address is an Ethereum address.
+   */
+  isEVM(): bool {
+    return this.length == 20
+  }
+
+  /**
+   * Tells whether this address is a Solana address.
+   */
+  isSVM(): bool {
+    return this.length == 32
+  }
+
+  /**
+   * Tells whether this address is the USD denomination address.
+   */
+  isUsd(): boolean {
+    return this.equals(Address.USD())
+  }
+
+  /**
+   * Tells whether this address is the native address.
+   */
+  isNative(): boolean {
+    return this.equals(Address.native())
+  }
+
+  /**
+   * Returns the address in hexadecimal or base58, accordingly. This method is overridden to avoid
    * returning the UTF-8 encoded version of the address.
    */
   toString(): string {
-    return super.toHexString()
+    return this.isEVM() ? super.toHexString() : super.toBase58String()
   }
 
-  clone(): Address {
-    const copy = new ByteArray(this.length)
-    copy.set(this)
-    return changetype<Address>(copy)
+  /**
+   * Returns the address as its underlying bytes
+   */
+  toBytes(): Bytes {
+    return changetype<Bytes>(this.slice(0))
   }
 }

package/src/types/BigInt.ts

@@ -4,7 +4,7 @@
 // Copyright (c) 2018 Graph Protocol, Inc. and contributors.
 // Modified by Mimic Protocol, 2025.
 
-import { areAllZeros, bytesToHexString, isHex, normalizeScientificNotation, Serializable } from '../helpers'
+import { areAllZeros, bytesToHexString, isHex, MAX_UINT256_HEX, normalizeScientificNotation } from '../helpers'
 
 import { ByteArray } from './ByteArray'
 import { Bytes } from './Bytes'
@@ -14,23 +14,19 @@ const ZERO_ASCII = '0'.charCodeAt(0)
 /**
  * Represents an arbitrary-precision integer stored as a byte array.
  */
-export class BigInt extends Uint8Array implements Serializable {
-  private static readonly SERIALIZED_PREFIX: string = 'BigInt'
-
+export class BigInt extends Uint8Array {
   /**
-   * Parses a serialized representation of a BigInt and converts it to a BigInt.
+   * Returns a BigInt initialized to zero.
    */
-  static parse(serialized: string): BigInt {
-    const isBigInt = serialized.startsWith(`${BigInt.SERIALIZED_PREFIX}(`) && serialized.endsWith(')')
-    if (!isBigInt) throw new Error('Invalid serialized BigInt')
-    return BigInt.fromString(serialized.slice(BigInt.SERIALIZED_PREFIX.length + 1, -1))
+  static zero(): BigInt {
+    return BigInt.fromI32(0)
   }
 
   /**
-   * Returns a BigInt initialized to zero.
+   * Returns a BigInt initialized to the maximum value for a 256-bit unsigned integer.
    */
-  static zero(): BigInt {
-    return BigInt.fromI32(0)
+  static maxUint256(): BigInt {
+    return BigInt.fromHexString(MAX_UINT256_HEX)
   }
 
   /**
@@ -408,15 +404,15 @@ export class BigInt extends Uint8Array implements Serializable {
       return aIsNeg ? resultAbs.neg() : resultAbs
     }
     const cmp = BigInt.compare(this.abs(), other.abs())
-    if (cmp === 0) {
-      return BigInt.zero()
-    } else if (cmp > 0) {
+    if (cmp === 0) return BigInt.zero()
+
+    if (cmp > 0) {
       const resultAbs = BigInt.subUnsigned(this.abs(), other.abs())
       return this.isNegative() ? resultAbs.neg() : resultAbs
-    } else {
-      const resultAbs = BigInt.subUnsigned(other.abs(), this.abs())
-      return other.isNegative() ? resultAbs.neg() : resultAbs
     }
+
+    const resultAbs = BigInt.subUnsigned(other.abs(), this.abs())
+    return other.isNegative() ? resultAbs.neg() : resultAbs
   }
 
   /**
@@ -789,8 +785,4 @@ export class BigInt extends Uint8Array implements Serializable {
       ? `${isNegative ? '-' : ''}${wholePart}.${decimalPart}`
       : `${isNegative ? '-' : ''}${wholePart}`
   }
-
-  serialize(): string {
-    return `${BigInt.SERIALIZED_PREFIX}(${this.toString()})`
-  }
 }

package/src/types/ByteArray.ts

@@ -4,7 +4,7 @@
 // Copyright (c) 2018 Graph Protocol, Inc. and contributors.
 // Modified by Mimic Protocol, 2025.
 
-import { bytesToHexString, bytesToString } from '../helpers'
+import { bytesFromBase58String, bytesToBase58String, bytesToHexString, bytesToString, isHex } from '../helpers'
 import { Serializable } from '../helpers'
 
 import { BigInt } from './BigInt'
@@ -20,7 +20,7 @@ export class ByteArray extends Uint8Array implements Serializable {
    * The resulting byte array is in little-endian order.
    */
   static empty(): ByteArray {
-    return ByteArray.fromI32(0)
+    return new ByteArray(0)
   }
 
   /**
@@ -101,13 +101,21 @@ export class ByteArray extends Uint8Array implements Serializable {
    * It may optionally start with '0x'.
    */
   static fromHexString(hex: string): ByteArray {
-    assert(hex.length % 2 == 0, 'input ' + hex + ' has odd length')
+    assert(hex.length % 2 == 0, `input ${hex} has odd length`)
+    assert(isHex(hex), `input ${hex} is not valid hex`)
     if (hex.length >= 2 && hex.charAt(0) == '0' && hex.charAt(1) == 'x') hex = hex.substring(2)
     const output = new Bytes(hex.length / 2)
     for (let i = 0; i < hex.length; i += 2) output[i / 2] = I8.parseInt(hex.substring(i, i + 2), 16)
     return output
   }
 
+  /**
+   * Converts a base58 string to a ByteArray.
+   */
+  static fromBase58String(base58: string): ByteArray {
+    return bytesFromBase58String(base58)
+  }
+
   /**
    * Converts a UTF-8 string to a ByteArray.
    */
@@ -168,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.
@@ -303,6 +334,13 @@ export class ByteArray extends Uint8Array implements Serializable {
     return bytesToHexString(this)
   }
 
+  /**
+   * Converts this ByteArray to a base58 string.
+   */
+  toBase58String(): string {
+    return bytesToBase58String(this)
+  }
+
   /**
    * Converts this ByteArray to a string representation.
    */

package/src/types/Bytes.ts

@@ -34,6 +34,13 @@ export class Bytes extends ByteArray {
     return changetype<Bytes>(ByteArray.fromHexString(hex))
   }
 
+  /**
+   * Converts a base58 string to a Bytes instance.
+   */
+  static fromBase58String(hex: string): Bytes {
+    return changetype<Bytes>(ByteArray.fromBase58String(hex))
+  }
+
   /**
    * Converts a UTF-8 string to a Bytes instance.
    */

package/src/types/ChainId.ts

@@ -4,6 +4,14 @@
  */
 export enum ChainId {
   ETHEREUM = 1,
-  POLYGON = 137,
   OPTIMISM = 10,
+  BNB = 56,
+  GNOSIS = 100,
+  POLYGON = 137,
+  SONIC = 146,
+  BASE = 8453,
+  ARBITRUM = 42161,
+  AVALANCHE = 43114,
+  BASE_SEPOLIA = 84532,
+  SOLANA_MAINNET = 507424,
 }

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

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

package/src/types/TriggerType.ts

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

package/src/types/evm/EvmDecodeParam.ts

@@ -0,0 +1,7 @@
+@json
+export class EvmDecodeParam {
+  constructor(
+    public readonly abiType: string,
+    public readonly value: string
+  ) {}
+}

package/src/types/evm/EvmEncodeParam.ts

@@ -0,0 +1,31 @@
+import { JSON } from 'json-as'
+
+import { serialize, Stringable } from '../../helpers'
+
+@json
+export class EvmEncodeParam {
+  constructor(
+    public readonly abiType: string,
+    public readonly value: string
+  ) {}
+
+  /**
+   * Creates an EvmEncodeParam for a primitive value.
+   * @param type - The ABI type signature (e.g., "uint256", "address", "string")
+   * @param value - The value to encode, must implement Stringable interface
+   * @returns A new EvmEncodeParam instance representing the primitive value
+   */
+  static fromValue<T extends Stringable>(type: string, value: T): EvmEncodeParam {
+    return new EvmEncodeParam(type, serialize(value))
+  }
+
+  /**
+   * Creates an EvmEncodeParam for complex types like arrays or tuples.
+   * @param type - The ABI type signature (e.g., "address[]", "()", "()[]")
+   * @param values - Array of EvmEncodeParam instances representing the nested elements
+   * @returns A new EvmEncodeParam instance representing the complex type
+   */
+  static fromValues(type: string, values: EvmEncodeParam[]): EvmEncodeParam {
+    return new EvmEncodeParam(type, JSON.stringify(values))
+  }
+}

package/src/types/evm/index.ts

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

package/src/types/index.ts

@@ -1,7 +1,13 @@
+import { JSON } from 'json-as'
+
 export * from './Address'
 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 './Result'
+export * from './svm'
+export * from './TriggerType'
+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/SvmAccountMeta.ts

@@ -0,0 +1,28 @@
+import { Address } from '../Address'
+
+@json
+export class SvmAccountMeta {
+  constructor(
+    public pubkey: string,
+    public isWritable: bool = false,
+    public isSigner: bool = false
+  ) {}
+
+  writable(): SvmAccountMeta {
+    this.isWritable = true
+    return this
+  }
+
+  signer(): SvmAccountMeta {
+    this.isSigner = true
+    return this
+  }
+
+  static fromAddress(pubkey: Address): SvmAccountMeta {
+    return new SvmAccountMeta(pubkey.toString())
+  }
+
+  static fromString(pubkey: string): SvmAccountMeta {
+    return new SvmAccountMeta(pubkey)
+  }
+}

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())
+  }
+}