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

package/src/intents/Intent.ts

@@ -1,53 +1,204 @@
 import { environment } from '../environment'
 import { evm } from '../evm'
 import { NULL_ADDRESS } from '../helpers'
-import { Address, BigInt } from '../types'
+import { Token, TokenAmount } from '../tokens'
+import { Address, BigInt, Bytes, ChainId } from '../types'
 
 export enum OperationType {
   Swap,
   Transfer,
-  Call,
+  EvmCall,
+  SvmCall,
 }
 
 const DEFAULT_DEADLINE = 5 * 60 // 5 minutes in seconds
 
+/**
+ * Base builder for creating intents.
+ */
 export abstract class IntentBuilder {
   protected user: Address | null = null
   protected settler: Address | null = null
   protected deadline: BigInt | null = null
   protected nonce: string | null = null
+  protected maxFees: TokenAmount[] = []
+  protected events: IntentEvent[] = []
 
+  /**
+   * Sets the settler address for this intent.
+   * @param settler - The settler address as an Address instance
+   * @returns This IntentBuilder instance for method chaining
+   */
   addSettler(settler: Address): IntentBuilder {
     this.settler = settler
     return this
   }
 
+  /**
+   * Sets the settler address from a string.
+   * @param settler - The settler address as a hex string
+   * @returns This IntentBuilder instance for method chaining
+   */
   addSettlerAsString(settler: string): IntentBuilder {
     return this.addSettler(Address.fromString(settler))
   }
 
+  /**
+   * Sets the deadline for this intent.
+   * @param deadline - The deadline as a timestamp
+   * @returns This IntentBuilder instance for method chaining
+   */
   addDeadline(deadline: BigInt): IntentBuilder {
     this.deadline = deadline
     return this
   }
 
+  /**
+   * Sets the user address for this intent.
+   * @param user - The user address
+   * @returns This IntentBuilder instance for method chaining
+   */
   addUser(user: Address): IntentBuilder {
     this.user = user
     return this
   }
 
+  /**
+   * Sets the user address from a string.
+   * @param user - The user address as a hex string
+   * @returns This IntentBuilder instance for method chaining
+   */
   addUserAsString(user: string): IntentBuilder {
     return this.addUser(Address.fromString(user))
   }
 
+  /**
+   * Sets the nonce for this intent.
+   * @param nonce - The nonce to be set for the intent
+   * @returns This IntentBuilder instance for method chaining
+   */
   addNonce(nonce: string): IntentBuilder {
     this.nonce = nonce
     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 IntentBuilder instance for method chaining
+   */
+  addEvent(topic: Bytes, data: Bytes): IntentBuilder {
+    const event = new IntentEvent(topic, data)
+    this.events.push(event)
+    return this
+  }
+
+  /**
+   * Sets multiple events for the intent.
+   * @param events - The list of events to be added
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addEvents(events: IntentEvent[]): IntentBuilder {
+    for (let i = 0; i < events.length; i++) {
+      this.events.push(events[i])
+    }
+    return this
+  }
+
+  /**
+   * Adds a max fee for this intent.
+   * @param fee - The max fee token amount (must be on same chain)
+   * @returns This IntentBuilder instance for method chaining
+   */
+  abstract addMaxFee(fee: TokenAmount): IntentBuilder
+
+  /**
+   * Builds and returns the final intent.
+   * @returns A new intent
+   */
   abstract build(): Intent
 }
 
+/**
+ * Represents an intent max fee.
+ * Specifies the token address and the max amount to be paid for the intent.
+ */
+@json
+export class MaxFee {
+  token: string
+  amount: string
+
+  /**
+   * Creates a MaxFee from a TokenAmount.
+   * @param tokenAmount - The token amount to be used as max fee
+   * @returns A new MaxFee instance
+   */
+  static fromTokenAmount(tokenAmount: TokenAmount): MaxFee {
+    return new MaxFee(tokenAmount.token.address, tokenAmount.amount)
+  }
+
+  /**
+   * Creates a MaxFee from a 32-bit integer amount.
+   * @param token - The max fee token
+   * @param amount - The max fee amount
+   * @returns A new MaxFee instance
+   */
+  static fromI32(token: Token, amount: i32): MaxFee {
+    return this.fromTokenAmount(TokenAmount.fromI32(token, amount))
+  }
+
+  /**
+   * Creates a MaxFee from a BigInt amount.
+   * @param token - The max fee token
+   * @param amount - The max fee amount in the token's smallest unit
+   * @returns A new MaxFee instance
+   */
+  static fromBigInt(token: Token, amount: BigInt): MaxFee {
+    return this.fromTokenAmount(TokenAmount.fromBigInt(token, amount))
+  }
+
+  /**
+   * Creates a MaxFee from a decimal string amount.
+   * @param token - The max fee token
+   * @param amount - The max fee amount as a decimal string
+   * @returns A new MaxFee instance
+   */
+  static fromStringDecimal(token: Token, amount: string): MaxFee {
+    return this.fromTokenAmount(TokenAmount.fromStringDecimal(token, amount))
+  }
+
+  /**
+   * Creates a new MaxFee instance.
+   * @param token - The max fee token address
+   * @param amount - The max fee amount
+   */
+  constructor(token: Address, amount: BigInt) {
+    this.token = token.toString()
+    this.amount = amount.toString()
+  }
+}
+
+/**
+ * Represents an intent event.
+ * Specifies the topic and data for the event. The topic is an indexed parameter for the EVM events.
+ */
+@json
+export class IntentEvent {
+  topic: string
+  data: string
+
+  /**
+   * Creates a new Intent Event instance.
+   * @param topic - the topic that is going to be index in the event
+   * @param data - The event data
+   */
+  constructor(topic: Bytes, data: Bytes) {
+    this.topic = topic.toHexString()
+    this.data = data.toHexString()
+  }
+}
+
 let INTENT_INDEX: u32 = 0
 @json
 export abstract class Intent {
@@ -56,24 +207,46 @@ export abstract class Intent {
   public user: string
   public deadline: string
   public nonce: string
+  public maxFees: MaxFee[]
+  public events: IntentEvent[]
 
+  /**
+   * Creates a new intent.
+   * @param op - The type of intent to be created
+   * @param chainId - The chain ID for fetch the settler
+   * @param maxFees - The list of max fees to pay for the intent (optional)
+   * @param settler - The settler address (optional)
+   * @param user - The user address (optional)
+   * @param deadline - The deadline timestamp (optional)
+   * @param nonce - The nonce for replay protection (optional)
+   */
   protected constructor(
     op: OperationType,
+    chainId: ChainId,
+    maxFees: MaxFee[] | null,
     settler: Address | null,
     user: Address | null,
     deadline: BigInt | null,
-    nonce: string | null
+    nonce: string | null,
+    events: IntentEvent[] | null
   ) {
     const context = environment.getContext()
     this.op = op
-    this.settler = settler ? settler.toString() : context.settler.toString()
+    this.maxFees = maxFees || []
+    this.settler = settler ? settler.toString() : context.findSettler(chainId).toString()
     this.deadline = deadline ? deadline.toString() : (context.timestamp / 1000 + DEFAULT_DEADLINE).toString()
     this.user = user ? user.toString() : context.user.toString()
-    this.nonce = nonce ? nonce : evm.keccak(`${context.configId}${context.timestamp}${++INTENT_INDEX}`)
+    this.events = events || []
+    this.nonce = nonce
+      ? nonce
+      : evm.keccak(`${context.triggerSig}${context.timestamp}${context.triggerPayload.data}${++INTENT_INDEX}`)
 
     if (!this.user || this.user == NULL_ADDRESS) throw new Error('A user must be specified')
     if (!this.settler || this.settler == NULL_ADDRESS) throw new Error('A settler contract must be specified')
   }
 
+  /**
+   * Sends this intent to the execution environment.
+   */
   abstract send(): void
 }

package/src/intents/Swap.ts

@@ -1,18 +1,18 @@
 import { environment } from '../environment'
 import { Token, TokenAmount } from '../tokens'
-import { Address, BigInt, ChainId } from '../types'
+import { Address, BigInt, Bytes, ChainId } from '../types'
 
-import { Intent, IntentBuilder, OperationType } from './Intent'
+import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from './Intent'
 
 /**
  * Builder for creating Swap intents with token exchange operations.
  * Supports both single-chain and cross-chain swaps with multiple input and output tokens.
  */
 export class SwapBuilder extends IntentBuilder {
-  private sourceChain: ChainId
-  private destinationChain: ChainId
-  private tokensIn: TokenIn[] = []
-  private tokensOut: TokenOut[] = []
+  protected sourceChain: ChainId
+  protected destinationChain: ChainId
+  protected tokensIn: SwapTokenIn[] = []
+  protected tokensOut: SwapTokenOut[] = []
 
   /**
    * Creates a SwapBuilder for a single-chain swap.
@@ -38,7 +38,7 @@ export class SwapBuilder extends IntentBuilder {
    * @param sourceChain - The source blockchain network identifier
    * @param destinationChain - The destination blockchain network identifier
    */
-  constructor(sourceChain: ChainId, destinationChain: ChainId) {
+  private constructor(sourceChain: ChainId, destinationChain: ChainId) {
     super()
     this.sourceChain = sourceChain
     this.destinationChain = destinationChain
@@ -49,7 +49,7 @@ export class SwapBuilder extends IntentBuilder {
    * @param tokenIn - The token input configuration
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokenIn(tokenIn: TokenIn): SwapBuilder {
+  addTokenIn(tokenIn: SwapTokenIn): SwapBuilder {
     this.tokensIn.push(tokenIn)
     return this
   }
@@ -59,17 +59,44 @@ export class SwapBuilder extends IntentBuilder {
    * @param tokensIn - Array of token input configurations
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokensIn(tokensIn: TokenIn[]): SwapBuilder {
+  addTokensIn(tokensIn: SwapTokenIn[]): SwapBuilder {
     for (let i = 0; i < tokensIn.length; i++) this.addTokenIn(tokensIn[i])
     return this
   }
 
+  /**
+   * Adds the tokens in from another SwapBuilder to this SwapBuilder.
+   * @param builder - The SwapBuilder to add the tokens in from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensInFromBuilder(builder: SwapBuilder): SwapBuilder {
+    return this.addTokensIn(builder.getTokensIn())
+  }
+
+  /**
+   * Adds the tokens in from multiple SwapBuilders to this SwapBuilder.
+   * @param builders - The SwapBuilders to add the tokens in from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensInFromBuilders(builders: SwapBuilder[]): SwapBuilder {
+    for (let i = 0; i < builders.length; i++) this.addTokensInFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the tokens in array.
+   * @returns A copy of the tokens in array
+   */
+  getTokensIn(): SwapTokenIn[] {
+    return this.tokensIn.slice(0)
+  }
+
   /**
    * Adds an output token to the swap.
    * @param tokenOut - The token output configuration
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokenOut(tokenOut: TokenOut): SwapBuilder {
+  addTokenOut(tokenOut: SwapTokenOut): SwapBuilder {
     this.tokensOut.push(tokenOut)
     return this
   }
@@ -79,19 +106,46 @@ export class SwapBuilder extends IntentBuilder {
    * @param tokensOut - Array of token output configurations
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokensOut(tokensOut: TokenOut[]): SwapBuilder {
+  addTokensOut(tokensOut: SwapTokenOut[]): SwapBuilder {
     for (let i = 0; i < tokensOut.length; i++) this.addTokenOut(tokensOut[i])
     return this
   }
 
+  /**
+   * Adds the tokens out from another SwapBuilder to this SwapBuilder.
+   * @param builder - The SwapBuilder to add the tokens out from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensOutFromBuilder(builder: SwapBuilder): SwapBuilder {
+    return this.addTokensOut(builder.getTokensOut())
+  }
+
+  /**
+   * Adds the tokens out from multiple SwapBuilders to this SwapBuilder.
+   * @param builders - The SwapBuilders to add the tokens out from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensOutFromBuilders(builders: SwapBuilder[]): SwapBuilder {
+    for (let i = 0; i < builders.length; i++) this.addTokensOutFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the tokens out array.
+   * @returns A copy of the tokens out array
+   */
+  getTokensOut(): SwapTokenOut[] {
+    return this.tokensOut.slice(0)
+  }
+
   /**
    * Adds an input token from a TokenAmount.
    * @param tokenAmount - The token amount to swap from (must be on source chain)
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenInFromTokenAmount(tokenAmount: TokenAmount): SwapBuilder {
-    if (tokenAmount.token.chainId !== this.sourceChain) throw new Error('Tokens in must be on the same chain')
-    return this.addTokenIn(TokenIn.fromTokenAmount(tokenAmount))
+    if (!tokenAmount.token.hasChain(this.sourceChain)) throw new Error('Tokens in must be on the same chain')
+    return this.addTokenIn(SwapTokenIn.fromTokenAmount(tokenAmount))
   }
 
   /**
@@ -111,8 +165,8 @@ export class SwapBuilder extends IntentBuilder {
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenInFromStringDecimal(token: Token, amount: string): SwapBuilder {
-    if (token.chainId !== this.sourceChain) throw new Error('Tokens in must be on the same chain')
-    return this.addTokenIn(TokenIn.fromStringDecimal(token, amount))
+    if (!token.hasChain(this.sourceChain)) throw new Error('Tokens in must be on the source chain')
+    return this.addTokenIn(SwapTokenIn.fromStringDecimal(token, amount))
   }
 
   /**
@@ -122,8 +176,9 @@ export class SwapBuilder extends IntentBuilder {
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenOutFromTokenAmount(tokenAmount: TokenAmount, recipient: Address): SwapBuilder {
-    if (tokenAmount.token.chainId !== this.destinationChain) throw new Error('Tokens out must be on the same chain')
-    return this.addTokenOut(TokenOut.fromTokenAmount(tokenAmount, recipient))
+    if (!tokenAmount.token.hasChain(this.destinationChain))
+      throw new Error('Tokens out must be on the destination chain')
+    return this.addTokenOut(SwapTokenOut.fromTokenAmount(tokenAmount, recipient))
   }
 
   /**
@@ -145,8 +200,8 @@ export class SwapBuilder extends IntentBuilder {
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenOutFromStringDecimal(token: Token, amount: string, recipient: Address): SwapBuilder {
-    if (token.chainId !== this.destinationChain) throw new Error('Tokens out must be on the same chain')
-    return this.addTokenOut(TokenOut.fromStringDecimal(token, amount, recipient))
+    if (!token.hasChain(this.destinationChain)) throw new Error('Tokens out must be on the destination chain')
+    return this.addTokenOut(SwapTokenOut.fromStringDecimal(token, amount, recipient))
   }
 
   /**
@@ -203,6 +258,36 @@ export class SwapBuilder extends IntentBuilder {
     return changetype<SwapBuilder>(super.addNonce(nonce))
   }
 
+  /**
+   * Adds a max fee for this intent.
+   * @param fee - The max fee token amount (must be on same chain)
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addMaxFee(fee: TokenAmount): SwapBuilder {
+    if (!fee.token.hasChain(this.destinationChain)) throw new Error('Fee token must be on the destination 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 SwapBuilder instance for method chaining
+   */
+  addEvent(topic: Bytes, data: Bytes): SwapBuilder {
+    return changetype<SwapBuilder>(super.addEvent(topic, data))
+  }
+
+  /**
+   * Sets multiple events for the intent.
+   * @param events - The list of events to be added
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addEvents(events: IntentEvent[]): SwapBuilder {
+    return changetype<SwapBuilder>(super.addEvents(events))
+  }
+
   /**
    * Builds and returns the final Swap intent.
    * @returns A new Swap instance with all configured parameters
@@ -218,7 +303,9 @@ export class SwapBuilder extends IntentBuilder {
       this.settler,
       this.user,
       this.deadline,
-      this.nonce
+      this.nonce,
+      this.maxFees,
+      this.events
     )
   }
 }
@@ -228,7 +315,7 @@ export class SwapBuilder extends IntentBuilder {
  * Specifies the token address and amount to be swapped.
  */
 @json
-export class TokenIn {
+export class SwapTokenIn {
   token: string
   amount: string
 
@@ -237,8 +324,8 @@ export class TokenIn {
    * @param tokenAmount - The token amount to swap from
    * @returns A new TokenIn instance
    */
-  static fromTokenAmount(tokenAmount: TokenAmount): TokenIn {
-    return new TokenIn(tokenAmount.token.address, tokenAmount.amount)
+  static fromTokenAmount(tokenAmount: TokenAmount): SwapTokenIn {
+    return new SwapTokenIn(tokenAmount.token.address, tokenAmount.amount)
   }
 
   /**
@@ -247,7 +334,7 @@ export class TokenIn {
    * @param amount - The amount as a whole number
    * @returns A new TokenIn instance
    */
-  static fromI32(token: Token, amount: i32): TokenIn {
+  static fromI32(token: Token, amount: i32): SwapTokenIn {
     return this.fromTokenAmount(TokenAmount.fromI32(token, amount))
   }
 
@@ -257,7 +344,7 @@ export class TokenIn {
    * @param amount - The amount in the token's smallest unit
    * @returns A new TokenIn instance
    */
-  static fromBigInt(token: Token, amount: BigInt): TokenIn {
+  static fromBigInt(token: Token, amount: BigInt): SwapTokenIn {
     return this.fromTokenAmount(TokenAmount.fromBigInt(token, amount))
   }
 
@@ -267,7 +354,7 @@ export class TokenIn {
    * @param amount - The amount as a decimal string
    * @returns A new TokenIn instance
    */
-  static fromStringDecimal(token: Token, amount: string): TokenIn {
+  static fromStringDecimal(token: Token, amount: string): SwapTokenIn {
     return this.fromTokenAmount(TokenAmount.fromStringDecimal(token, amount))
   }
 
@@ -287,7 +374,7 @@ export class TokenIn {
  * Specifies the token address, minimum amount to receive, and recipient.
  */
 @json
-export class TokenOut {
+export class SwapTokenOut {
   token: string
   minAmount: string
   recipient: string
@@ -298,8 +385,8 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromTokenAmount(tokenAmount: TokenAmount, recipient: Address): TokenOut {
-    return new TokenOut(tokenAmount.token.address, tokenAmount.amount, recipient)
+  static fromTokenAmount(tokenAmount: TokenAmount, recipient: Address): SwapTokenOut {
+    return new SwapTokenOut(tokenAmount.token.address, tokenAmount.amount, recipient)
   }
 
   /**
@@ -309,7 +396,7 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromI32(token: Token, amount: i32, recipient: Address): TokenOut {
+  static fromI32(token: Token, amount: i32, recipient: Address): SwapTokenOut {
     return this.fromTokenAmount(TokenAmount.fromI32(token, amount), recipient)
   }
 
@@ -320,7 +407,7 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromBigInt(token: Token, amount: BigInt, recipient: Address): TokenOut {
+  static fromBigInt(token: Token, amount: BigInt, recipient: Address): SwapTokenOut {
     return this.fromTokenAmount(TokenAmount.fromBigInt(token, amount), recipient)
   }
 
@@ -331,7 +418,7 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromStringDecimal(token: Token, amount: string, recipient: Address): TokenOut {
+  static fromStringDecimal(token: Token, amount: string, recipient: Address): SwapTokenOut {
     return this.fromTokenAmount(TokenAmount.fromStringDecimal(token, amount), recipient)
   }
 
@@ -356,9 +443,9 @@ export class Swap extends Intent {
   /**
    * Creates a simple single-chain swap intent.
    * @param chainId - The blockchain network identifier
-   * @param tokenIn - The input token address
+   * @param tokenIn - The input token
    * @param amountIn - The amount to swap from
-   * @param tokenOut - The output token address
+   * @param tokenOut - The output token
    * @param minAmountOut - The minimum amount to receive
    * @param settler - The settler address (optional)
    * @param user - The user address (optional)
@@ -368,20 +455,21 @@ export class Swap extends Intent {
    */
   static create(
     chainId: ChainId,
-    tokenIn: Address,
+    tokenIn: Token,
     amountIn: BigInt,
-    tokenOut: Address,
+    tokenOut: Token,
     minAmountOut: 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
   ): Swap {
     const context = environment.getContext()
     const recipient = user || context.user
-    const swapIn = TokenIn.fromBigInt(Token.fromAddress(tokenIn, chainId), amountIn)
-    const swapOut = TokenOut.fromBigInt(Token.fromAddress(tokenOut, chainId), minAmountOut, recipient)
-    return new Swap(chainId, [swapIn], [swapOut], chainId, settler, user, deadline, nonce)
+    const swapIn = SwapTokenIn.fromBigInt(tokenIn, amountIn)
+    const swapOut = SwapTokenOut.fromBigInt(tokenOut, minAmountOut, recipient)
+    return new Swap(chainId, [swapIn], [swapOut], chainId, settler, user, deadline, nonce, [], events)
   }
 
   /**
@@ -394,18 +482,22 @@ export class Swap extends Intent {
    * @param user - The user address (optional)
    * @param deadline - The deadline timestamp (optional)
    * @param nonce - The nonce for replay protection (optional)
+   * @param maxFees - The list of max fees to pay for the swap intent (optional)
    */
   constructor(
     public sourceChain: ChainId,
-    public tokensIn: TokenIn[],
-    public tokensOut: TokenOut[],
+    public tokensIn: SwapTokenIn[],
+    public tokensOut: SwapTokenOut[],
     public destinationChain: ChainId,
     settler: Address | null = null,
     user: Address | null = null,
     deadline: BigInt | null = null,
-    nonce: string | null = null
+    nonce: string | null = null,
+    maxFees: TokenAmount[] | null = null,
+    events: IntentEvent[] | null = null
   ) {
-    super(OperationType.Swap, settler, user, deadline, nonce)
+    const fees: MaxFee[] = maxFees ? maxFees.map((fee: TokenAmount) => MaxFee.fromTokenAmount(fee)) : []
+    super(OperationType.Swap, sourceChain, fees, settler, user, deadline, nonce, events)
     if (tokensIn.length === 0) throw new Error('TokenIn list cannot be empty')
     if (tokensOut.length === 0) throw new Error('TokenOut list cannot be empty')
   }