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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimicprotocol/lib-ts",
-  "version": "0.0.1-rc.21",
+  "version": "0.0.1-rc.23",
   "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,31 +1,30 @@
-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 {
-  private chainId: ChainId
-  private calls: CallData[] = []
+export class EvmCallBuilder extends IntentBuilder {
+  protected chainId: ChainId
+  protected 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) {
+  private constructor(chainId: ChainId) {
     super()
     this.chainId = chainId
   }
@@ -35,73 +34,115 @@ 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()): EvmCallBuilder {
+    this.calls.push(new EvmCallData(target, data, value))
+    return this
+  }
+
+  /**
+   * Adds multiple contract calls to the intent.
+   * @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
    */
-  addCall(target: Address, data: Bytes = Bytes.empty(), value: BigInt = BigInt.zero()): CallBuilder {
-    this.calls.push(new CallData(target, data, value))
+  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 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 +152,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 +190,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 +212,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 +240,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 +257,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 +266,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 +275,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,278 @@
+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 {
+  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 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 {
+  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 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/intents/Swap.ts

@@ -9,10 +9,10 @@ import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from './Int
  * Supports both single-chain and cross-chain swaps with multiple input and output tokens.
  */
 export class SwapBuilder extends IntentBuilder {
-  private sourceChain: ChainId
-  private destinationChain: ChainId
-  private tokensIn: TokenIn[] = []
-  private tokensOut: TokenOut[] = []
+  protected sourceChain: ChainId
+  protected destinationChain: ChainId
+  protected tokensIn: SwapTokenIn[] = []
+  protected tokensOut: SwapTokenOut[] = []
 
   /**
    * Creates a SwapBuilder for a single-chain swap.
@@ -38,7 +38,7 @@ export class SwapBuilder extends IntentBuilder {
    * @param sourceChain - The source blockchain network identifier
    * @param destinationChain - The destination blockchain network identifier
    */
-  constructor(sourceChain: ChainId, destinationChain: ChainId) {
+  private constructor(sourceChain: ChainId, destinationChain: ChainId) {
     super()
     this.sourceChain = sourceChain
     this.destinationChain = destinationChain
@@ -49,7 +49,7 @@ export class SwapBuilder extends IntentBuilder {
    * @param tokenIn - The token input configuration
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokenIn(tokenIn: TokenIn): SwapBuilder {
+  addTokenIn(tokenIn: SwapTokenIn): SwapBuilder {
     this.tokensIn.push(tokenIn)
     return this
   }
@@ -59,17 +59,44 @@ export class SwapBuilder extends IntentBuilder {
    * @param tokensIn - Array of token input configurations
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokensIn(tokensIn: TokenIn[]): SwapBuilder {
+  addTokensIn(tokensIn: SwapTokenIn[]): SwapBuilder {
     for (let i = 0; i < tokensIn.length; i++) this.addTokenIn(tokensIn[i])
     return this
   }
 
+  /**
+   * Adds the tokens in from another SwapBuilder to this SwapBuilder.
+   * @param builder - The SwapBuilder to add the tokens in from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensInFromBuilder(builder: SwapBuilder): SwapBuilder {
+    return this.addTokensIn(builder.getTokensIn())
+  }
+
+  /**
+   * Adds the tokens in from multiple SwapBuilders to this SwapBuilder.
+   * @param builders - The SwapBuilders to add the tokens in from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensInFromBuilders(builders: SwapBuilder[]): SwapBuilder {
+    for (let i = 0; i < builders.length; i++) this.addTokensInFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the tokens in array.
+   * @returns A copy of the tokens in array
+   */
+  getTokensIn(): SwapTokenIn[] {
+    return this.tokensIn.slice(0)
+  }
+
   /**
    * Adds an output token to the swap.
    * @param tokenOut - The token output configuration
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokenOut(tokenOut: TokenOut): SwapBuilder {
+  addTokenOut(tokenOut: SwapTokenOut): SwapBuilder {
     this.tokensOut.push(tokenOut)
     return this
   }
@@ -79,11 +106,38 @@ export class SwapBuilder extends IntentBuilder {
    * @param tokensOut - Array of token output configurations
    * @returns This SwapBuilder instance for method chaining
    */
-  addTokensOut(tokensOut: TokenOut[]): SwapBuilder {
+  addTokensOut(tokensOut: SwapTokenOut[]): SwapBuilder {
     for (let i = 0; i < tokensOut.length; i++) this.addTokenOut(tokensOut[i])
     return this
   }
 
+  /**
+   * Adds the tokens out from another SwapBuilder to this SwapBuilder.
+   * @param builder - The SwapBuilder to add the tokens out from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensOutFromBuilder(builder: SwapBuilder): SwapBuilder {
+    return this.addTokensOut(builder.getTokensOut())
+  }
+
+  /**
+   * Adds the tokens out from multiple SwapBuilders to this SwapBuilder.
+   * @param builders - The SwapBuilders to add the tokens out from
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addTokensOutFromBuilders(builders: SwapBuilder[]): SwapBuilder {
+    for (let i = 0; i < builders.length; i++) this.addTokensOutFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the tokens out array.
+   * @returns A copy of the tokens out array
+   */
+  getTokensOut(): SwapTokenOut[] {
+    return this.tokensOut.slice(0)
+  }
+
   /**
    * Adds an input token from a TokenAmount.
    * @param tokenAmount - The token amount to swap from (must be on source chain)
@@ -91,7 +145,7 @@ export class SwapBuilder extends IntentBuilder {
    */
   addTokenInFromTokenAmount(tokenAmount: TokenAmount): SwapBuilder {
     if (!tokenAmount.token.hasChain(this.sourceChain)) throw new Error('Tokens in must be on the same chain')
-    return this.addTokenIn(TokenIn.fromTokenAmount(tokenAmount))
+    return this.addTokenIn(SwapTokenIn.fromTokenAmount(tokenAmount))
   }
 
   /**
@@ -112,7 +166,7 @@ export class SwapBuilder extends IntentBuilder {
    */
   addTokenInFromStringDecimal(token: Token, amount: string): SwapBuilder {
     if (!token.hasChain(this.sourceChain)) throw new Error('Tokens in must be on the source chain')
-    return this.addTokenIn(TokenIn.fromStringDecimal(token, amount))
+    return this.addTokenIn(SwapTokenIn.fromStringDecimal(token, amount))
   }
 
   /**
@@ -124,7 +178,7 @@ export class SwapBuilder extends IntentBuilder {
   addTokenOutFromTokenAmount(tokenAmount: TokenAmount, recipient: Address): SwapBuilder {
     if (!tokenAmount.token.hasChain(this.destinationChain))
       throw new Error('Tokens out must be on the destination chain')
-    return this.addTokenOut(TokenOut.fromTokenAmount(tokenAmount, recipient))
+    return this.addTokenOut(SwapTokenOut.fromTokenAmount(tokenAmount, recipient))
   }
 
   /**
@@ -147,7 +201,7 @@ export class SwapBuilder extends IntentBuilder {
    */
   addTokenOutFromStringDecimal(token: Token, amount: string, recipient: Address): SwapBuilder {
     if (!token.hasChain(this.destinationChain)) throw new Error('Tokens out must be on the destination chain')
-    return this.addTokenOut(TokenOut.fromStringDecimal(token, amount, recipient))
+    return this.addTokenOut(SwapTokenOut.fromStringDecimal(token, amount, recipient))
   }
 
   /**
@@ -261,7 +315,7 @@ export class SwapBuilder extends IntentBuilder {
  * Specifies the token address and amount to be swapped.
  */
 @json
-export class TokenIn {
+export class SwapTokenIn {
   token: string
   amount: string
 
@@ -270,8 +324,8 @@ export class TokenIn {
    * @param tokenAmount - The token amount to swap from
    * @returns A new TokenIn instance
    */
-  static fromTokenAmount(tokenAmount: TokenAmount): TokenIn {
-    return new TokenIn(tokenAmount.token.address, tokenAmount.amount)
+  static fromTokenAmount(tokenAmount: TokenAmount): SwapTokenIn {
+    return new SwapTokenIn(tokenAmount.token.address, tokenAmount.amount)
   }
 
   /**
@@ -280,7 +334,7 @@ export class TokenIn {
    * @param amount - The amount as a whole number
    * @returns A new TokenIn instance
    */
-  static fromI32(token: Token, amount: i32): TokenIn {
+  static fromI32(token: Token, amount: i32): SwapTokenIn {
     return this.fromTokenAmount(TokenAmount.fromI32(token, amount))
   }
 
@@ -290,7 +344,7 @@ export class TokenIn {
    * @param amount - The amount in the token's smallest unit
    * @returns A new TokenIn instance
    */
-  static fromBigInt(token: Token, amount: BigInt): TokenIn {
+  static fromBigInt(token: Token, amount: BigInt): SwapTokenIn {
     return this.fromTokenAmount(TokenAmount.fromBigInt(token, amount))
   }
 
@@ -300,7 +354,7 @@ export class TokenIn {
    * @param amount - The amount as a decimal string
    * @returns A new TokenIn instance
    */
-  static fromStringDecimal(token: Token, amount: string): TokenIn {
+  static fromStringDecimal(token: Token, amount: string): SwapTokenIn {
     return this.fromTokenAmount(TokenAmount.fromStringDecimal(token, amount))
   }
 
@@ -320,7 +374,7 @@ export class TokenIn {
  * Specifies the token address, minimum amount to receive, and recipient.
  */
 @json
-export class TokenOut {
+export class SwapTokenOut {
   token: string
   minAmount: string
   recipient: string
@@ -331,8 +385,8 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromTokenAmount(tokenAmount: TokenAmount, recipient: Address): TokenOut {
-    return new TokenOut(tokenAmount.token.address, tokenAmount.amount, recipient)
+  static fromTokenAmount(tokenAmount: TokenAmount, recipient: Address): SwapTokenOut {
+    return new SwapTokenOut(tokenAmount.token.address, tokenAmount.amount, recipient)
   }
 
   /**
@@ -342,7 +396,7 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromI32(token: Token, amount: i32, recipient: Address): TokenOut {
+  static fromI32(token: Token, amount: i32, recipient: Address): SwapTokenOut {
     return this.fromTokenAmount(TokenAmount.fromI32(token, amount), recipient)
   }
 
@@ -353,7 +407,7 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromBigInt(token: Token, amount: BigInt, recipient: Address): TokenOut {
+  static fromBigInt(token: Token, amount: BigInt, recipient: Address): SwapTokenOut {
     return this.fromTokenAmount(TokenAmount.fromBigInt(token, amount), recipient)
   }
 
@@ -364,7 +418,7 @@ export class TokenOut {
    * @param recipient - The address to receive the tokens
    * @returns A new TokenOut instance
    */
-  static fromStringDecimal(token: Token, amount: string, recipient: Address): TokenOut {
+  static fromStringDecimal(token: Token, amount: string, recipient: Address): SwapTokenOut {
     return this.fromTokenAmount(TokenAmount.fromStringDecimal(token, amount), recipient)
   }
 
@@ -413,8 +467,8 @@ export class Swap extends Intent {
   ): Swap {
     const context = environment.getContext()
     const recipient = user || context.user
-    const swapIn = TokenIn.fromBigInt(tokenIn, amountIn)
-    const swapOut = TokenOut.fromBigInt(tokenOut, minAmountOut, recipient)
+    const swapIn = SwapTokenIn.fromBigInt(tokenIn, amountIn)
+    const swapOut = SwapTokenOut.fromBigInt(tokenOut, minAmountOut, recipient)
     return new Swap(chainId, [swapIn], [swapOut], chainId, settler, user, deadline, nonce, [], events)
   }
 
@@ -432,8 +486,8 @@ export class Swap extends Intent {
    */
   constructor(
     public sourceChain: ChainId,
-    public tokensIn: TokenIn[],
-    public tokensOut: TokenOut[],
+    public tokensIn: SwapTokenIn[],
+    public tokensOut: SwapTokenOut[],
     public destinationChain: ChainId,
     settler: Address | null = null,
     user: Address | null = null,

package/src/intents/Transfer.ts

@@ -9,8 +9,8 @@ import { Intent, IntentBuilder, IntentEvent, MaxFee, OperationType } from './Int
  * Supports multiple transfers within a single transaction on the same chain.
  */
 export class TransferBuilder extends IntentBuilder {
-  private chainId: ChainId
-  private transfers: TransferData[] = []
+  protected chainId: ChainId
+  protected transfers: TransferData[] = []
 
   /**
    * Creates a TransferBuilder for a specific chain.
@@ -25,7 +25,7 @@ export class TransferBuilder extends IntentBuilder {
    * Creates a new TransferBuilder instance.
    * @param chainId - The blockchain network identifier
    */
-  constructor(chainId: ChainId) {
+  private constructor(chainId: ChainId) {
     super()
     this.chainId = chainId
   }
@@ -50,6 +50,33 @@ export class TransferBuilder extends IntentBuilder {
     return this
   }
 
+  /**
+   * Adds the transfers from another TransferBuilder to this TransferBuilder.
+   * @param builder - The TransferBuilder to add the transfers from
+   * @returns This TransferBuilder instance for method chaining
+   */
+  addTransfersFromBuilder(builder: TransferBuilder): TransferBuilder {
+    return this.addTransfers(builder.getTransfers())
+  }
+
+  /**
+   * Adds the transfers from multiple TransferBuilders to this TransferBuilder.
+   * @param builders - The TransferBuilders to add the transfers from
+   * @returns This TransferBuilder instance for method chaining
+   */
+  addTransfersFromBuilders(builders: TransferBuilder[]): TransferBuilder {
+    for (let i = 0; i < builders.length; i++) this.addTransfersFromBuilder(builders[i])
+    return this
+  }
+
+  /**
+   * Returns a copy of the transfers array.
+   * @returns A copy of the transfers array
+   */
+  getTransfers(): TransferData[] {
+    return this.transfers.slice(0)
+  }
+
   /**
    * Adds a transfer from a TokenAmount.
    * @param tokenAmount - The token amount to transfer (must be on same chain)

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)
+  }
+}