@mimicprotocol/lib-ts 0.0.1 → 0.1.1

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

@@ -2,13 +2,14 @@ import { environment } from '../environment'
 import { Token, TokenAmount } from '../tokens'
 import { Address, BigInt, Bytes, ChainId } from '../types'
 
-import { Intent, IntentBuilder, IntentEvent, MaxFee, 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 {
+export class SwapBuilder extends OperationBuilder {
   protected sourceChain: ChainId
   protected destinationChain: ChainId
   protected tokensIn: SwapTokenIn[] = []
@@ -204,33 +205,6 @@ export class SwapBuilder extends IntentBuilder {
     return this.addTokenOut(SwapTokenOut.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))
-  }
-
   /**
    * Sets the user address for this intent.
    * @param user - The user address
@@ -249,26 +223,6 @@ export class SwapBuilder extends IntentBuilder {
     return changetype<SwapBuilder>(super.addUserAsString(user))
   }
 
-  /**
-   * Sets the nonce for this intent.
-   * @param nonce - A unique identifier to prevent replay attacks
-   * @returns This SwapBuilder instance for method chaining
-   */
-  addNonce(nonce: string): SwapBuilder {
-    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
@@ -284,7 +238,7 @@ export class SwapBuilder extends IntentBuilder {
    * @param events - The list of events to be added
    * @returns This SwapBuilder instance for method chaining
    */
-  addEvents(events: IntentEvent[]): SwapBuilder {
+  addEvents(events: OperationEvent[]): SwapBuilder {
     return changetype<SwapBuilder>(super.addEvents(events))
   }
 
@@ -295,18 +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,
-      this.maxFees,
-      this.events
-    )
+    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)
   }
 }
 
@@ -439,39 +391,7 @@ export class SwapTokenOut {
  * 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
-   * @param amountIn - The amount to swap from
-   * @param tokenOut - The output token
-   * @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: Token,
-    amountIn: BigInt,
-    tokenOut: Token,
-    minAmountOut: BigInt,
-    settler: Address | null = null,
-    user: Address | null = null,
-    deadline: BigInt | null = null,
-    nonce: string | null = null,
-    events: IntentEvent[] | null = null
-  ): Swap {
-    const context = environment.getContext()
-    const recipient = user || context.user
-    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)
-  }
-
+export class Swap extends Operation {
   /**
    * Creates a new Swap intent.
    * @param sourceChain - The source blockchain network identifier
@@ -489,23 +409,24 @@ export class Swap extends Intent {
     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,
-    maxFees: TokenAmount[] | null = null,
-    events: IntentEvent[] | null = null
+    events: OperationEvent[] | null = null
   ) {
-    const fees: MaxFee[] = maxFees ? maxFees.map((fee: TokenAmount) => MaxFee.fromTokenAmount(fee)) : []
-    super(OperationType.Swap, sourceChain, fees, settler, user, deadline, nonce, events)
+    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())
   }
 }

package/src/intents/Transfer.ts

@@ -1,14 +1,15 @@
 import { environment } from '../environment'
-import { ERC20Token, Token, TokenAmount } from '../tokens'
+import { Token, TokenAmount } from '../tokens'
 import { Address, BigInt, Bytes, ChainId } from '../types'
 
-import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from './Intent'
+import { IntentBuilder } from './Intent'
+import { Operation, OperationBuilder, OperationEvent, OperationType } from './Operation'
 
 /**
  * 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 {
+export class TransferBuilder extends OperationBuilder {
   protected chainId: ChainId
   protected transfers: TransferData[] = []
 
@@ -135,33 +136,6 @@ export class TransferBuilder extends IntentBuilder {
     return this
   }
 
-  /**
-   * Sets the settler address for this intent.
-   * @param settler - The settler address as an Address instance
-   * @returns This TransferBuilder instance for method chaining
-   */
-  addSettler(settler: Address): TransferBuilder {
-    return changetype<TransferBuilder>(super.addSettler(settler))
-  }
-
-  /**
-   * Sets the settler address from a string.
-   * @param settler - The settler address as a hex or base58 string accordingly
-   * @returns This TransferBuilder instance for method chaining
-   */
-  addSettlerAsString(settler: string): TransferBuilder {
-    return changetype<TransferBuilder>(super.addSettlerAsString(settler))
-  }
-
-  /**
-   * Sets the deadline for this intent.
-   * @param deadline - The deadline as a timestamp
-   * @returns This TransferBuilder instance for method chaining
-   */
-  addDeadline(deadline: BigInt): TransferBuilder {
-    return changetype<TransferBuilder>(super.addDeadline(deadline))
-  }
-
   /**
    * Sets the user address for this intent.
    * @param user - The user address
@@ -180,26 +154,6 @@ export class TransferBuilder extends IntentBuilder {
     return changetype<TransferBuilder>(super.addUserAsString(user))
   }
 
-  /**
-   * Sets the nonce for this intent.
-   * @param nonce - A unique identifier to prevent replay attacks
-   * @returns This TransferBuilder instance for method chaining
-   */
-  addNonce(nonce: string): TransferBuilder {
-    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
@@ -215,7 +169,7 @@ export class TransferBuilder extends IntentBuilder {
    * @param events - The list of events to be added
    * @returns This TransferBuilder instance for method chaining
    */
-  addEvents(events: IntentEvent[]): TransferBuilder {
+  addEvents(events: OperationEvent[]): TransferBuilder {
     return changetype<TransferBuilder>(super.addEvents(events))
   }
 
@@ -224,16 +178,16 @@ export class TransferBuilder extends IntentBuilder {
    * @returns A new Transfer instance with all configured parameters
    */
   build(): Transfer {
-    return new Transfer(
-      this.chainId,
-      this.transfers,
-      this.maxFees,
-      this.settler,
-      this.user,
-      this.deadline,
-      this.nonce,
-      this.events
-    )
+    return new Transfer(this.chainId, this.transfers, 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
+   * @param feePayer - The fee payer for the intent (optional)
+   */
+  send(maxFee: TokenAmount, feePayer: Address | null = null): void {
+    this.build().send(maxFee, feePayer)
   }
 }
 
@@ -307,48 +261,9 @@ export class TransferData {
  * Represents a Transfer intent for sending tokens to recipients on a blockchain network.
  */
 @json
-export class Transfer extends Intent {
-  public chainId: ChainId
+export class Transfer extends Operation {
   public transfers: TransferData[]
 
-  /**
-   * Creates a simple single-token transfer intent.
-   * @param token - The Token to transfer
-   * @param amount - The amount to transfer
-   * @param recipient - The address to receive the tokens
-   * @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)
-   * @param nonce - The nonce for replay protection (optional)
-   * @returns A new Transfer instance
-   */
-  static create(
-    token: Token,
-    amount: BigInt,
-    recipient: Address,
-    maxFee: BigInt,
-    settler: Address | null = null,
-    user: Address | null = null,
-    deadline: BigInt | null = null,
-    nonce: string | null = null,
-    events: IntentEvent[] | null = null
-  ): Transfer {
-    const transferAmount = TokenAmount.fromBigInt(token, amount)
-    const transferData = TransferData.fromTokenAmount(transferAmount, recipient)
-    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
@@ -362,33 +277,22 @@ export class Transfer extends Intent {
   constructor(
     chainId: ChainId,
     transfers: TransferData[],
-    maxFees: TokenAmount[],
-    settler: Address | null = null,
     user: Address | null = null,
-    deadline: BigInt | null = null,
-    nonce: string | null = null,
-    events: IntentEvent[] | null = null
+    events: OperationEvent[] | null = null
   ) {
-    const fees: MaxFee[] = maxFees.map((fee: TokenAmount) => MaxFee.fromTokenAmount(fee))
-    super(OperationType.Transfer, chainId, fees, settler, user, deadline, nonce, events)
+    super(OperationType.Transfer, chainId, user, 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.chainId = chainId
   }
 
   /**
    * Sends this Transfer intent to the execution environment.
+   * @param maxFee - The max fee to pay for the intent
+   * @param feePayer - The fee payer for the intent (optional)
    */
-  send(): void {
-    environment.transfer(this)
-  }
-
-  /**
-   * Whether the chainId is Solana or not
-   */
-  isSVM(): bool {
-    return this.chainId === ChainId.SOLANA_MAINNET
+  send(maxFee: TokenAmount, feePayer: Address | null = null): void {
+    const intentBuilder = new IntentBuilder().addMaxFee(maxFee).addOperation(this)
+    if (feePayer) intentBuilder.addFeePayer(feePayer)
+    environment.sendIntent(intentBuilder.build())
   }
 }

package/src/intents/index.ts

@@ -1,4 +1,5 @@
 export * from './Call'
 export * from './Intent'
+export * from './Operation'
 export * from './Swap'
 export * from './Transfer'

package/src/storage/storage.ts

@@ -2,7 +2,6 @@ import { environment } from '../environment'
 import { evm } from '../evm'
 import { MIMIC_HELPER_ADDRESS } from '../helpers'
 import { EvmCall, EvmCallBuilder } from '../intents'
-import { TokenAmount } from '../tokens'
 import { Address, Bytes, ChainId, EvmDecodeParam, EvmEncodeParam, Result } from '../types'
 
 const ADDRESS = Address.fromHexString(MIMIC_HELPER_ADDRESS)
@@ -11,7 +10,6 @@ const DEFAULT_CHAIN_ID = ChainId.OPTIMISM
 export namespace storage {
   export function createSetDataCall(
     smartAccount: Address,
-    maxFee: TokenAmount,
     key: string,
     data: Bytes,
     chainId: ChainId = DEFAULT_CHAIN_ID
@@ -20,11 +18,7 @@ export namespace storage {
       '0x1c1bbd37' +
         evm.encode([EvmEncodeParam.fromValue('string', Bytes.fromUTF8(key)), EvmEncodeParam.fromValue('bytes', data)])
     )
-    return EvmCallBuilder.forChain(chainId)
-      .addUser(smartAccount)
-      .addMaxFee(maxFee)
-      .addCall(ADDRESS, encodedData)
-      .build()
+    return EvmCallBuilder.forChain(chainId).addUser(smartAccount).addCall(ADDRESS, encodedData).build()
   }
 
   export function getData(