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

package/src/helpers/strings.ts

@@ -1,5 +1,9 @@
-export function bytesToString(bytes: Uint8Array): string {
-  return String.UTF8.decodeUnsafe(bytes.dataStart, bytes.length)
+import { decode, encode } from 'as-base58/assembly/index'
+
+import { ByteArray } from '../types'
+
+export function bytesToString(bytes: Uint8Array, nullTerminated: bool = false): string {
+  return String.UTF8.decodeUnsafe(bytes.dataStart, bytes.length, nullTerminated)
 }
 
 export function bytesToHexString(bytes: Uint8Array): string {
@@ -8,6 +12,59 @@ export function bytesToHexString(bytes: Uint8Array): string {
   return hex
 }
 
+export function bytesToBase58String(bytes: Uint8Array): string {
+  return encode(bytes)
+}
+
+export function bytesFromBase58String(base58: string): ByteArray {
+  assert(isBase58(base58), `input ${base58} is not valid base58`)
+  return changetype<ByteArray>(decode(base58))
+}
+
+export function stringToBool(str: string): bool {
+  if (str !== 'true' && str !== 'false') throw new Error(`Invalid boolean: ${str}`)
+  return str === 'true'
+}
+
+/**
+ * Workaround for json-as boolean bug:
+ * Converts JSON boolean values (true/false) into their string equivalents ("true"/"false")
+ * without touching occurrences inside JSON strings or keys.
+ *
+ * This function assumes compact JSON (no newlines between the boolean and the delimiter).
+ */
+export function replaceJsonBooleans(json: string): string {
+  return (
+    json
+      // true after ':' (object property values)
+      .replaceAll(':true', ':"true"')
+      .replaceAll(':true,', ':"true",')
+      .replaceAll(':true}', ':"true"}')
+      .replaceAll(':true]', ':"true"]')
+      .replaceAll(': true,', ': "true",')
+      .replaceAll(': true}', ': "true"}')
+      .replaceAll(': true]', ': "true"]')
+      // true in arrays
+      .replaceAll('[true,', '["true",')
+      .replaceAll('[true]', '["true"]')
+      .replaceAll(',true,', ',"true",')
+      .replaceAll(',true]', ',"true"]')
+      // false after ':' (object property values)
+      .replaceAll(':false', ':"false"')
+      .replaceAll(':false,', ':"false",')
+      .replaceAll(':false}', ':"false"}')
+      .replaceAll(':false]', ':"false"]')
+      .replaceAll(': false,', ': "false",')
+      .replaceAll(': false}', ': "false"}')
+      .replaceAll(': false]', ': "false"]')
+      // false in arrays
+      .replaceAll('[false,', '["false",')
+      .replaceAll('[false]', '["false"]')
+      .replaceAll(',false,', ',"false",')
+      .replaceAll(',false]', ',"false"]')
+  )
+}
+
 export function areAllZeros(str: string): boolean {
   for (let i = 0; i < str.length; i++) if (str.charCodeAt(i) !== 48) return false
   return true
@@ -76,12 +133,14 @@ export function normalizeScientificNotation(input: string): string {
   if (newDecimalPos <= 0) {
     const zeros = '0'.repeat(-newDecimalPos)
     return sign + '0.' + zeros + fullDigits
-  } else if (newDecimalPos >= fullDigits.length) {
+  }
+
+  if (newDecimalPos >= fullDigits.length) {
     const zeros = '0'.repeat(newDecimalPos - fullDigits.length)
     return sign + fullDigits + zeros
-  } else {
-    return sign + fullDigits.substring(0, newDecimalPos) + '.' + fullDigits.substring(newDecimalPos)
   }
+
+  return sign + fullDigits.substring(0, newDecimalPos) + '.' + fullDigits.substring(newDecimalPos)
 }
 
 export function isHex(str: string, strict: boolean = false): boolean {
@@ -101,3 +160,21 @@ export function isHex(str: string, strict: boolean = false): boolean {
 
   return true
 }
+
+export function isBase58(str: string): boolean {
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i)
+
+    // Base58 alphabet: digits, letters (not 0IOl)
+    if (
+      (c >= '1'.charCodeAt(0) && c <= '9'.charCodeAt(0)) ||
+      (c >= 'A'.charCodeAt(0) && c <= 'Z'.charCodeAt(0) && c !== 'I'.charCodeAt(0) && c !== 'O'.charCodeAt(0)) ||
+      (c >= 'a'.charCodeAt(0) && c <= 'z'.charCodeAt(0) && c !== 'l'.charCodeAt(0))
+    ) {
+      continue
+    }
+    return false
+  }
+
+  return true
+}

package/src/intents/Call/EvmCall.ts

@@ -0,0 +1,199 @@
+import { environment } from '../../environment'
+import { TokenAmount } from '../../tokens'
+import { Address, BigInt, Bytes, ChainId } from '../../types'
+import { IntentBuilder } from '../Intent'
+import { Operation, OperationBuilder, OperationEvent, OperationType } from '../Operation'
+
+/**
+ * Builder for creating EVM call operations.
+ */
+export class EvmCallBuilder extends OperationBuilder {
+  protected chainId: ChainId
+  protected calls: EvmCallData[] = []
+
+  /**
+   * Creates an EvmCallBuilder for the specified EVM blockchain network.
+   * @param chainId - The blockchain network identifier
+   * @returns A new EvmCallBuilder instance
+   */
+  static forChain(chainId: ChainId): EvmCallBuilder {
+    return new EvmCallBuilder(chainId)
+  }
+
+  /**
+   * Creates a new EvmCallBuilder instance.
+   * @param chainId - The EVM blockchain network identifier
+   */
+  private constructor(chainId: ChainId) {
+    super()
+    this.chainId = chainId
+  }
+
+  /**
+   * Adds a contract call to the operation.
+   * @param target - The contract address to call
+   * @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 {
+    this.calls.push(new EvmCallData(target, data, value))
+    return this
+  }
+
+  /**
+   * Adds multiple contract calls to the operation.
+   * @param calls - The contract calls to add
+   * @returns This EvmCallBuilder instance for method chaining
+   */
+  addCalls(calls: EvmCallData[]): EvmCallBuilder {
+    for (let i = 0; i < calls.length; i++)
+      this.addCall(
+        Address.fromString(calls[i].target),
+        Bytes.fromHexString(calls[i].data),
+        BigInt.fromString(calls[i].value)
+      )
+    return this
+  }
+
+  /**
+   * Adds the calls from another EvmCallBuilder to this EvmCallBuilder.
+   * @param builder - The EvmCallBuilder to add the calls from
+   * @returns This EvmCallBuilder instance for method chaining
+   */
+  addCallsFromBuilder(builder: EvmCallBuilder): EvmCallBuilder {
+    return this.addCalls(builder.getCalls())
+  }
+
+  /**
+   * Adds the calls from multiple EvmCallBuilders to this EvmCallBuilder.
+   * @param builders - The EvmCallBuilders to add the calls from
+   * @returns This EvmCallBuilder instance for method chaining
+   */
+  addCallsFromBuilders(builders: EvmCallBuilder[]): EvmCallBuilder {
+    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(): EvmCallData[] {
+    return this.calls.slice(0)
+  }
+
+  /**
+   * Sets the user address for this operation.
+   * @param user - The user address
+   * @returns This EvmCallBuilder instance for method chaining
+   */
+  addUser(user: Address): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(super.addUser(user))
+  }
+
+  /**
+   * Sets the user address from a string.
+   * @param user - The user address as a hex string
+   * @returns This EvmCallBuilder instance for method chaining
+   */
+  addUserAsString(user: string): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(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 EvmCallBuilder instance for method chaining
+   */
+  addEvent(topic: Bytes, data: Bytes): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(super.addEvent(topic, data))
+  }
+
+  /**
+   * Sets multiple events for the operation.
+   * @param events - The list of events to be added
+   * @returns This EvmCallBuilder instance for method chaining
+   */
+  addEvents(events: OperationEvent[]): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(super.addEvents(events))
+  }
+
+  /**
+   * 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.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 an EVM call operation.
+ * Contains the target address, call data, and value to send.
+ */
+@json
+export class EvmCallData {
+  public target: string
+  public data: string
+  public value: string
+
+  /**
+   * Creates a new EvmCallData instance.
+   * @param target - The contract address to call
+   * @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()
+    this.data = data.toHexString()
+    this.value = value.toString()
+  }
+}
+
+/**
+ * Represents an EVM call operation containing one or more contract calls to be executed.
+ */
+@json
+export class EvmCall extends Operation {
+  public calls: EvmCallData[]
+
+  /**
+   * Creates a new EvmCall operation.
+   * @param chainId - The blockchain network identifier
+   * @param calls - Array of contract calls to execute
+   * @param user - The user address
+   * @param events - The operation events to emit
+   */
+  constructor(
+    chainId: ChainId,
+    calls: EvmCallData[],
+    user: Address | null = null,
+    events: OperationEvent[] | null = null
+  ) {
+    super(OperationType.EvmCall, chainId, user, events)
+    if (calls.length === 0) throw new Error('Call list cannot be empty')
+    this.calls = calls
+  }
+
+  /**
+   * 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(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())
+  }
+}