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

package/src/intents/Transfer.ts

@@ -1,17 +1,16 @@
 import { environment } from '../environment'
-import { Token, TokenAmount } from '../tokens'
-import { Address, BigInt, ChainId } from '../types'
+import { ERC20Token, Token, TokenAmount } from '../tokens'
+import { Address, BigInt, Bytes, ChainId } from '../types'
 
-import { Intent, IntentBuilder, OperationType } from './Intent'
+import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from './Intent'
 
 /**
  * Builder for creating Transfer intents with token transfer operations.
  * Supports multiple transfers within a single transaction on the same chain.
  */
 export class TransferBuilder extends IntentBuilder {
-  private chainId: ChainId
-  private transfers: TransferData[] = []
-  private fee: TokenAmount | null = null
+  protected chainId: ChainId
+  protected transfers: TransferData[] = []
 
   /**
    * Creates a TransferBuilder for a specific chain.
@@ -22,23 +21,11 @@ export class TransferBuilder extends IntentBuilder {
     return new TransferBuilder(chainId)
   }
 
-  /**
-   * Creates a TransferBuilder for a specific chain with a pre-configured fee.
-   * @param chainId - The blockchain network identifier
-   * @param fee - The fee token amount for the transfer
-   * @returns A new TransferBuilder instance with fee set
-   */
-  static forChainWithFee(chainId: ChainId, fee: TokenAmount): TransferBuilder {
-    const builder = new TransferBuilder(chainId)
-    builder.addFee(fee)
-    return builder
-  }
-
   /**
    * Creates a new TransferBuilder instance.
    * @param chainId - The blockchain network identifier
    */
-  constructor(chainId: ChainId) {
+  private constructor(chainId: ChainId) {
     super()
     this.chainId = chainId
   }
@@ -63,6 +50,33 @@ export class TransferBuilder extends IntentBuilder {
     return this
   }
 
+  /**
+   * Adds the transfers from another TransferBuilder to this TransferBuilder.
+   * @param builder - The TransferBuilder to add the transfers from
+   * @returns This TransferBuilder instance for method chaining
+   */
+  addTransfersFromBuilder(builder: TransferBuilder): TransferBuilder {
+    return this.addTransfers(builder.getTransfers())
+  }
+
+  /**
+   * Adds the transfers from multiple TransferBuilders to this TransferBuilder.
+   * @param builders - The TransferBuilders to add the transfers from
+   * @returns This TransferBuilder instance for method chaining
+   */
+  addTransfersFromBuilders(builders: TransferBuilder[]): TransferBuilder {
+    for (let i = 0; i < builders.length; i++) this.addTransfersFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the transfers array.
+   * @returns A copy of the transfers array
+   */
+  getTransfers(): TransferData[] {
+    return this.transfers.slice(0)
+  }
+
   /**
    * Adds a transfer from a TokenAmount.
    * @param tokenAmount - The token amount to transfer (must be on same chain)
@@ -70,7 +84,7 @@ export class TransferBuilder extends IntentBuilder {
    * @returns This TransferBuilder instance for method chaining
    */
   addTransferFromTokenAmount(tokenAmount: TokenAmount, recipient: Address): TransferBuilder {
-    if (tokenAmount.token.chainId !== this.chainId) throw new Error('Transfer tokens must be on the same chain')
+    if (!tokenAmount.token.hasChain(this.chainId)) throw new Error('Transfer tokens must be on the same chain')
     return this.addTransfer(TransferData.fromTokenAmount(tokenAmount, recipient))
   }
 
@@ -82,7 +96,7 @@ export class TransferBuilder extends IntentBuilder {
    * @returns This TransferBuilder instance for method chaining
    */
   addTransferFromI32(token: Token, amount: i32, recipient: Address): TransferBuilder {
-    if (token.chainId !== this.chainId) throw new Error('Transfer tokens must be on the same chain')
+    if (!token.hasChain(this.chainId)) throw new Error('Transfer tokens must be on the same chain')
     return this.addTransfer(TransferData.fromI32(token, amount, recipient))
   }
 
@@ -94,7 +108,7 @@ export class TransferBuilder extends IntentBuilder {
    * @returns This TransferBuilder instance for method chaining
    */
   addTransferFromBigInt(token: Token, amount: BigInt, recipient: Address): TransferBuilder {
-    if (token.chainId !== this.chainId) throw new Error('Transfer tokens must be on the same chain')
+    if (!token.hasChain(this.chainId)) throw new Error('Transfer tokens must be on the same chain')
     return this.addTransfer(TransferData.fromBigInt(token, amount, recipient))
   }
 
@@ -106,7 +120,7 @@ export class TransferBuilder extends IntentBuilder {
    * @returns This TransferBuilder instance for method chaining
    */
   addTransferFromStringDecimal(token: Token, amount: string, recipient: Address): TransferBuilder {
-    if (token.chainId !== this.chainId) throw new Error('Transfer tokens must be on the same chain')
+    if (!token.hasChain(this.chainId)) throw new Error('Transfer tokens must be on the same chain')
     return this.addTransfer(TransferData.fromStringDecimal(token, amount, recipient))
   }
 
@@ -121,17 +135,6 @@ export class TransferBuilder extends IntentBuilder {
     return this
   }
 
-  /**
-   * Sets the fee for this transfer intent.
-   * @param fee - The fee token amount (must be on same chain)
-   * @returns This TransferBuilder instance for method chaining
-   */
-  addFee(fee: TokenAmount): TransferBuilder {
-    if (fee.token.chainId !== this.chainId) throw new Error('Fee token must be on the same chain')
-    this.fee = fee
-    return this
-  }
-
   /**
    * Sets the settler address for this intent.
    * @param settler - The settler address as an Address instance
@@ -143,7 +146,7 @@ export class TransferBuilder extends IntentBuilder {
 
   /**
    * Sets the settler address from a string.
-   * @param settler - The settler address as a hex string
+   * @param settler - The settler address as a hex or base58 string accordingly
    * @returns This TransferBuilder instance for method chaining
    */
   addSettlerAsString(settler: string): TransferBuilder {
@@ -186,20 +189,50 @@ export class TransferBuilder extends IntentBuilder {
     return changetype<TransferBuilder>(super.addNonce(nonce))
   }
 
+  /**
+   * Adds a max fee for this intent.
+   * @param fee - The max fee token amount (must be on same chain)
+   * @returns This TransferBuilder instance for method chaining
+   */
+  addMaxFee(fee: TokenAmount): TransferBuilder {
+    if (!fee.token.hasChain(this.chainId)) throw new Error('Fee token must be on the same chain')
+    this.maxFees.push(fee)
+    return this
+  }
+
+  /**
+   * Sets an event for the intent.
+   * @param topic - The topic to be indexed in the event
+   * @param data - The event data
+   * @returns This TransferBuilder instance for method chaining
+   */
+  addEvent(topic: Bytes, data: Bytes): TransferBuilder {
+    return changetype<TransferBuilder>(super.addEvent(topic, data))
+  }
+
+  /**
+   * Sets multiple events for the intent.
+   * @param events - The list of events to be added
+   * @returns This TransferBuilder instance for method chaining
+   */
+  addEvents(events: IntentEvent[]): TransferBuilder {
+    return changetype<TransferBuilder>(super.addEvents(events))
+  }
+
   /**
    * Builds and returns the final Transfer intent.
    * @returns A new Transfer instance with all configured parameters
    */
   build(): Transfer {
-    if (!this.fee) throw new Error('Transfer fee must be specified')
     return new Transfer(
       this.chainId,
       this.transfers,
-      this.fee as TokenAmount,
+      this.maxFees,
       this.settler,
       this.user,
       this.deadline,
-      this.nonce
+      this.nonce,
+      this.events
     )
   }
 }
@@ -277,16 +310,13 @@ export class TransferData {
 export class Transfer extends Intent {
   public chainId: ChainId
   public transfers: TransferData[]
-  public feeToken: string
-  public feeAmount: string
 
   /**
    * Creates a simple single-token transfer intent.
-   * @param chainId - The blockchain network identifier
-   * @param token - The token address to transfer
+   * @param token - The Token to transfer
    * @param amount - The amount to transfer
    * @param recipient - The address to receive the tokens
-   * @param fee - The fee amount for the transfer
+   * @param maxFee - The max fee to pay for the transfer intent
    * @param settler - The settler address (optional)
    * @param user - The user address (optional)
    * @param deadline - The deadline timestamp (optional)
@@ -294,28 +324,36 @@ export class Transfer extends Intent {
    * @returns A new Transfer instance
    */
   static create(
-    chainId: ChainId,
-    token: Address,
+    token: Token,
     amount: BigInt,
     recipient: Address,
-    fee: BigInt,
+    maxFee: BigInt,
     settler: Address | null = null,
     user: Address | null = null,
     deadline: BigInt | null = null,
-    nonce: string | null = null
+    nonce: string | null = null,
+    events: IntentEvent[] | null = null
   ): Transfer {
-    const transferToken = Token.fromAddress(token, chainId)
-    const transferAmount = TokenAmount.fromBigInt(transferToken, amount)
+    const transferAmount = TokenAmount.fromBigInt(token, amount)
     const transferData = TransferData.fromTokenAmount(transferAmount, recipient)
-    const feeAmount = TokenAmount.fromBigInt(transferToken, fee)
-    return new Transfer(chainId, [transferData], feeAmount, settler, user, deadline, nonce)
+    const maxFees = [TokenAmount.fromBigInt(token, maxFee)]
+    return new Transfer(
+      token instanceof ERC20Token ? (token as ERC20Token).chainId : ChainId.SOLANA_MAINNET,
+      [transferData],
+      maxFees,
+      settler,
+      user,
+      deadline,
+      nonce,
+      events
+    )
   }
 
   /**
    * Creates a new Transfer intent.
    * @param chainId - The blockchain network identifier
    * @param transfers - Array of transfer data configurations
-   * @param fee - The fee token amount for the transfers
+   * @param maxFees - The list of max fees to pay for the transfer intent
    * @param settler - The settler address (optional)
    * @param user - The user address (optional)
    * @param deadline - The deadline timestamp (optional)
@@ -324,19 +362,19 @@ export class Transfer extends Intent {
   constructor(
     chainId: ChainId,
     transfers: TransferData[],
-    fee: TokenAmount,
+    maxFees: TokenAmount[],
     settler: Address | null = null,
     user: Address | null = null,
     deadline: BigInt | null = null,
-    nonce: string | null = null
+    nonce: string | null = null,
+    events: IntentEvent[] | null = null
   ) {
-    super(OperationType.Transfer, settler, user, deadline, nonce)
-
+    const fees: MaxFee[] = maxFees.map((fee: TokenAmount) => MaxFee.fromTokenAmount(fee))
+    super(OperationType.Transfer, chainId, fees, settler, user, deadline, nonce, events)
     if (transfers.length === 0) throw new Error('Transfer list cannot be empty')
+    if (maxFees.length == 0) throw new Error('At least a max fee must be specified')
 
     this.transfers = transfers
-    this.feeToken = fee.token.address.toString()
-    this.feeAmount = fee.amount.toString()
     this.chainId = chainId
   }
 
@@ -346,4 +384,11 @@ export class Transfer extends Intent {
   send(): void {
     environment.transfer(this)
   }
+
+  /**
+   * Whether the chainId is Solana or not
+   */
+  isSVM(): bool {
+    return this.chainId === ChainId.SOLANA_MAINNET
+  }
 }

package/src/log.ts

@@ -0,0 +1,83 @@
+// 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'
+
+export namespace log {
+  @external('log', '_log')
+  declare function _log(level: Level, msg: string): void
+
+  export enum Level {
+    CRITICAL = 0,
+    ERROR = 1,
+    WARNING = 2,
+    INFO = 3,
+    DEBUG = 4,
+  }
+
+  /**
+   * Logs a critical message that terminates the execution.
+   *
+   * @param msg Format string like "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function critical<T extends Stringable>(msg: string, args: Array<T> = []): void {
+    _log(Level.CRITICAL, format(msg, args))
+  }
+
+  /**
+   * Logs an error message.
+   *
+   * @param msg Format string like "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function error<T extends Stringable>(msg: string, args: Array<T> = []): void {
+    _log(Level.ERROR, format(msg, args))
+  }
+
+  /** Logs a warning message.
+   *
+   * @param msg Format string like "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function warning<T extends Stringable>(msg: string, args: Array<T> = []): void {
+    _log(Level.WARNING, format(msg, args))
+  }
+
+  /** Logs an info message.
+   *
+   * @param msg Format string like "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function info<T extends Stringable>(msg: string, args: Array<T> = []): void {
+    _log(Level.INFO, format(msg, args))
+  }
+
+  /** Logs a debug message.
+   *
+   * @param msg Format string like "Value = {}, other = {}".
+   * @param args Format string arguments.
+   */
+  export function debug<T extends Stringable>(msg: string, args: Array<T> = []): void {
+    _log(Level.DEBUG, format(msg, args))
+  }
+}
+
+function format<T extends Stringable>(fmt: string, args: Array<T>): string {
+  let out = ''
+  let argIndex = 0
+  const argsStr = args.map<string>((a) => a.toString())
+  for (let i: i32 = 0, len: i32 = fmt.length; i < len; i++) {
+    if (i < len - 1 && fmt.charCodeAt(i) == 0x7b /* '{' */ && fmt.charCodeAt(i + 1) == 0x7d /* '}' */) {
+      if (argIndex >= argsStr.length) throw new Error('Too few arguments for format string: ' + fmt)
+      out += argsStr[argIndex++]
+      i++
+    } else {
+      out += fmt.charAt(i)
+    }
+  }
+  return out
+}

package/src/queries/EvmCallQuery.ts

@@ -0,0 +1,43 @@
+import { Address, ChainId, Result } from '../types'
+
+import { QueryResponseBase } from './QueryResponse'
+
+@json
+class EvmCallQueryBase {
+  constructor(
+    public readonly to: string,
+    public readonly chainId: ChainId,
+    public readonly data: string
+  ) {}
+}
+
+@json
+export class EvmCallQuery extends EvmCallQueryBase {
+  public readonly timestamp: i64
+
+  constructor(to: string, chainId: ChainId, timestamp: i64, data: string) {
+    super(to, chainId, data)
+    this.timestamp = timestamp
+  }
+
+  static from(to: Address, chainId: ChainId, timestamp: Date | null, data: string): EvmCallQueryBase {
+    const address = to.toString()
+    return timestamp
+      ? new EvmCallQuery(address, chainId, changetype<Date>(timestamp).getTime(), data)
+      : new EvmCallQueryBase(address, chainId, data)
+  }
+}
+
+@json
+export class EvmCallQueryResponse extends QueryResponseBase {
+  public data: string
+
+  constructor(success: string, data: string, error: string) {
+    super(success, error)
+    this.data = data
+  }
+
+  toResult(): Result<string, string> {
+    return this.buildResult<string>(this.data, 'Unknown error getting evm call')
+  }
+}

package/src/queries/QueryResponse.ts

@@ -0,0 +1,26 @@
+import { JSON } from 'json-as'
+
+import { replaceJsonBooleans } from '../helpers'
+import { Result } from '../types'
+
+@json
+export class QueryResponseBase {
+  constructor(
+    public success: string, // boolean as string due to json-as bug
+    public error: string
+  ) {}
+
+  static fromJson<T extends QueryResponseBase>(json: string): T {
+    return JSON.parse<T>(replaceJsonBooleans(json))
+  }
+
+  protected buildResult<TData, TResult = TData>(
+    data: TData,
+    defaultError: string,
+    transform: (data: TData) => TResult = (data: TData) => changetype<TResult>(data)
+  ): Result<TResult, string> {
+    if (this.success !== 'true') return Result.err<TResult, string>(this.error.length > 0 ? this.error : defaultError)
+
+    return Result.ok<TResult, string>(transform(data))
+  }
+}

package/src/queries/RelevantTokensQuery.ts

@@ -0,0 +1,82 @@
+import { ListType } from '../helpers'
+import { BlockchainToken, TokenAmount, USD } from '../tokens'
+import { Address, BigInt, ChainId, Result } from '../types'
+
+import { QueryResponseBase } from './QueryResponse'
+
+@json
+export class TokenQuery {
+  constructor(
+    public address: string,
+    public chainId: i32
+  ) {}
+
+  static fromToken(token: BlockchainToken): TokenQuery {
+    return new TokenQuery(token.address.toString(), token.chainId)
+  }
+}
+
+@json
+export class RelevantTokensQuery {
+  constructor(
+    public readonly owner: string,
+    public readonly chainIds: ChainId[],
+    public readonly usdMinAmount: string,
+    public readonly tokens: TokenQuery[],
+    public readonly tokenFilter: ListType
+  ) {}
+
+  static init(
+    owner: Address,
+    chainIds: ChainId[],
+    usdMinAmount: USD,
+    tokens: BlockchainToken[],
+    tokenFilter: ListType
+  ): RelevantTokensQuery {
+    const ownerStr = owner.toString()
+    const usdMinAmountStr = usdMinAmount.value.toString()
+    const tokensQueries = tokens.map<TokenQuery>((token) => TokenQuery.fromToken(token))
+    return new RelevantTokensQuery(ownerStr, chainIds, usdMinAmountStr, tokensQueries, tokenFilter)
+  }
+}
+
+@json
+export class TokenBalanceQuery {
+  constructor(
+    public token: TokenQuery,
+    public balance: string
+  ) {}
+
+  toTokenAmount(): TokenAmount {
+    return TokenAmount.fromBigInt(
+      BlockchainToken.fromString(this.token.address, this.token.chainId),
+      BigInt.fromString(this.balance)
+    )
+  }
+}
+
+@json
+export class RelevantTokensQueryResult {
+  constructor(
+    public timestamp: i64,
+    public balances: TokenBalanceQuery[]
+  ) {}
+}
+
+@json
+export class RelevantTokensQueryResponse extends QueryResponseBase {
+  public data: RelevantTokensQueryResult[]
+
+  constructor(success: string, data: RelevantTokensQueryResult[], error: string) {
+    super(success, error)
+    this.data = data
+  }
+
+  toResult(): Result<TokenBalanceQuery[][], string> {
+    return this.buildResult<RelevantTokensQueryResult[], TokenBalanceQuery[][]>(
+      this.data,
+      'Unknown error getting relevant tokens',
+      (data) => data.map<TokenBalanceQuery[]>((response: RelevantTokensQueryResult) => response.balances)
+    )
+  }
+}

package/src/queries/SubgraphQuery.ts

@@ -0,0 +1,50 @@
+import { ChainId, Result } from '../types'
+
+import { QueryResponseBase } from './QueryResponse'
+
+@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 SubgraphQueryResult {
+  constructor(
+    public blockNumber: i64,
+    public data: string
+  ) {}
+}
+
+@json
+export class SubgraphQueryResponse extends QueryResponseBase {
+  public data: SubgraphQueryResult
+
+  constructor(success: string, data: SubgraphQueryResult, error: string) {
+    super(success, error)
+    this.data = data
+  }
+
+  toResult(): Result<SubgraphQueryResult, string> {
+    return this.buildResult<SubgraphQueryResult>(this.data, 'Unknown error getting subgraph query')
+  }
+}

package/src/queries/SvmAccountsInfoQuery.ts

@@ -0,0 +1,65 @@
+import { Address, Result, SerializableSvmAccountInfo, SvmAccountInfo } from '../types'
+
+import { QueryResponseBase } from './QueryResponse'
+
+@json
+class SvmAccountsInfoQueryBase {
+  constructor(public readonly publicKeys: string[]) {}
+}
+
+@json
+export class SvmAccountsInfoQuery extends SvmAccountsInfoQueryBase {
+  public readonly timestamp: i64
+
+  constructor(publicKeys: string[], timestamp: i64) {
+    super(publicKeys)
+    this.timestamp = timestamp
+  }
+
+  static from(publicKeys: Address[], timestamp: Date | null): SvmAccountsInfoQueryBase {
+    const strPublicKeys = publicKeys.map((pk: Address) => pk.toString())
+    return timestamp
+      ? new SvmAccountsInfoQuery(strPublicKeys, changetype<Date>(timestamp).getTime())
+      : new SvmAccountsInfoQueryBase(strPublicKeys)
+  }
+}
+
+@json
+export class SerializableSvmAccountsInfoQueryResult {
+  constructor(
+    public accountsInfo: SerializableSvmAccountInfo[],
+    public slot: string
+  ) {}
+}
+
+export class SvmAccountsInfoQueryResult {
+  constructor(
+    public accountsInfo: SvmAccountInfo[],
+    public slot: string
+  ) {}
+
+  static fromSerializable(serializable: SerializableSvmAccountsInfoQueryResult): SvmAccountsInfoQueryResult {
+    return new SvmAccountsInfoQueryResult(
+      serializable.accountsInfo.map((acc: SerializableSvmAccountInfo) => SvmAccountInfo.fromSerializable(acc)),
+      serializable.slot
+    )
+  }
+}
+
+@json
+export class SvmAccountsInfoQueryResponse extends QueryResponseBase {
+  public data: SerializableSvmAccountsInfoQueryResult
+
+  constructor(success: string, data: SerializableSvmAccountsInfoQueryResult, error: string) {
+    super(success, error)
+    this.data = data
+  }
+
+  toResult(): Result<SvmAccountsInfoQueryResult, string> {
+    return this.buildResult<SerializableSvmAccountsInfoQueryResult, SvmAccountsInfoQueryResult>(
+      this.data,
+      'Unknown error getting SVM accounts info',
+      (data) => SvmAccountsInfoQueryResult.fromSerializable(data)
+    )
+  }
+}

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