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

package/src/intents/Call/SvmCall.ts

@@ -0,0 +1,204 @@
+import { environment } from '../../environment'
+import { TokenAmount } from '../../tokens'
+import { Address, Bytes, ChainId } from '../../types'
+import { SvmAccountMeta } from '../../types/svm/SvmAccountMeta'
+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 OperationBuilder {
+  protected chainId: ChainId
+  protected instructions: SvmInstruction[] = []
+
+  /**
+   * Creates a SvmCallBuilder for Solana mainnet.
+   * @returns A new SvmCallBuilder instance
+   */
+  static forChain(): SvmCallBuilder {
+    return new SvmCallBuilder()
+  }
+
+  /**
+   * Creates a new SvmCallBuilder instance.
+   */
+  private constructor() {
+    super()
+    this.chainId = ChainId.SOLANA_MAINNET
+  }
+
+  /**
+   * Adds an instruction to the intent.
+   * @param instruction - The instruction to add
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addInstruction(instruction: SvmInstruction): SvmCallBuilder {
+    this.instructions.push(instruction)
+    return this
+  }
+
+  /**
+   * Adds multiple instructions to the intent.
+   * @param instructions - The instructions to add
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addInstructions(instructions: SvmInstruction[]): SvmCallBuilder {
+    for (let i = 0; i < instructions.length; i++) this.addInstruction(instructions[i])
+    return this
+  }
+
+  /**
+   * Adds the instructions from another SvmCallBuilder to this SvmCallBuilder.
+   * @param builder - The SvmCallBuilder to add the instructions from
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addInstructionsFromBuilder(builder: SvmCallBuilder): SvmCallBuilder {
+    return this.addInstructions(builder.getInstructions())
+  }
+
+  /**
+   * Adds the instructions from multiple SvmCallBuilders to this SvmCallBuilder.
+   * @param builders - The SvmCallBuilders to add the instructions from
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addInstructionsFromBuilders(builders: SvmCallBuilder[]): SvmCallBuilder {
+    for (let i = 0; i < builders.length; i++) this.addInstructionsFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the instructions array.
+   * @returns A copy of the instructions array
+   */
+  getInstructions(): SvmInstruction[] {
+    return this.instructions.slice(0)
+  }
+
+  /**
+   * Sets the user address for this intent.
+   * @param user - The user address
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addUser(user: Address): SvmCallBuilder {
+    return changetype<SvmCallBuilder>(super.addUser(user))
+  }
+
+  /**
+   * Sets the user address from a string.
+   * @param user - The user address as a hex string
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addUserAsString(user: string): SvmCallBuilder {
+    return changetype<SvmCallBuilder>(super.addUserAsString(user))
+  }
+
+  /**
+   * Sets an event for the intent.
+   * @param topic - The topic to be indexed in the event
+   * @param data - The event data
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addEvent(topic: Bytes, data: Bytes): SvmCallBuilder {
+    return changetype<SvmCallBuilder>(super.addEvent(topic, data))
+  }
+
+  /**
+   * Sets multiple events for the intent.
+   * @param events - The list of events to be added
+   * @returns This SvmCallBuilder instance for method chaining
+   */
+  addEvents(events: OperationEvent[]): SvmCallBuilder {
+    return changetype<SvmCallBuilder>(super.addEvents(events))
+  }
+
+  /**
+   * Builds and returns the final SvmCall intent.
+   * @returns A new SvmCall instance with all configured parameters
+   */
+  build(): SvmCall {
+    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)
+  }
+}
+
+export class SvmInstructionBuilder {
+  protected programId: Address = Address.zero(32)
+  protected accountsMeta: SvmAccountMeta[] = []
+  protected data: Bytes = Bytes.empty()
+
+  setProgram(programId: Address): SvmInstructionBuilder {
+    this.programId = programId
+    return this
+  }
+
+  setAccounts(accountsMeta: SvmAccountMeta[]): SvmInstructionBuilder {
+    this.accountsMeta = accountsMeta
+    return this
+  }
+
+  setDataFromBytes(data: Bytes): SvmInstructionBuilder {
+    this.data = data
+    return this
+  }
+
+  setDataFromHex(data: string): SvmInstructionBuilder {
+    return this.setDataFromBytes(Bytes.fromHexString(data))
+  }
+
+  instruction(): SvmInstruction {
+    return new SvmInstruction(this.programId.toBase58String(), this.accountsMeta, this.data.toHexString())
+  }
+}
+
+@json
+export class SvmInstruction {
+  constructor(
+    public programId: string,
+    public accountsMeta: SvmAccountMeta[],
+    public data: string
+  ) {}
+}
+
+/**
+ * Represents a SVM Call intent containing one or more program calls to be executed.
+ */
+@json
+export class SvmCall extends Operation {
+  public instructions: SvmInstruction[]
+
+  /**
+   * Creates a new SvmCall intent.
+   * @param instructions - Array of instructions to execute
+   * @param maxFees - The list of max fees 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)
+   */
+  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')
+    this.instructions = instructions
+  }
+
+  /**
+   * 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(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

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

package/src/intents/Intent.ts

@@ -1,79 +1,391 @@
 import { environment } from '../environment'
 import { evm } from '../evm'
 import { NULL_ADDRESS } from '../helpers'
-import { Address, BigInt } from '../types'
+import { BlockchainToken, Token, TokenAmount } from '../tokens'
+import { Address, BigInt, Bytes, ChainId } from '../types'
+import { SvmAccountMeta } from '../types/svm/SvmAccountMeta'
 
-export enum OperationType {
-  Swap,
-  Transfer,
-  Call,
-}
+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
 
-export abstract class IntentBuilder {
-  protected user: Address | null = null
+/**
+ * Builder for creating intents with one or more operations.
+ */
+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 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.
+   * @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))
   }
 
