@mimicprotocol/lib-ts 0.0.1 → 0.1.0

package/src/intents/Call/SvmCall.ts

@@ -1,14 +1,15 @@
 import { environment } from '../../environment'
 import { TokenAmount } from '../../tokens'
-import { Address, BigInt, Bytes, ChainId } from '../../types'
+import { Address, Bytes, ChainId } from '../../types'
 import { SvmAccountMeta } from '../../types/svm/SvmAccountMeta'
-import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from '../Intent'
+import { IntentBuilder } from '../Intent'
+import { Operation, OperationBuilder, OperationEvent, OperationType } from '../Operation'
 
 /**
  * Builder for creating SVM Call intents with program call operations.
  * Allows chaining multiple calls and configuring fees and settlement parameters.
  */
-export class SvmCallBuilder extends IntentBuilder {
+export class SvmCallBuilder extends OperationBuilder {
   protected chainId: ChainId
   protected instructions: SvmInstruction[] = []
 
@@ -75,33 +76,6 @@ export class SvmCallBuilder extends IntentBuilder {
     return this.instructions.slice(0)
   }
 
-  /**
-   * Sets the settler address for this intent.
-   * @param settler - The settler address as an Address instance
-   * @returns This SvmCallBuilder instance for method chaining
-   */
-  addSettler(settler: Address): SvmCallBuilder {
-    return changetype<SvmCallBuilder>(super.addSettler(settler))
-  }
-
-  /**
-   * Sets the settler address from a string.
-   * @param settler - The settler address as a hex string
-   * @returns This SvmCallBuilder instance for method chaining
-   */
-  addSettlerAsString(settler: string): SvmCallBuilder {
-    return changetype<SvmCallBuilder>(super.addSettlerAsString(settler))
-  }
-
-  /**
-   * Sets the deadline for this intent.
-   * @param deadline - The deadline as a timestamp
-   * @returns This SvmCallBuilder instance for method chaining
-   */
-  addDeadline(deadline: BigInt): SvmCallBuilder {
-    return changetype<SvmCallBuilder>(super.addDeadline(deadline))
-  }
-
   /**
    * Sets the user address for this intent.
    * @param user - The user address
@@ -120,26 +94,6 @@ export class SvmCallBuilder extends IntentBuilder {
     return changetype<SvmCallBuilder>(super.addUserAsString(user))
   }
 
-  /**
-   * Sets the nonce for this intent.
-   * @param nonce - A unique identifier to prevent replay attacks
-   * @returns This SvmCallBuilder instance for method chaining
-   */
-  addNonce(nonce: string): SvmCallBuilder {
-    return changetype<SvmCallBuilder>(super.addNonce(nonce))
-  }
-
-  /**
-   * Adds a max fee for this intent.
-   * @param fee - The max fee token amount (must be on same chain)
-   * @returns This SvmCallBuilder instance for method chaining
-   */
-  addMaxFee(fee: TokenAmount): SvmCallBuilder {
-    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
@@ -155,7 +109,7 @@ export class SvmCallBuilder extends IntentBuilder {
    * @param events - The list of events to be added
    * @returns This SvmCallBuilder instance for method chaining
    */
-  addEvents(events: IntentEvent[]): SvmCallBuilder {
+  addEvents(events: OperationEvent[]): SvmCallBuilder {
     return changetype<SvmCallBuilder>(super.addEvents(events))
   }
 
@@ -164,7 +118,16 @@ export class SvmCallBuilder extends IntentBuilder {
    * @returns A new SvmCall instance with all configured parameters
    */
   build(): SvmCall {
-    return new SvmCall(this.instructions, this.maxFees, this.settler, this.user, this.deadline, this.nonce, this.events)
+    return new SvmCall(this.instructions, 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)
   }
 }
 
@@ -193,7 +156,7 @@ export class SvmInstructionBuilder {
   }
 
   instruction(): SvmInstruction {
-    return SvmInstruction.create(this.programId, this.accountsMeta, this.data)
+    return new SvmInstruction(this.programId.toBase58String(), this.accountsMeta, this.data.toHexString())
   }
 }
 
@@ -204,44 +167,15 @@ export class SvmInstruction {
     public accountsMeta: SvmAccountMeta[],
     public data: string
   ) {}
-
-  static create(programId: Address, accountsMeta: SvmAccountMeta[], data: Bytes): SvmInstruction {
-    return new SvmInstruction(programId.toBase58String(), accountsMeta, data.toHexString())
-  }
 }
 
 /**
  * Represents a SVM Call intent containing one or more program calls to be executed.
  */
 @json
-export class SvmCall extends Intent {
-  public chainId: ChainId
+export class SvmCall extends Operation {
   public instructions: SvmInstruction[]
 
-  /**
-   * Creates a SvmCall intent with a single program call.
-   * @param maxFee - The max fee to pay for the call 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 Call instance
-   */
-  static create(
-    programId: Address,
-    accountsMeta: SvmAccountMeta[],
-    data: Bytes,
-    maxFee: TokenAmount,
-    settler: Address | null = null,
-    user: Address | null = null,
-    deadline: BigInt | null = null,
-    nonce: string | null = null,
-    events: IntentEvent[] | null = null
-  ): SvmCall {
-    const instruction = SvmInstruction.create(programId, accountsMeta, data)
-    return new SvmCall([instruction], [maxFee], settler, user, deadline, nonce, events)
-  }
-
   /**
    * Creates a new SvmCall intent.
    * @param instructions - Array of instructions to execute
@@ -251,28 +185,20 @@ export class SvmCall extends Intent {
    * @param deadline - The deadline timestamp (optional)
    * @param nonce - The nonce for replay protection (optional)
    */
-  constructor(
-    instructions: SvmInstruction[],
-    maxFees: TokenAmount[],
-    settler: Address | null = null,
-    user: Address | null = null,
-    deadline: BigInt | null = null,
-    nonce: string | null = null,
-    events: IntentEvent[] | null = null
-  ) {
-    const fees: MaxFee[] = maxFees.map((fee: TokenAmount) => MaxFee.fromTokenAmount(fee))
-    super(OperationType.SvmCall, ChainId.SOLANA_MAINNET, fees, settler, user, deadline, nonce, events)
+  constructor(instructions: SvmInstruction[], user: Address | null = null, events: OperationEvent[] | null = null) {
+    super(OperationType.SvmCall, ChainId.SOLANA_MAINNET, user, events)
     if (instructions.length === 0) throw new Error('Call list cannot be empty')
-    if (maxFees.length == 0) throw new Error('At least a max fee must be specified')
-
     this.instructions = instructions
-    this.chainId = ChainId.SOLANA_MAINNET
   }
 
   /**
    * Sends this SvmCall intent to the execution environment.
+   * @param maxFee - The max fee to pay for the intent
+   * @param feePayer - The fee payer for the intent (optional)
    */
-  public send(): void {
-    environment.svmCall(this)
+  public 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/Call/index.ts

@@ -1,2 +1,3 @@
 export * from './EvmCall'
+export * from './EvmDynamicCall'
 export * from './SvmCall'

package/src/intents/Intent.ts

@@ -1,28 +1,185 @@
 import { environment } from '../environment'
 import { evm } from '../evm'
 import { NULL_ADDRESS } from '../helpers'
-import { Token, TokenAmount } from '../tokens'
+import { BlockchainToken, Token, TokenAmount } from '../tokens'
 import { Address, BigInt, Bytes, ChainId } from '../types'
+import { SvmAccountMeta } from '../types/svm/SvmAccountMeta'
 
-export enum OperationType {
-  Swap,
-  Transfer,
-  EvmCall,
-  SvmCall,
-}
+import { EvmCall, EvmCallData } from './Call/EvmCall'
+import { EvmDynamicArg, EvmDynamicCall, EvmDynamicCallData } from './Call/EvmDynamicCall'
+import { SvmCall, SvmInstruction } from './Call/SvmCall'
+import { Operation, OperationBuilder, OperationEvent, OperationType } from './Operation'
+import { Swap, SwapTokenIn, SwapTokenOut } from './Swap'
+import { Transfer, TransferData } from './Transfer'
 
 const DEFAULT_DEADLINE = 5 * 60 // 5 minutes in seconds
 
 /**
- * Base builder for creating intents.
+ * Builder for creating intents with one or more operations.
  */
-export abstract class IntentBuilder {
-  protected user: Address | null = null
+export class IntentBuilder {
   protected settler: Address | null = null
+  protected feePayer: Address | null = null
   protected deadline: BigInt | null = null
   protected nonce: string | null = null
   protected maxFees: TokenAmount[] = []
-  protected events: IntentEvent[] = []
+  protected operations: Operation[] = []
+
+  /**
+   * Adds an operation to this intent.
+   * @param operation - The operation to add
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addOperation(operation: Operation): IntentBuilder {
+    this.operations.push(operation)
+    return this
+  }
+
+  /**
+   * Adds multiple operations to this intent.
+   * @param operations - The operations to add
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addOperations(operations: Operation[]): IntentBuilder {
+    for (let i = 0; i < operations.length; i++) this.addOperation(operations[i])
+    return this
+  }
+
+  /**
+   * Adds a built operation builder to this intent.
+   * @param operationBuilder - The operation builder to build and add
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addOperationBuilder(operationBuilder: OperationBuilder): IntentBuilder {
+    return this.addOperation(operationBuilder.build())
+  }
+
+  /**
+   * Adds multiple built operation builders to this intent.
+   * @param operationBuilders - The operation builders to build and add
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addOperationsBuilders(operationBuilders: OperationBuilder[]): IntentBuilder {
+    for (let i = 0; i < operationBuilders.length; i++) this.addOperationBuilder(operationBuilders[i])
+    return this
+  }
+
+  /**
+   * Adds a single EVM call operation to this intent from raw parameters.
+   * @param chainId - The blockchain network identifier
+   * @param target - The contract address to call
+   * @param data - The encoded call data
+   * @param value - The native token value to send
+   * @param user - The user that should execute the operation
+   * @param events - The operation events to emit
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addEvmCallOperation(
+    chainId: ChainId,
+    target: Address,
+    data: Bytes = Bytes.empty(),
+    value: BigInt = BigInt.zero(),
+    user: Address | null = null,
+    events: OperationEvent[] | null = null
+  ): IntentBuilder {
+    return this.addOperation(new EvmCall(chainId, [new EvmCallData(target, data, value)], user, events))
+  }
+
+  /**
+   * Adds a single EVM dynamic call operation to this intent from raw parameters.
+   * @param chainId - The blockchain network identifier
+   * @param target - The contract address to call
+   * @param selector - The function selector to call
+   * @param args - The dynamic arguments to resolve at execution time
+   * @param value - The native token value to send
+   * @param user - The user that should execute the operation
+   * @param events - The operation events to emit
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addEvmDynamicCallOperation(
+    chainId: ChainId,
+    target: Address,
+    selector: Bytes,
+    args: EvmDynamicArg[] = [],
+    value: BigInt = BigInt.zero(),
+    user: Address | null = null,
+    events: OperationEvent[] | null = null
+  ): IntentBuilder {
+    return this.addOperation(
+      new EvmDynamicCall(chainId, [new EvmDynamicCallData(target, selector, args, value)], user, events)
+    )
+  }
+
+  /**
+   * Adds a single swap operation to this intent from raw parameters.
+   * @param sourceChain - The source blockchain network identifier
+   * @param tokenIn - The token to swap from
+   * @param amountIn - The amount to swap from
+   * @param tokenOut - The token to receive
+   * @param minAmountOut - The minimum amount to receive
+   * @param recipient - The recipient of the output token
+   * @param destinationChain - The destination blockchain network identifier
+   * @param user - The user that should execute the operation
+   * @param events - The operation events to emit
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addSwapOperation(
+    sourceChain: ChainId,
+    tokenIn: Token,
+    amountIn: BigInt,
+    tokenOut: Token,
+    minAmountOut: BigInt,
+    recipient: Address,
+    destinationChain: ChainId = sourceChain,
+    user: Address | null = null,
+    events: OperationEvent[] | null = null
+  ): IntentBuilder {
+    const swapIn = SwapTokenIn.fromBigInt(tokenIn, amountIn)
+    const swapOut = SwapTokenOut.fromBigInt(tokenOut, minAmountOut, recipient)
+    return this.addOperation(new Swap(sourceChain, [swapIn], [swapOut], destinationChain, user, events))
+  }
+
+  /**
+   * Adds a single transfer operation to this intent from raw parameters.
+   * @param token - The token to transfer
+   * @param amount - The amount to transfer
+   * @param recipient - The recipient of the transfer
+   * @param user - The user that should execute the operation
+   * @param events - The operation events to emit
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addTransferOperation(
+    token: Token,
+    amount: BigInt,
+    recipient: Address,
+    user: Address | null = null,
+    events: OperationEvent[] | null = null
+  ): IntentBuilder {
+    if (!(token instanceof BlockchainToken)) throw new Error('Transfer token must be a blockchain token')
+    const transferAmount = TokenAmount.fromBigInt(token, amount)
+    const transferData = TransferData.fromTokenAmount(transferAmount, recipient)
+    const chainId = changetype<BlockchainToken>(token).chainId
+    return this.addOperation(new Transfer(chainId, [transferData], user, events))
+  }
+
+  /**
+   * Adds a single SVM call operation to this intent from raw parameters.
+   * @param programId - The program address to call
+   * @param accountsMeta - The accounts metadata for the instruction
+   * @param data - The encoded instruction data
+   * @param user - The user that should execute the operation
+   * @param events - The operation events to emit
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addSvmCallOperation(
+    programId: Address,
+    accountsMeta: SvmAccountMeta[],
+    data: Bytes,
+    user: Address | null = null,
+    events: OperationEvent[] | null = null
+  ): IntentBuilder {
+    return this.addOperation(new SvmCall([SvmInstruction.create(programId, accountsMeta, data)], user, events))
+  }
 
   /**
    * Sets the settler address for this intent.
@@ -44,32 +201,32 @@ export abstract class IntentBuilder {
   }
 
   /**
-   * Sets the deadline for this intent.
-   * @param deadline - The deadline as a timestamp
+   * Sets the fee payer address for this intent.
+   * @param feePayer - The fee payer address as an Address instance
    * @returns This IntentBuilder instance for method chaining
    */
-  addDeadline(deadline: BigInt): IntentBuilder {
-    this.deadline = deadline
+  addFeePayer(feePayer: Address): IntentBuilder {
+    this.feePayer = feePayer
     return this
   }
 
   /**
-   * Sets the user address for this intent.
-   * @param user - The user address
+   * Sets the fee payer address from a string.
+   * @param feePayer - The fee payer address as a hex string
    * @returns This IntentBuilder instance for method chaining
    */
-  addUser(user: Address): IntentBuilder {
-    this.user = user
-    return this
+  addFeePayerAsString(feePayer: string): IntentBuilder {
+    return this.addFeePayer(Address.fromString(feePayer))
   }
 
   /**
-   * Sets the user address from a string.
-   * @param user - The user address as a hex string
+   * Sets the deadline for this intent.
+   * @param deadline - The deadline as a timestamp
    * @returns This IntentBuilder instance for method chaining
    */
-  addUserAsString(user: string): IntentBuilder {
-    return this.addUser(Address.fromString(user))
+  addDeadline(deadline: BigInt): IntentBuilder {
+    this.deadline = deadline
+    return this
   }
 
   /**
@@ -83,41 +240,29 @@ export abstract class IntentBuilder {
   }
 
   /**
-   * Sets an event for the intent.
-   * @param topic - The topic to be indexed in the event
-   * @param data - The event data
+   * Adds a max fee for this intent.
+   * @param fee - The max fee token amount
    * @returns This IntentBuilder instance for method chaining
    */
-  addEvent(topic: Bytes, data: Bytes): IntentBuilder {
-    const event = new IntentEvent(topic, data)
-    this.events.push(event)
+  addMaxFee(fee: TokenAmount): IntentBuilder {
+    this.maxFees.push(fee)
     return this
   }
 
   /**
-   * Sets multiple events for the intent.
-   * @param events - The list of events to be added
-   * @returns This IntentBuilder instance for method chaining
+   * Builds and returns the final intent.
+   * @returns A new intent
    */
-  addEvents(events: IntentEvent[]): IntentBuilder {
-    for (let i = 0; i < events.length; i++) {
-      this.events.push(events[i])
-    }
-    return this
+  build(): Intent {
+    return new Intent(this.maxFees, this.settler, this.feePayer, this.deadline, this.nonce, this.operations)
   }
 
   /**
-   * 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
+   * Builds and sends the final intent.
    */
-  abstract build(): Intent
+  send(): void {
+    this.build().send()
+  }
 }
 
 /**
@@ -179,74 +324,68 @@ export class MaxFee {
   }
 }
 
+let INTENT_INDEX: u32 = 0
+
 /**
- * Represents an intent event.
- * Specifies the topic and data for the event. The topic is an indexed parameter for the EVM events.
+ * Represents a sendable intent containing one or more operations plus intent-level metadata.
  */
 @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 {
-  public op: OperationType
-  public settler: string
-  public user: string
-  public deadline: string
-  public nonce: string
-  public maxFees: MaxFee[]
-  public events: IntentEvent[]
+export class Intent {
+  public settler: string = ''
+  public feePayer: string = ''
+  public deadline: string = ''
+  public nonce: string = ''
+  public maxFees: MaxFee[] = []
+  public operations: Operation[]
 
   /**
    * 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,
-    events: IntentEvent[] | null
+   * @param maxFees - The list of max fees to pay for the intent
+   * @param settler - The settler address
+   * @param feePayer - The fee payer address
+   * @param deadline - The deadline timestamp
+   * @param nonce - The nonce for replay protection
+   * @param operations - The operations to execute
+   */
+  constructor(
+    maxFees: TokenAmount[] | null = null,
+    settler: Address | null = null,
+    feePayer: Address | null = null,
+    deadline: BigInt | null = null,
+    nonce: string | null = null,
+    operations: Operation[] | null = null
   ) {
     const context = environment.getContext()
-    this.op = op
-    this.maxFees = maxFees || []
-    this.settler = settler ? settler.toString() : context.findSettler(chainId).toString()
+    this.operations = operations || []
+    if (this.operations.length === 0) throw new Error('Operation list cannot be empty')
+
+    const defaultChainId = this.operations[0].chainId
+    for (let i = 0; i < this.operations.length; i++) {
+      const operation = this.operations[i]
+
+      if (operation.chainId !== defaultChainId) throw new Error('All operations must have the same chainId')
+
+      if (operation.opType === OperationType.CrossChainSwap) {
+        if (this.operations.length > 1) throw new Error('Cross-chain swap must be the only operation in an intent')
+      }
+    }
+
+    this.maxFees = maxFees ? maxFees.map((fee: TokenAmount) => MaxFee.fromTokenAmount(fee)) : []
+    this.settler = settler ? settler.toString() : context.findSettler(defaultChainId).toString()
+    this.feePayer = feePayer ? feePayer.toString() : context.user.toString()
     this.deadline = deadline ? deadline.toString() : (context.timestamp / 1000 + DEFAULT_DEADLINE).toString()
-    this.user = user ? user.toString() : context.user.toString()
-    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')
+    if (!this.feePayer || this.feePayer == NULL_ADDRESS) throw new Error('A fee payer must be specified')
   }
 
   /**
    * Sends this intent to the execution environment.
    */
-  abstract send(): void
+  send(): void {
+    environment.sendIntent(this)
+  }
 }