@mimicprotocol/lib-ts 0.0.1-rc.21 → 0.0.1-rc.22

package/package.json

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

package/src/environment.ts

@@ -2,7 +2,7 @@ import { JSON } from 'json-as/assembly'
 
 import { Context, SerializableContext } from './context'
 import { ListType } from './helpers'
-import { Swap, Transfer, Call } from './intents'
+import { Swap, Transfer, EvmCall, SvmCall } from './intents'
 import {
   Call as CallQuery,
   GetAccountsInfo,
@@ -17,10 +17,14 @@ import {
 } from './queries'
 import { BlockchainToken, Token, TokenAmount, USD } from './tokens'
 import { Address, BigInt, ChainId } from './types'
+import { log } from './log'
 
 export namespace environment {
-  @external('environment', '_call')
-  declare function _call(params: string): void
+  @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
@@ -47,11 +51,19 @@ export namespace environment {
   declare function _getContext(): string
 
   /**
-   * Generates a Call intent containing contract calls on the blockchain.
-   * @param call - The Call intent to generate
+   * 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 call(call: Call): void {
-    _call(JSON.stringify(call))
+  export function svmCall(call: SvmCall): void {
+    _svmCall(JSON.stringify(call))
   }
 
   /**

package/src/intents/{Call.ts → Call/EvmCall.ts}

@@ -1,29 +1,28 @@
-import { environment } from '../environment'
-import { TokenAmount } from '../tokens'
-import { Address, BigInt, Bytes, ChainId } from '../types'
-
-import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from './Intent'
+import { environment } from '../../environment'
+import { TokenAmount } from '../../tokens'
+import { Address, BigInt, Bytes, ChainId } from '../../types'
+import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from '../Intent'
 
 /**
- * Builder for creating Call intents with contract call operations.
+ * Builder for creating EVM Call intents with contract call operations.
  * Allows chaining multiple contract calls and configuring fees and settlement parameters.
  */
-export class CallBuilder extends IntentBuilder {
+export class EvmCallBuilder extends IntentBuilder {
   private chainId: ChainId
-  private calls: CallData[] = []
+  private calls: EvmCallData[] = []
 
   /**
-   * Creates a CallBuilder for the specified blockchain network.
+   * Creates a EvmCallBuilder for the specified EVM blockchain network.
    * @param chainId - The blockchain network identifier
-   * @returns A new CallBuilder instance
+   * @returns A new EvmCallBuilder instance
    */
-  static forChain(chainId: ChainId): CallBuilder {
-    return new CallBuilder(chainId)
+  static forChain(chainId: ChainId): EvmCallBuilder {
+    return new EvmCallBuilder(chainId)
   }
 
   /**
-   * Creates a new CallBuilder instance.
-   * @param chainId - The blockchain network identifier
+   * Creates a new EvmCallBuilder instance.
+   * @param chainId - The EVM blockchain network identifier
    */
   constructor(chainId: ChainId) {
     super()
@@ -35,73 +34,73 @@ export class CallBuilder extends IntentBuilder {
    * @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)
-   * @returns This CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addCall(target: Address, data: Bytes = Bytes.empty(), value: BigInt = BigInt.zero()): CallBuilder {
-    this.calls.push(new CallData(target, data, value))
+  addCall(target: Address, data: Bytes = Bytes.empty(), value: BigInt = BigInt.zero()): EvmCallBuilder {
+    this.calls.push(new EvmCallData(target, data, value))
     return this
   }
 
   /**
    * Sets the settler address for this intent.
    * @param settler - The settler address as an Address instance
-   * @returns This CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addSettler(settler: Address): CallBuilder {
-    return changetype<CallBuilder>(super.addSettler(settler))
+  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 CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addSettlerAsString(settler: string): CallBuilder {
-    return changetype<CallBuilder>(super.addSettlerAsString(settler))
+  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 CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addDeadline(deadline: BigInt): CallBuilder {
-    return changetype<CallBuilder>(super.addDeadline(deadline))
+  addDeadline(deadline: BigInt): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(super.addDeadline(deadline))
   }
 
   /**
    * Sets the user address for this intent.
    * @param user - The user address
-   * @returns This CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addUser(user: Address): CallBuilder {
-    return changetype<CallBuilder>(super.addUser(user))
+  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 CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addUserAsString(user: string): CallBuilder {
-    return changetype<CallBuilder>(super.addUserAsString(user))
+  addUserAsString(user: string): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(super.addUserAsString(user))
   }
 
   /**
    * Sets the nonce for this intent.
    * @param nonce - A unique identifier to prevent replay attacks
-   * @returns This CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addNonce(nonce: string): CallBuilder {
-    return changetype<CallBuilder>(super.addNonce(nonce))
+  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 CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addMaxFee(fee: TokenAmount): CallBuilder {
+  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
@@ -111,27 +110,27 @@ export class CallBuilder extends IntentBuilder {
    * Sets an event for the intent.
    * @param topic - The topic to be indexed in the event
    * @param data - The event data
-   * @returns This CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addEvent(topic: Bytes, data: Bytes): CallBuilder {
-    return changetype<CallBuilder>(super.addEvent(topic, data))
+  addEvent(topic: Bytes, data: Bytes): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(super.addEvent(topic, data))
   }
 
   /**
    * Sets multiple events for the intent.
    * @param events - The list of events to be added
-   * @returns This CallBuilder instance for method chaining
+   * @returns This EvmCallBuilder instance for method chaining
    */
-  addEvents(events: IntentEvent[]): CallBuilder {
-    return changetype<CallBuilder>(super.addEvents(events))
+  addEvents(events: IntentEvent[]): EvmCallBuilder {
+    return changetype<EvmCallBuilder>(super.addEvents(events))
   }
 
   /**
-   * Builds and returns the final Call intent.
-   * @returns A new Call instance with all configured parameters
+   * Builds and returns the final EvmCall intent.
+   * @returns A new EvmCall instance with all configured parameters
    */
-  build(): Call {
-    return new Call(
+  build(): EvmCall {
+    return new EvmCall(
       this.chainId,
       this.calls,
       this.maxFees,
@@ -149,13 +148,13 @@ export class CallBuilder extends IntentBuilder {
  * Contains the target address, call data, and value to send.
  */
 @json
-export class CallData {
+export class EvmCallData {
   public target: string
   public data: string
   public value: string
 
   /**
-   * Creates a new CallData instance.
+   * 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)
@@ -171,12 +170,12 @@ export class CallData {
  * Represents a Call intent containing one or more contract calls to be executed.
  */
 @json
-export class Call extends Intent {
+export class EvmCall extends Intent {
   public chainId: ChainId
-  public calls: CallData[]
+  public calls: EvmCallData[]
 
   /**
-   * Creates a Call intent with a single contract call.
+   * 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
@@ -199,13 +198,13 @@ export class Call extends Intent {
     deadline: BigInt | null = null,
     nonce: string | null = null,
     events: IntentEvent[] | null = null
-  ): Call {
-    const callData = new CallData(target, data, value)
-    return new Call(chainId, [callData], [maxFee], settler, user, deadline, nonce, events)
+  ): EvmCall {
+    const callData = new EvmCallData(target, data, value)
+    return new EvmCall(chainId, [callData], [maxFee], settler, user, deadline, nonce, events)
   }
 
   /**
-   * Creates a new Call intent.
+   * Creates a new EvmCall intent.
    * @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
@@ -216,7 +215,7 @@ export class Call extends Intent {
    */
   constructor(
     chainId: ChainId,
-    calls: CallData[],
+    calls: EvmCallData[],
     maxFees: TokenAmount[],
     settler: Address | null = null,
     user: Address | null = null,
@@ -225,7 +224,7 @@ export class Call extends Intent {
     events: IntentEvent[] | null = null
   ) {
     const fees: MaxFee[] = maxFees.map((fee: TokenAmount) => MaxFee.fromTokenAmount(fee))
-    super(OperationType.Call, chainId, fees, settler, user, deadline, nonce, events)
+    super(OperationType.EvmCall, chainId, fees, settler, user, deadline, nonce, 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')
 
@@ -234,9 +233,9 @@ export class Call extends Intent {
   }
 
   /**
-   * Sends this Call intent to the execution environment.
+   * Sends this EvmCall intent to the execution environment.
    */
   public send(): void {
-    environment.call(this)
+    environment.evmCall(this)
   }
 }

package/src/intents/Call/SvmCall.ts

@@ -0,0 +1,233 @@
+import { environment } from '../../environment'
+import { TokenAmount } from '../../tokens'
+import { Address, BigInt, Bytes, ChainId } from '../../types'
+import { SvmAccountMeta } from '../../types/svm/SvmAccountMeta'
+import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from '../Intent'
+
+/**
+ * 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 {
+  private chainId: ChainId
+  private instructions: SvmInstruction[] = []
+
+  /**
+   * Creates a new SvmCallBuilder instance.
+   */
+  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
+  }
+
+  /**
+   * 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
+   * @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 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
+   * @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: IntentEvent[]): 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.maxFees, this.settler, this.user, this.deadline, this.nonce, this.events)
+  }
+}
+
+export class SvmInstructionBuilder {
+  private programId: Address = Address.zero(32)
+  private accountsMeta: SvmAccountMeta[] = []
+  private 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 SvmInstruction.create(this.programId, this.accountsMeta, this.data)
+  }
+}
+
+@json
+export class SvmInstruction {
+  constructor(
+    public programId: string,
+    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
+  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
+   * @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[],
+    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)
+    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.
+   */
+  public send(): void {
+    environment.svmCall(this)
+  }
+}

package/src/intents/Call/index.ts

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

package/src/intents/Intent.ts

@@ -7,7 +7,8 @@ import { Address, BigInt, Bytes, ChainId } from '../types'
 export enum OperationType {
   Swap,
   Transfer,
-  Call,
+  EvmCall,
+  SvmCall,
 }
 
 const DEFAULT_DEADLINE = 5 * 60 // 5 minutes in seconds

package/src/tokens/BlockchainToken.ts

@@ -1,8 +1,8 @@
-import { Address, ChainId } from '../types'
+import { Address, ChainId, JSON } from '../types'
 
 import { ERC20Token } from './ERC20Token'
 import { SPLToken } from './SPLToken'
-import { Token } from './Token'
+import { SerializableToken, Token } from './Token'
 
 /**
  * Represents a token on a blockchain network
@@ -49,6 +49,16 @@ export abstract class BlockchainToken extends Token {
     return BlockchainToken.fromAddress(Address.fromString(address), chainId, decimals, symbol)
   }
 
+  /**
+   * Creates a BlockchainToken from a serialized string.
+   * @param serialized - The serialized string to parse
+   * @returns A new BlockchainToken instance
+   */
+  static fromSerializable(serialized: string): BlockchainToken {
+    const data = JSON.parse<SerializableToken>(serialized)
+    return BlockchainToken.fromString(data.address, data.chainId)
+  }
+
   /**
    * Creates a new BlockchainToken instance
    * @param address The token address in the corresponding blockchain (contract, mint, etc.)

package/src/tokens/Token.ts

@@ -81,3 +81,11 @@ export abstract class Token {
    */
   abstract toString(): string
 }
+
+@json
+export class SerializableToken {
+  constructor(
+    public address: string,
+    public chainId: i32
+  ) {}
+}

package/src/tokens/TokenAmount.ts

@@ -1,7 +1,8 @@
 import { environment } from '../environment'
-import { BigInt } from '../types'
+import { BigInt, JSON } from '../types'
 
-import { Token } from './Token'
+import { BlockchainToken } from './BlockchainToken'
+import { SerializableToken, Token } from './Token'
 import { USD } from './USD'
 
 /**
@@ -50,6 +51,17 @@ export class TokenAmount {
     return new TokenAmount(token, amount)
   }
 
+  /**
+   * Creates a TokenAmount from a serialized string.
+   * @param serialized - The serialized string to parse
+   * @returns A new TokenAmount instance
+   */
+  static fromSerializable(serialized: string): TokenAmount {
+    const data = JSON.parse<SerializableTokenAmount>(serialized)
+    const token = BlockchainToken.fromString(data.token.address, data.token.chainId)
+    return TokenAmount.fromStringDecimal(token, data.amount)
+  }
+
   /**
    * Creates a new TokenAmount instance.
    * @param token - The token this amount represents
@@ -228,3 +240,11 @@ export class TokenAmount {
     if (!this.token.equals(other)) throw new Error(`Cannot ${action} different tokens`)
   }
 }
+
+@json
+export class SerializableTokenAmount {
+  constructor(
+    public token: SerializableToken,
+    public amount: string
+  ) {}
+}

package/src/types/Address.ts

@@ -15,10 +15,10 @@ import { Option } from './Option'
  */
 export class Address extends Bytes {
   /**
-   * Returns an EVM zero address (20 bytes filled with zeroes).
+   * Returns a zero address (default 20 bytes filled with zeroes).
    */
-  static zero(): Address {
-    const self = new ByteArray(20)
+  static zero(length: i32 = 20): Address {
+    const self = new ByteArray(length)
     return changetype<Address>(self)
   }
 

package/src/types/svm/SvmAccountMeta.ts

@@ -0,0 +1,28 @@
+import { Address } from '../Address'
+
+@json
+export class SvmAccountMeta {
+  constructor(
+    public pubkey: string,
+    public isWritable: bool = false,
+    public isSigner: bool = false
+  ) {}
+
+  writable(): SvmAccountMeta {
+    this.isWritable = true
+    return this
+  }
+
+  signer(): SvmAccountMeta {
+    this.isSigner = true
+    return this
+  }
+
+  static fromAddress(pubkey: Address): SvmAccountMeta {
+    return new SvmAccountMeta(pubkey.toString())
+  }
+
+  static fromString(pubkey: string): SvmAccountMeta {
+    return new SvmAccountMeta(pubkey)
+  }
+}