@mimicprotocol/lib-ts 0.0.1 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @mimicprotocol/lib-ts
 
+## 0.1.0
+
+### Minor Changes
+
+- 45a5f9f: Add operations and dynamic call operation
+
+### Patch Changes
+
+- 45a5f9f: Refactor intents to have operations and bump to runner version v0.1.0
+
 ## 0.0.1
 
 ### Patch Changes

package/constants.js

@@ -1 +1 @@
-export const RUNNER_TARGET_VERSION = '0.0.1'
+export const RUNNER_TARGET_VERSION = '0.1.0'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimicprotocol/lib-ts",
-  "version": "0.0.1",
+  "version": "0.1.0",
   "license": "GPL-3.0",
   "private": false,
   "type": "module",

package/src/environment.ts

@@ -3,7 +3,7 @@ import { JSON } from 'json-as/assembly'
 import { Context, SerializableContext } from './context'
 import { evm } from './evm'
 import { Consensus, ListType, MIMIC_HELPER_ADDRESS } from './helpers'
-import { EvmCall, SvmCall, Swap, Transfer } from './intents'
+import { Intent } from './intents'
 import {
   EvmCallQuery,
   EvmCallQueryResponse,
@@ -23,17 +23,8 @@ import { BlockchainToken, Token, TokenAmount, USD } from './tokens'
 import { Address, BigInt, Bytes, ChainId, EvmDecodeParam, EvmEncodeParam, Result } from './types'
 
 export namespace environment {
-  @external('environment', '_evmCall')
-  declare function _evmCall(params: string): void
-
-  @external('environment', '_svmCall')
-  declare function _svmCall(params: string): void
-
-  @external('environment', '_swap')
-  declare function _swap(params: string): void
-
-  @external('environment', '_transfer')
-  declare function _transfer(params: string): void
+  @external('environment', '_sendIntent')
+  declare function _sendIntent(params: string): void
 
   @external('environment', '_tokenPriceQuery')
   declare function _tokenPriceQuery(params: string): string
@@ -54,35 +45,11 @@ export namespace environment {
   declare function _getContext(): string
 
   /**
-   * Generates a EVM Call intent containing contract calls on the blockchain.
-   * @param call - The EvmCall intent to generate
-   */
-  export function evmCall(call: EvmCall): void {
-    _evmCall(JSON.stringify(call))
-  }
-
-  /**
-   * Generates a SVM Call intent containing contract calls on the blockchain.
-   * @param call - The SvmCall intent to generate
-   */
-  export function svmCall(call: SvmCall): void {
-    _svmCall(JSON.stringify(call))
-  }
-
-  /**
-   * Generates a Swap intent for token exchange operations.
-   * @param swap - The Swap intent to generate
-   */
-  export function swap(swap: Swap): void {
-    _swap(JSON.stringify(swap))
-  }
-
-  /**
-   * Generates a Transfer intent for sending tokens to recipients.
-   * @param transfer - The Transfer intent to generate
+   * Sends an intent containing one or more operations to the execution environment.
+   * @param intent - The intent to send
    */
-  export function transfer(transfer: Transfer): void {
-    _transfer(JSON.stringify(transfer))
+  export function sendIntent(intent: Intent): void {
+    _sendIntent(JSON.stringify(intent))
   }
 
   /**

package/src/intents/Call/EvmCall.ts

@@ -1,18 +1,18 @@
 import { environment } from '../../environment'
 import { 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 EVM Call intents with contract call operations.
- * Allows chaining multiple contract calls and configuring fees and settlement parameters.
+ * Builder for creating EVM call operations.
  */
-export class EvmCallBuilder extends IntentBuilder {
+export class EvmCallBuilder extends OperationBuilder {
   protected chainId: ChainId
   protected calls: EvmCallData[] = []
 
   /**
-   * Creates a EvmCallBuilder for the specified EVM blockchain network.
+   * Creates an EvmCallBuilder for the specified EVM blockchain network.
    * @param chainId - The blockchain network identifier
    * @returns A new EvmCallBuilder instance
    */
@@ -30,10 +30,10 @@ export class EvmCallBuilder extends IntentBuilder {
   }
 
   /**
-   * Adds a contract call to the intent.
+   * Adds a contract call to the operation.
    * @param target - The contract address to call
-   * @param data - The call data (optional, defaults to empty bytes)
-   * @param value - The native token value to send (optional, defaults to zero)
+   * @param data - The call data
+   * @param value - The native token value to send
    * @returns This EvmCallBuilder instance for method chaining
    */
   addCall(target: Address, data: Bytes = Bytes.empty(), value: BigInt = BigInt.zero()): EvmCallBuilder {
@@ -42,7 +42,7 @@ export class EvmCallBuilder extends IntentBuilder {
   }
 
   /**
-   * Adds multiple contract calls to the intent.
+   * Adds multiple contract calls to the operation.
    * @param calls - The contract calls to add
    * @returns This EvmCallBuilder instance for method chaining
    */
@@ -84,34 +84,7 @@ export class EvmCallBuilder extends IntentBuilder {
   }
 
   /**
-   * Sets the settler address for this intent.
-   * @param settler - The settler address as an Address instance
-   * @returns This EvmCallBuilder instance for method chaining
-   */
-  addSettler(settler: Address): EvmCallBuilder {
-    return changetype<EvmCallBuilder>(super.addSettler(settler))
-  }
-
-  /**
-   * Sets the settler address from a string.
-   * @param settler - The settler address as a hex string
-   * @returns This EvmCallBuilder instance for method chaining
-   */
-  addSettlerAsString(settler: string): EvmCallBuilder {
-    return changetype<EvmCallBuilder>(super.addSettlerAsString(settler))
-  }
-
-  /**
-   * Sets the deadline for this intent.
-   * @param deadline - The deadline as a timestamp
-   * @returns This EvmCallBuilder instance for method chaining
-   */
-  addDeadline(deadline: BigInt): EvmCallBuilder {
-    return changetype<EvmCallBuilder>(super.addDeadline(deadline))
-  }
-
-  /**
-   * Sets the user address for this intent.
+   * Sets the user address for this operation.
    * @param user - The user address
    * @returns This EvmCallBuilder instance for method chaining
    */
@@ -129,27 +102,7 @@ export class EvmCallBuilder extends IntentBuilder {
   }
 
   /**
-   * Sets the nonce for this intent.
-   * @param nonce - A unique identifier to prevent replay attacks
-   * @returns This EvmCallBuilder instance for method chaining
-   */
-  addNonce(nonce: string): EvmCallBuilder {
-    return changetype<EvmCallBuilder>(super.addNonce(nonce))
-  }
-
-  /**
-   * Adds a max fee for this intent.
-   * @param fee - The max fee token amount (must be on same chain)
-   * @returns This EvmCallBuilder instance for method chaining
-   */
-  addMaxFee(fee: TokenAmount): EvmCallBuilder {
-    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.
+   * Sets an event for the operation.
    * @param topic - The topic to be indexed in the event
    * @param data - The event data
    * @returns This EvmCallBuilder instance for method chaining
@@ -159,34 +112,34 @@ export class EvmCallBuilder extends IntentBuilder {
   }
 
   /**
-   * Sets multiple events for the intent.
+   * Sets multiple events for the operation.
    * @param events - The list of events to be added
    * @returns This EvmCallBuilder instance for method chaining
    */
-  addEvents(events: IntentEvent[]): EvmCallBuilder {
+  addEvents(events: OperationEvent[]): EvmCallBuilder {
     return changetype<EvmCallBuilder>(super.addEvents(events))
   }
 
   /**
-   * Builds and returns the final EvmCall intent.
+   * Builds and returns the final EvmCall operation.
    * @returns A new EvmCall instance with all configured parameters
    */
   build(): EvmCall {
-    return new EvmCall(
-      this.chainId,
-      this.calls,
-      this.maxFees,
-      this.settler,
-      this.user,
-      this.deadline,
-      this.nonce,
-      this.events
-    )
+    return new EvmCall(this.chainId, this.calls, 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)
   }
 }
 
 /**
- * Represents data for a single contract call within a Call intent.
+ * Represents data for a single contract call within an EVM call operation.
  * Contains the target address, call data, and value to send.
  */
 @json
@@ -198,8 +151,8 @@ export class EvmCallData {
   /**
    * Creates a new EvmCallData instance.
    * @param target - The contract address to call
-   * @param data - The call data (optional, defaults to empty bytes)
-   * @param value - The native token value to send (optional, defaults to zero)
+   * @param data - The call data
+   * @param value - The native token value to send
    */
   constructor(target: Address, data: Bytes = Bytes.empty(), value: BigInt = BigInt.zero()) {
     this.target = target.toString()
@@ -209,75 +162,38 @@ export class EvmCallData {
 }
 
 /**
- * Represents a Call intent containing one or more contract calls to be executed.
+ * Represents an EVM call operation containing one or more contract calls to be executed.
  */
 @json
-export class EvmCall extends Intent {
-  public chainId: ChainId
+export class EvmCall extends Operation {
   public calls: EvmCallData[]
 
   /**
-   * Creates a EvmCall intent with a single contract call.
-   * @param chainId - The blockchain network identifier
-   * @param target - The contract address to call
-   * @param data - The call data
-   * @param maxFee - The max fee to pay for the call intent
-   * @param value - The native token value to send (optional, defaults to zero)
-   * @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(
-    chainId: ChainId,
-    target: Address,
-    data: Bytes,
-    maxFee: TokenAmount,
-    value: BigInt = BigInt.zero(),
-    settler: Address | null = null,
-    user: Address | null = null,
-    deadline: BigInt | null = null,
-    nonce: string | null = null,
-    events: IntentEvent[] | null = null
-  ): EvmCall {
-    const callData = new EvmCallData(target, data, value)
-    return new EvmCall(chainId, [callData], [maxFee], settler, user, deadline, nonce, events)
-  }
-
-  /**
-   * Creates a new EvmCall intent.
+   * Creates a new EvmCall operation.
    * @param chainId - The blockchain network identifier
    * @param calls - Array of contract calls 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)
+   * @param user - The user address
+   * @param events - The operation events to emit
    */
   constructor(
     chainId: ChainId,
     calls: EvmCallData[],
-    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.EvmCall, chainId, fees, settler, user, deadline, nonce, events)
+    super(OperationType.EvmCall, chainId, user, events)
     if (calls.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.calls = calls
-    this.chainId = chainId
   }
 
   /**
-   * Sends this EvmCall intent to the execution environment.
+   * Sends this EvmCall operation wrapped in an intent.
+   * @param maxFee - The max fee to pay for the intent
+   * @param feePayer - The fee payer for the intent (optional)
    */
-  public send(): void {
-    environment.evmCall(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/EvmDynamicCall.ts

@@ -0,0 +1,272 @@
+import { environment } from '../../environment'
+import { evm } from '../../evm'
+import { TokenAmount } from '../../tokens'
+import { Address, BigInt, Bytes, ChainId, EvmEncodeParam } from '../../types'
+import { IntentBuilder } from '../Intent'
+import { Operation, OperationBuilder, OperationEvent, OperationType } from '../Operation'
+
+export enum EvmDynamicArgKind {
+  Literal = 0,
+  Variable = 1,
+}
+
+/**
+ * Builder for creating EVM dynamic call operations.
+ */
+export class EvmDynamicCallBuilder extends OperationBuilder {
+  protected chainId: ChainId
+  protected calls: EvmDynamicCallData[] = []
+
+  /**
+   * Creates an EvmDynamicCallBuilder for the specified EVM blockchain network.
+   * @param chainId - The blockchain network identifier
+   * @returns A new EvmDynamicCallBuilder instance
+   */
+  static forChain(chainId: ChainId): EvmDynamicCallBuilder {
+    return new EvmDynamicCallBuilder(chainId)
+  }
+
+  /**
+   * Creates a new EvmDynamicCallBuilder instance.
+   * @param chainId - The EVM blockchain network identifier
+   */
+  private constructor(chainId: ChainId) {
+    super()
+    this.chainId = chainId
+  }
+
+  /**
+   * Adds a dynamic contract call to the operation.
+   * @param target - The contract address to call
+   * @param selector - The function selector to call
+   * @param args - The dynamic call arguments
+   * @param value - The native token value to send
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addCall(
+    target: Address,
+    selector: Bytes,
+    args: EvmDynamicArg[] = [],
+    value: BigInt = BigInt.zero()
+  ): EvmDynamicCallBuilder {
+    this.calls.push(new EvmDynamicCallData(target, selector, args, value))
+    return this
+  }
+
+  /**
+   * Adds multiple dynamic contract calls to the operation.
+   * @param calls - The contract calls to add
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addCalls(calls: EvmDynamicCallData[]): EvmDynamicCallBuilder {
+    for (let i = 0; i < calls.length; i++) {
+      this.addCall(
+        Address.fromString(calls[i].target),
+        Bytes.fromHexString(calls[i].selector),
+        calls[i].arguments,
+        BigInt.fromString(calls[i].value)
+      )
+    }
+    return this
+  }
+
+  /**
+   * Adds the calls from another EvmDynamicCallBuilder to this EvmDynamicCallBuilder.
+   * @param builder - The EvmDynamicCallBuilder to add the calls from
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addCallsFromBuilder(builder: EvmDynamicCallBuilder): EvmDynamicCallBuilder {
+    return this.addCalls(builder.getCalls())
+  }
+
+  /**
+   * Adds the calls from multiple EvmDynamicCallBuilders to this EvmDynamicCallBuilder.
+   * @param builders - The EvmDynamicCallBuilders to add the calls from
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addCallsFromBuilders(builders: EvmDynamicCallBuilder[]): EvmDynamicCallBuilder {
+    for (let i = 0; i < builders.length; i++) this.addCallsFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the calls array.
+   * @returns A copy of the calls array
+   */
+  getCalls(): EvmDynamicCallData[] {
+    return this.calls.slice(0)
+  }
+
+  /**
+   * Sets the user address for this operation.
+   * @param user - The user address
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addUser(user: Address): EvmDynamicCallBuilder {
+    return changetype<EvmDynamicCallBuilder>(super.addUser(user))
+  }
+
+  /**
+   * Sets the user address from a string.
+   * @param user - The user address as a hex string
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addUserAsString(user: string): EvmDynamicCallBuilder {
+    return changetype<EvmDynamicCallBuilder>(super.addUserAsString(user))
+  }
+
+  /**
+   * Sets an event for the operation.
+   * @param topic - The topic to be indexed in the event
+   * @param data - The event data
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addEvent(topic: Bytes, data: Bytes): EvmDynamicCallBuilder {
+    return changetype<EvmDynamicCallBuilder>(super.addEvent(topic, data))
+  }
+
+  /**
+   * Sets multiple events for the operation.
+   * @param events - The list of events to be added
+   * @returns This EvmDynamicCallBuilder instance for method chaining
+   */
+  addEvents(events: OperationEvent[]): EvmDynamicCallBuilder {
+    return changetype<EvmDynamicCallBuilder>(super.addEvents(events))
+  }
+
+  /**
+   * Builds and returns the final EvmDynamicCall operation.
+   * @returns A new EvmDynamicCall instance with all configured parameters
+   */
+  build(): EvmDynamicCall {
+    return new EvmDynamicCall(this.chainId, this.calls, 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)
+  }
+}
+
+/**
+ * Represents a single dynamic argument in a dynamic call.
+ */
+@json
+export class EvmDynamicArg {
+  public kind: EvmDynamicArgKind
+  public data: string
+  public isDynamic: bool
+
+  /**
+   * Creates a literal dynamic argument from ABI-encoded parameters.
+   * @param parameters - The ABI parameters to encode as a literal argument
+   * @param isDynamic - Whether the resolved argument is ABI-dynamic
+   * @returns A new literal dynamic argument
+   */
+  static literal(parameters: EvmEncodeParam[], isDynamic: bool): EvmDynamicArg {
+    return new EvmDynamicArg(EvmDynamicArgKind.Literal, Bytes.fromHexString(evm.encode(parameters)), isDynamic)
+  }
+
+  /**
+   * Creates a variable reference dynamic argument.
+   * @param opIndex - The referenced operation index
+   * @param subIndex - The referenced output index within the operation
+   * @param isDynamic - Whether the resolved argument is ABI-dynamic
+   * @returns A new variable dynamic argument
+   */
+  static variable(opIndex: u32, subIndex: u32, isDynamic: bool): EvmDynamicArg {
+    return new EvmDynamicArg(
+      EvmDynamicArgKind.Variable,
+      Bytes.fromHexString(
+        evm.encode([
+          EvmEncodeParam.fromValue('uint256', BigInt.fromU32(opIndex)),
+          EvmEncodeParam.fromValue('uint256', BigInt.fromU32(subIndex)),
+        ])
+      ),
+      isDynamic
+    )
+  }
+
+  /**
+   * Creates a new EvmDynamicArg instance.
+   * @param kind - The argument resolution strategy
+   * @param data - The ABI-encoded argument data
+   * @param isDynamic - Whether the resolved argument is ABI-dynamic
+   */
+  constructor(kind: EvmDynamicArgKind, data: Bytes, isDynamic: bool) {
+    this.kind = kind
+    this.data = data.toHexString()
+    this.isDynamic = isDynamic
+  }
+}
+
+/**
+ * Represents data for a single dynamic contract call within an EVM dynamic call operation.
+ */
+@json
+export class EvmDynamicCallData {
+  public target: string
+  public value: string
+  public selector: string
+  public arguments: EvmDynamicArg[]
+
+  /**
+   * Creates a new EvmDynamicCallData instance.
+   * @param target - The contract address to call
+   * @param selector - The function selector to call
+   * @param args - The dynamic arguments for the call
+   * @param value - The native token value to send
+   */
+  constructor(target: Address, selector: Bytes, args: EvmDynamicArg[] = [], value: BigInt = BigInt.zero()) {
+    if (selector.length !== 4) throw new Error('Selector must be 4 bytes')
+    this.target = target.toString()
+    this.value = value.toString()
+    this.selector = selector.toHexString()
+    this.arguments = new Array<EvmDynamicArg>(args.length)
+    for (let i = 0; i < args.length; i++) {
+      const argument = args[i]
+      this.arguments[i] = new EvmDynamicArg(argument.kind, Bytes.fromHexString(argument.data), argument.isDynamic)
+    }
+  }
+}
+
+/**
+ * Represents an EVM dynamic call operation containing one or more dynamic contract calls.
+ */
+@json
+export class EvmDynamicCall extends Operation {
+  public calls: EvmDynamicCallData[]
+
+  /**
+   * Creates a new EvmDynamicCall operation.
+   * @param chainId - The blockchain network identifier
+   * @param calls - Array of dynamic contract calls to execute
+   * @param user - The user address
+   * @param events - The operation events to emit
+   */
+  constructor(
+    chainId: ChainId,
+    calls: EvmDynamicCallData[],
+    user: Address | null = null,
+    events: OperationEvent[] | null = null
+  ) {
+    super(OperationType.EvmDynamicCall, chainId, user, events)
+    if (calls.length === 0) throw new Error('Call list cannot be empty')
+    this.calls = calls
+  }
+
+  /**
+   * Sends this EvmDynamicCall operation wrapped in an intent.
+   * @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())
+  }
+}