-  addDeadline(deadline: BigInt): IntentBuilder {
-    this.deadline = deadline
+  /**
+   * 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
+   */
+  addFeePayer(feePayer: Address): IntentBuilder {
+    this.feePayer = feePayer
     return this
   }
 
-  addUser(user: Address): IntentBuilder {
-    this.user = user
-    return this
+  /**
+   * 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
+   */
+  addFeePayerAsString(feePayer: string): IntentBuilder {
+    return this.addFeePayer(Address.fromString(feePayer))
   }
 
-  addUserAsString(user: string): IntentBuilder {
-    return this.addUser(Address.fromString(user))
+  /**
+   * 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 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
   }
 
-  abstract build(): Intent
+  /**
+   * Adds a max fee for this intent.
+   * @param fee - The max fee token amount
+   * @returns This IntentBuilder instance for method chaining
+   */
+  addMaxFee(fee: TokenAmount): IntentBuilder {
+    this.maxFees.push(fee)
+    return this
+  }
+
+  /**
+   * Builds and returns the final intent.
+   * @returns A new intent
+   */
+  build(): Intent {
+    return new Intent(this.maxFees, this.settler, this.feePayer, this.deadline, this.nonce, this.operations)
+  }
+
+  /**
+   * Builds and sends the final intent.
+   */
+  send(): void {
+    this.build().send()
+  }
+}
+
+/**
+ * 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()
+  }
 }
 
 let INTENT_INDEX: u32 = 0
+
+/**
+ * Represents a sendable intent containing one or more operations plus intent-level metadata.
+ */
 @json
-export abstract class Intent {
-  public op: OperationType
-  public settler: string
-  public user: string
-  public deadline: string
-  public nonce: string
-
-  protected constructor(
-    op: OperationType,
-    settler: Address | null,
-    user: Address | null,
-    deadline: BigInt | null,
-    nonce: string | null
+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 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.settler = settler ? settler.toString() : context.settler.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.nonce = nonce ? nonce : evm.keccak(`${context.configId}${context.timestamp}${++INTENT_INDEX}`)
+    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')
   }
 
-  abstract send(): void
+  /**
+   * Sends this intent to the execution environment.
+   */
+  send(): void {
+    environment.sendIntent(this)
+  }
 }