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

package/src/intents/Operation.ts

@@ -0,0 +1,114 @@
+import { environment } from '../environment'
+import { NULL_ADDRESS } from '../helpers'
+import { Address, Bytes, ChainId } from '../types'
+
+export enum OperationType {
+  Swap,
+  Transfer,
+  EvmCall,
+  CrossChainSwap,
+  EvmDynamicCall,
+  SvmCall,
+}
+
+/**
+ * Represents an operation event.
+ * Specifies the topic and data for the event. The topic is an indexed parameter for the EVM events.
+ */
+@json
+export class OperationEvent {
+  topic: string
+  data: string
+
+  /**
+   * Creates a new Operation 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()
+  }
+}
+
+/**
+ * Base builder for creating operations.
+ */
+export abstract class OperationBuilder {
+  protected user: Address | null = null
+  protected events: OperationEvent[] = []
+
+  abstract build(): Operation
+
+  /**
+   * Sets the user address for this intent.
+   * @param user - The user address
+   * @returns This OperationBuilder instance for method chaining
+   */
+  addUser(user: Address): OperationBuilder {
+    this.user = user
+    return this
+  }
+
+  /**
+   * Sets the user address from a string.
+   * @param user - The user address as a hex string
+   * @returns This OperationBuilder instance for method chaining
+   */
+  addUserAsString(user: string): OperationBuilder {
+    return this.addUser(Address.fromString(user))
+  }
+
+  /**
+   * Sets an event for the intent.
+   * @param topic - The topic to be indexed in the event
+   * @param data - The event data
+   * @returns This OperationBuilder instance for method chaining
+   */
+  addEvent(topic: Bytes, data: Bytes): OperationBuilder {
+    const event = new OperationEvent(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 OperationBuilder instance for method chaining
+   */
+  addEvents(events: OperationEvent[]): OperationBuilder {
+    for (let i = 0; i < events.length; i++) {
+      this.events.push(events[i])
+    }
+    return this
+  }
+}
+
+@json
+export abstract class Operation {
+  public opType: OperationType
+  public chainId: ChainId
+  public user: string
+  public events: OperationEvent[]
+
+  /**
+   * Creates a new operation.
+   * @param opType - The type of operation to be created
+   * @param chainId - The source chain id for the operation
+   * @param user - The user address (optional)
+   * @param events - The list of events for the operation (optional)
+   */
+  protected constructor(
+    opType: OperationType,
+    chainId: ChainId,
+    user: Address | null,
+    events: OperationEvent[] | null
+  ) {
+    const context = environment.getContext()
+    this.opType = opType
+    this.chainId = chainId
+    this.user = user ? user.toString() : context.user.toString()
+    this.events = events || []
+    if (!this.user || this.user == NULL_ADDRESS) throw new Error('A user must be specified')
+  }
+}

package/src/intents/Swap.ts

@@ -1,18 +1,19 @@
 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 { IntentBuilder } from './Intent'
+import { Operation, OperationBuilder, OperationEvent, OperationType } from './Operation'
 
 /**
  * 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[] = []
+export class SwapBuilder extends OperationBuilder {
+  protected sourceChain: ChainId
+  protected destinationChain: ChainId
+  protected tokensIn: SwapTokenIn[] = []
+  protected tokensOut: SwapTokenOut[] = []
 
   /**
    * Creates a SwapBuilder for a single-chain swap.
@@ -38,7 +39,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 +50,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 +60,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 +107,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 +166,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 +177,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,35 +201,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))
-  }
-
-  /**
-   * Sets the settler address for this intent.
-   * @param settler - The settler address as an Address instance
-   * @returns This SwapBuilder instance for method chaining
-   */
-  addSettler(settler: Address): SwapBuilder {
-    return changetype<SwapBuilder>(super.addSettler(settler))
-  }
-
-  /**
-   * Sets the settler address from a string.
-   * @param settler - The settler address as a hex string
-   * @returns This SwapBuilder instance for method chaining
-   */
-  addSettlerAsString(settler: string): SwapBuilder {
-    return changetype<SwapBuilder>(super.addSettlerAsString(settler))
-  }
-
-  /**
-   * Sets the deadline for this intent.
-   * @param deadline - The deadline as a timestamp
-   * @returns This SwapBuilder instance for method chaining
-   */
-  addDeadline(deadline: BigInt): SwapBuilder {
-    return changetype<SwapBuilder>(super.addDeadline(deadline))
+    if (!token.hasChain(this.destinationChain)) throw new Error('Tokens out must be on the destination chain')
+    return this.addTokenOut(SwapTokenOut.fromStringDecimal(token, amount, recipient))
   }
 
   /**
@@ -195,12 +224,22 @@ export class SwapBuilder extends IntentBuilder {
   }
 
   /**
-   * Sets the nonce for this intent.
-   * @param nonce - A unique identifier to prevent replay attacks
+   * 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
    */
-  addNonce(nonce: string): SwapBuilder {
-    return changetype<SwapBuilder>(super.addNonce(nonce))
+  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: OperationEvent[]): SwapBuilder {
+    return changetype<SwapBuilder>(super.addEvents(events))
   }
 
   /**
@@ -210,16 +249,16 @@ export class SwapBuilder extends IntentBuilder {
   build(): Swap {
     if (this.tokensIn.length === 0 || this.tokensOut.length === 0) throw new Error('Tokens in and out are required')
 
-    return new Swap(
-      this.sourceChain,
-      this.tokensIn,
-      this.tokensOut,
-      this.destinationChain,
-      this.settler,
-      this.user,
-      this.deadline,
-      this.nonce
-    )
+    return new Swap(this.sourceChain, this.tokensIn, this.tokensOut, this.destinationChain, this.user, this.events)
+  }
+
+  /**
+   * Builds this operation and sends it inside an intent with the provided fee data.
+   * @param maxFee - The max fee to pay for the intent (optional for swaps)
+   * @param feePayer - The fee payer for the intent (optional)
+   */
+  send(maxFee: TokenAmount | null = null, feePayer: Address | null = null): void {
+    this.build().send(maxFee, feePayer)
   }
 }
 
@@ -228,7 +267,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 +276,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 +286,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 +296,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 +306,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 +326,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 +337,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 +348,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 +359,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 +370,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)
   }
 
@@ -352,38 +391,7 @@ export class TokenOut {
  * Represents a Swap intent for exchanging tokens between blockchain networks.
  */
 @json
-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 amountIn - The amount to swap from
-   * @param tokenOut - The output token address
-   * @param minAmountOut - The minimum amount to receive
-   * @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)
-   * @returns A new Swap instance
-   */
-  static create(
-    chainId: ChainId,
-    tokenIn: Address,
-    amountIn: BigInt,
-    tokenOut: Address,
-    minAmountOut: BigInt,
-    settler: Address | null = null,
-    user: Address | null = null,
-    deadline: BigInt | null = null,
-    nonce: string | 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)
-  }
-
+export class Swap extends Operation {
   /**
    * Creates a new Swap intent.
    * @param sourceChain - The source blockchain network identifier
@@ -394,26 +402,31 @@ 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
+    events: OperationEvent[] | null = null
   ) {
-    super(OperationType.Swap, settler, user, deadline, nonce)
+    const opType = sourceChain == destinationChain ? OperationType.Swap : OperationType.CrossChainSwap
+    super(opType, sourceChain, user, 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')
   }
 
   /**
    * Sends this Swap intent to the execution environment.
-   */
-  send(): void {
-    environment.swap(this)
+   * @param maxFee - The max fee to pay for the intent (optional for swaps)
+   * @param feePayer - The fee payer for the intent (optional)
+   */
+  send(maxFee: TokenAmount | null = null, feePayer: Address | null = null): void {
+    const intentBuilder = new IntentBuilder().addOperation(this)
+    if (maxFee) intentBuilder.addMaxFee(maxFee)
+    if (feePayer) intentBuilder.addFeePayer(feePayer)
+    environment.sendIntent(intentBuilder.build())
   }
 }