@mimicprotocol/lib-ts 0.0.1-rc.11 → 0.0.1-rc.13

package/README.md

@@ -53,9 +53,9 @@ $ yarn
 Here’s an example of how to use the library in a Mimic task:
 
 ```ts
-import { environment, Token } from '@mimicprotocol/lib-ts'
+import { environment, ERC20Token } from '@mimicprotocol/lib-ts'
 
-const USDC = Token.fromString('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', 1)
+const USDC = ERC20Token.fromString('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', 1)
 
 environment.getPrice(USDC, new Date(1744818017000))
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mimicprotocol/lib-ts",
-  "version": "0.0.1-rc.11",
+  "version": "0.0.1-rc.13",
   "license": "GPL-3.0",
   "private": false,
   "type": "module",
@@ -19,8 +19,9 @@
     "assemblyscript": "0.27.36"
   },
   "dependencies": {
+    "as-base58": "^0.1.1",
     "eslint-config-mimic": "^0.0.3",
     "json-as": "1.1.7",
     "visitor-as": "0.11.4"
   }
-}
+}

package/src/chains/Arbitrum.ts

@@ -1,14 +1,14 @@
-import { Token } from '../tokens'
+import { ERC20Token } from '../tokens/ERC20Token'
 import { ChainId } from '../types'
 
 /* eslint-disable no-secrets/no-secrets */
 
 export namespace Arbitrum {
   export const CHAIN_ID = ChainId.ARBITRUM
-  export const ETH = Token.native(CHAIN_ID)
-  export const USDC = Token.fromString('0xaf88d065e77c8cC2239327C5EDb3A432268e5831', CHAIN_ID, 6, 'USDC')
-  export const USDT = Token.fromString('0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9', CHAIN_ID, 6, 'USDT')
-  export const DAI = Token.fromString('0xda10009cbd5d07dd0cecc66161fc93d7c9000da1', CHAIN_ID, 18, 'DAI')
-  export const WBTC = Token.fromString('0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f', CHAIN_ID, 8, 'WBTC')
-  export const WETH = Token.fromString('0x82af49447d8a07e3bd95bd0d56f35241523fbab1', CHAIN_ID, 18, 'WETH')
+  export const ETH = ERC20Token.native(CHAIN_ID)
+  export const USDC = ERC20Token.fromString('0xaf88d065e77c8cC2239327C5EDb3A432268e5831', CHAIN_ID, 6, 'USDC')
+  export const USDT = ERC20Token.fromString('0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9', CHAIN_ID, 6, 'USDT')
+  export const DAI = ERC20Token.fromString('0xda10009cbd5d07dd0cecc66161fc93d7c9000da1', CHAIN_ID, 18, 'DAI')
+  export const WBTC = ERC20Token.fromString('0x2f2a2543b76a4166549f7aab2e75bef0aefc5b0f', CHAIN_ID, 8, 'WBTC')
+  export const WETH = ERC20Token.fromString('0x82af49447d8a07e3bd95bd0d56f35241523fbab1', CHAIN_ID, 18, 'WETH')
 }

package/src/chains/Base.ts

@@ -1,14 +1,14 @@
-import { Token } from '../tokens'
+import { ERC20Token } from '../tokens'
 import { ChainId } from '../types'
 
 /* eslint-disable no-secrets/no-secrets */
 
 export namespace Base {
   export const CHAIN_ID = ChainId.BASE
-  export const ETH = Token.native(CHAIN_ID)
-  export const USDC = Token.fromString('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', CHAIN_ID, 6, 'USDC')
-  export const USDT = Token.fromString('0xfde4c96c8593536e31f229ea8f37b2ada2699bb2', CHAIN_ID, 6, 'USDT')
-  export const DAI = Token.fromString('0x50c5725949a6f0c72e6c4a641f24049a917db0cb', CHAIN_ID, 18, 'DAI')
-  export const WBTC = Token.fromString('0x0555e30da8f98308edb960aa94c0db47230d2b9c', CHAIN_ID, 8, 'WBTC')
-  export const WETH = Token.fromString('0x4200000000000000000000000000000000000006', CHAIN_ID, 18, 'WETH')
+  export const ETH = ERC20Token.native(CHAIN_ID)
+  export const USDC = ERC20Token.fromString('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', CHAIN_ID, 6, 'USDC')
+  export const USDT = ERC20Token.fromString('0xfde4c96c8593536e31f229ea8f37b2ada2699bb2', CHAIN_ID, 6, 'USDT')
+  export const DAI = ERC20Token.fromString('0x50c5725949a6f0c72e6c4a641f24049a917db0cb', CHAIN_ID, 18, 'DAI')
+  export const WBTC = ERC20Token.fromString('0x0555e30da8f98308edb960aa94c0db47230d2b9c', CHAIN_ID, 8, 'WBTC')
+  export const WETH = ERC20Token.fromString('0x4200000000000000000000000000000000000006', CHAIN_ID, 18, 'WETH')
 }

package/src/chains/Ethereum.ts

@@ -1,12 +1,12 @@
-import { Token } from '../tokens'
+import { ERC20Token } from '../tokens'
 import { ChainId } from '../types'
 
 export namespace Ethereum {
   export const CHAIN_ID = ChainId.ETHEREUM
-  export const ETH = Token.native(CHAIN_ID)
-  export const USDC = Token.fromString('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', CHAIN_ID, 6, 'USDC')
-  export const USDT = Token.fromString('0xdac17f958d2ee523a2206206994597c13d831ec7', CHAIN_ID, 6, 'USDT')
-  export const DAI = Token.fromString('0x6b175474e89094c44da98b954eedeac495271d0f', CHAIN_ID, 18, 'DAI')
-  export const WBTC = Token.fromString('0x2260fac5e5542a773aa44fbcfedf7c193bc2c599', CHAIN_ID, 8, 'WBTC')
-  export const WETH = Token.fromString('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', CHAIN_ID, 18, 'WETH')
+  export const ETH = ERC20Token.native(CHAIN_ID)
+  export const USDC = ERC20Token.fromString('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', CHAIN_ID, 6, 'USDC')
+  export const USDT = ERC20Token.fromString('0xdac17f958d2ee523a2206206994597c13d831ec7', CHAIN_ID, 6, 'USDT')
+  export const DAI = ERC20Token.fromString('0x6b175474e89094c44da98b954eedeac495271d0f', CHAIN_ID, 18, 'DAI')
+  export const WBTC = ERC20Token.fromString('0x2260fac5e5542a773aa44fbcfedf7c193bc2c599', CHAIN_ID, 8, 'WBTC')
+  export const WETH = ERC20Token.fromString('0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', CHAIN_ID, 18, 'WETH')
 }

package/src/chains/Gnosis.ts

@@ -1,14 +1,14 @@
-import { Token } from '../tokens'
+import { ERC20Token } from '../tokens'
 import { ChainId } from '../types'
 
 /* eslint-disable no-secrets/no-secrets */
 
 export namespace Gnosis {
   export const CHAIN_ID = ChainId.GNOSIS
-  export const xDAI = Token.native(CHAIN_ID)
-  export const USDC = Token.fromString('0x2a22f9c3b484c3629090feed35f17ff8f88f76f0', CHAIN_ID, 6, 'USDC')
-  export const USDT = Token.fromString('0x4ecaba5870353805a9f068101a40e0f32ed605c6', CHAIN_ID, 6, 'USDT')
-  export const WXDAI = Token.fromString('0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d', CHAIN_ID, 18, 'WXDAI')
-  export const WBTC = Token.fromString('0x8e5bbbb09ed1ebde8674cda39a0c169401db4252', CHAIN_ID, 8, 'WBTC')
-  export const WETH = Token.fromString('0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1', CHAIN_ID, 18, 'WETH')
+  export const xDAI = ERC20Token.native(CHAIN_ID)
+  export const USDC = ERC20Token.fromString('0x2a22f9c3b484c3629090feed35f17ff8f88f76f0', CHAIN_ID, 6, 'USDC')
+  export const USDT = ERC20Token.fromString('0x4ecaba5870353805a9f068101a40e0f32ed605c6', CHAIN_ID, 6, 'USDT')
+  export const WXDAI = ERC20Token.fromString('0xe91D153E0b41518A2Ce8Dd3D7944Fa863463a97d', CHAIN_ID, 18, 'WXDAI')
+  export const WBTC = ERC20Token.fromString('0x8e5bbbb09ed1ebde8674cda39a0c169401db4252', CHAIN_ID, 8, 'WBTC')
+  export const WETH = ERC20Token.fromString('0x6a023ccd1ff6f2045c3309768ead9e68f978f6e1', CHAIN_ID, 18, 'WETH')
 }

package/src/chains/Optimism.ts

@@ -1,12 +1,12 @@
-import { Token } from '../tokens'
+import { ERC20Token } from '../tokens'
 import { ChainId } from '../types'
 
 export namespace Optimism {
   export const CHAIN_ID = ChainId.OPTIMISM
-  export const ETH = Token.native(CHAIN_ID)
-  export const USDC = Token.fromString('0x0b2c639c533813f4aa9d7837caf62653d097ff85', CHAIN_ID, 6, 'USDC')
-  export const USDT = Token.fromString('0x94b008aa00579c1307b0ef2c499ad98a8ce58e58', CHAIN_ID, 6, 'USDT')
-  export const DAI = Token.fromString('0xda10009cbd5d07dd0cecc66161fc93d7c9000da1', CHAIN_ID, 18, 'DAI')
-  export const WBTC = Token.fromString('0x68f180fcce6836688e9084f035309e29bf0a2095', CHAIN_ID, 8, 'WBTC')
-  export const WETH = Token.fromString('0x4200000000000000000000000000000000000006', CHAIN_ID, 18, 'WETH')
+  export const ETH = ERC20Token.native(CHAIN_ID)
+  export const USDC = ERC20Token.fromString('0x0b2c639c533813f4aa9d7837caf62653d097ff85', CHAIN_ID, 6, 'USDC')
+  export const USDT = ERC20Token.fromString('0x94b008aa00579c1307b0ef2c499ad98a8ce58e58', CHAIN_ID, 6, 'USDT')
+  export const DAI = ERC20Token.fromString('0xda10009cbd5d07dd0cecc66161fc93d7c9000da1', CHAIN_ID, 18, 'DAI')
+  export const WBTC = ERC20Token.fromString('0x68f180fcce6836688e9084f035309e29bf0a2095', CHAIN_ID, 8, 'WBTC')
+  export const WETH = ERC20Token.fromString('0x4200000000000000000000000000000000000006', CHAIN_ID, 18, 'WETH')
 }

package/src/context/Context.ts

@@ -51,7 +51,9 @@ export class Context {
 
   findSettler(chainId: ChainId): Address {
     for (let i = 0; i < this.settlers.length; i++) {
-      if (this.settlers[i].chainId === chainId) return this.settlers[i].address
+      if (this.settlers[i].chainId === chainId) {
+        return this.settlers[i].address
+      }
     }
     throw new Error(`Settler not found for chainId: ${chainId}`)
   }

package/src/environment.ts

@@ -1,10 +1,11 @@
+import { JSON } from 'json-as/assembly'
+
+import { Context, SerializableContext } from './context'
 import { ListType } from './helpers'
-import { Token, TokenAmount, USD } from './tokens'
-import { Address, BigInt, ChainId } from './types'
 import { Swap, Transfer, Call } from './intents'
 import { Call as CallQuery, GetPrice, GetRelevantTokens, GetRelevantTokensResponse } from './queries'
-import { JSON } from 'json-as/assembly'
-import { Context, SerializableContext } from './context'
+import { ERC20Token, Token, TokenAmount, USD } from './tokens'
+import { Address, BigInt, ChainId } from './types'
 
 export namespace environment {
   @external('environment', '_call')
@@ -59,7 +60,9 @@ export namespace environment {
    * @returns The token price in USD
    */
   export function getPrice(token: Token, timestamp: Date | null = null): USD {
-    const price = _getPrice(JSON.stringify(GetPrice.fromToken(token, timestamp)))
+    if (token.isUSD()) return USD.fromI32(1)
+    else if (!token instanceof ERC20Token) throw new Error('Price query not supported for token ' + token.toString())
+    const price = _getPrice(JSON.stringify(GetPrice.fromERC20Token(token as ERC20Token, timestamp)))
     return USD.fromBigInt(BigInt.fromString(price))
   }
 
@@ -68,15 +71,16 @@ export namespace environment {
    * @param address - The address to query balances for
    * @param chainIds - Array of chain ids to search
    * @param usdMinAmount - Minimum USD value threshold for tokens (optional, defaults to zero)
-   * @param tokensList - List of tokens to include/exclude (optional, defaults to empty array)
+   * @param tokensList - List of ERC20 tokens to include/exclude (optional, defaults to empty array)
    * @param listType - Whether to include (AllowList) or exclude (DenyList) the tokens in `tokensList` (optional, defaults to DenyList)
+   * @param timestamp - The timestamp for relevant tokens qery (optional, defaults to current time)
    * @returns Array of TokenAmount objects representing the relevant tokens
    */
   export function getRelevantTokens(
     address: Address,
     chainIds: ChainId[],
     usdMinAmount: USD = USD.zero(),
-    tokensList: Token[] = [],
+    tokensList: ERC20Token[] = [],
     listType: ListType = ListType.DenyList,
     timestamp: Date | null = null
   ): TokenAmount[] {

package/src/helpers/constants.ts

@@ -1,5 +1,6 @@
 export const NULL_ADDRESS = '0x0000000000000000000000000000000000000000'
 export const NATIVE_ADDRESS = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
+export const USD_ADDRESS = '0x0000000000000000000000000000000000000348'
 
 export const STANDARD_DECIMALS: u8 = 18
 

package/src/helpers/strings.ts

@@ -1,3 +1,7 @@
+import { decode, encode } from 'as-base58/assembly/index'
+
+import { ByteArray } from '../types'
+
 export function bytesToString(bytes: Uint8Array): string {
   return String.UTF8.decodeUnsafe(bytes.dataStart, bytes.length)
 }
@@ -8,6 +12,15 @@ 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 areAllZeros(str: string): boolean {
   for (let i = 0; i < str.length; i++) if (str.charCodeAt(i) !== 48) return false
   return true
@@ -101,3 +114,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.ts

@@ -12,7 +12,6 @@ import { Intent, IntentBuilder, OperationType } from './Intent'
 export class CallBuilder extends IntentBuilder {
   private chainId: ChainId
   private calls: CallData[] = []
-  private fee: TokenAmount | null = null
 
   /**
    * Creates a CallBuilder for the specified blockchain network.
@@ -23,18 +22,6 @@ export class CallBuilder extends IntentBuilder {
     return new CallBuilder(chainId)
   }
 
-  /**
-   * Creates a CallBuilder with a pre-configured fee.
-   * @param chainId - The blockchain network identifier
-   * @param fee - The fee token amount to be charged for the call
-   * @returns A new CallBuilder instance with fee already set
-   */
-  static forChainWithFee(chainId: ChainId, fee: TokenAmount): CallBuilder {
-    const builder = new CallBuilder(chainId)
-    builder.addFee(fee)
-    return builder
-  }
-
   /**
    * Creates a new CallBuilder instance.
    * @param chainId - The blockchain network identifier
@@ -56,17 +43,6 @@ export class CallBuilder extends IntentBuilder {
     return this
   }
 
-  /**
-   * Sets the fee to be charged for executing this call intent.
-   * @param fee - The fee token amount (must be on the same chain as the call)
-   * @returns This CallBuilder instance for method chaining
-   */
-  addFee(fee: TokenAmount): CallBuilder {
-    if (fee.token.chainId !== this.chainId) throw new Error('Fee token must be on the same chain')
-    this.fee = fee
-    return this
-  }
-
   /**
    * Sets the settler address for this intent.
    * @param settler - The settler address as an Address instance
@@ -121,21 +97,23 @@ export class CallBuilder extends IntentBuilder {
     return changetype<CallBuilder>(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
+   */
+  addMaxFee(fee: TokenAmount): CallBuilder {
+    if (!fee.token.hasChain(this.chainId)) throw new Error('Fee token must be on the same chain')
+    this.maxFees.push(fee)
+    return this
+  }
+
   /**
    * Builds and returns the final Call intent.
    * @returns A new Call instance with all configured parameters
    */
   build(): Call {
-    if (!this.fee) throw new Error('Call fee must be specified')
-    return new Call(
-      this.chainId,
-      this.calls,
-      this.fee as TokenAmount,
-      this.settler,
-      this.user,
-      this.deadline,
-      this.nonce
-    )
+    return new Call(this.chainId, this.calls, this.maxFees, this.settler, this.user, this.deadline, this.nonce)
   }
 }
 
@@ -169,15 +147,13 @@ export class CallData {
 export class Call extends Intent {
   public chainId: ChainId
   public calls: CallData[]
-  public feeToken: string
-  public feeAmount: string
 
   /**
    * Creates a Call 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 fee - The fee token amount to be charged
+   * @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)
@@ -189,7 +165,7 @@ export class Call extends Intent {
     chainId: ChainId,
     target: Address,
     data: Bytes,
-    fee: TokenAmount,
+    maxFee: TokenAmount,
     value: BigInt = BigInt.zero(),
     settler: Address | null = null,
     user: Address | null = null,
@@ -197,14 +173,14 @@ export class Call extends Intent {
     nonce: string | null = null
   ): Call {
     const callData = new CallData(target, data, value)
-    return new Call(chainId, [callData], fee, settler, user, deadline, nonce)
+    return new Call(chainId, [callData], [maxFee], settler, user, deadline, nonce)
   }
 
   /**
    * Creates a new Call intent.
    * @param chainId - The blockchain network identifier
    * @param calls - Array of contract calls to execute
-   * @param fee - The fee token amount to be charged
+   * @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)
@@ -213,19 +189,17 @@ export class Call extends Intent {
   constructor(
     chainId: ChainId,
     calls: CallData[],
-    fee: TokenAmount,
+    maxFees: TokenAmount[],
     settler: Address | null = null,
     user: Address | null = null,
     deadline: BigInt | null = null,
     nonce: string | null = null
   ) {
-    super(OperationType.Call, chainId, settler, user, deadline, nonce)
-
+    super(OperationType.Call, chainId, maxFees, settler, user, deadline, nonce)
     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.feeToken = fee.token.address.toString()
-    this.feeAmount = fee.amount.toString()
     this.chainId = chainId
   }
 

package/src/intents/Intent.ts

@@ -1,6 +1,7 @@
 import { environment } from '../environment'
 import { evm } from '../evm'
 import { NULL_ADDRESS } from '../helpers'
+import { TokenAmount } from '../tokens'
 import { Address, BigInt, ChainId } from '../types'
 
 export enum OperationType {
@@ -11,40 +12,85 @@ export enum OperationType {
 
 const DEFAULT_DEADLINE = 5 * 60 // 5 minutes in seconds
 
+/**
+ * Base builder for creating intents.
+ */
 export abstract class IntentBuilder {
   protected user: Address | null = null
   protected settler: Address | null = null
   protected deadline: BigInt | null = null
   protected nonce: string | null = null
+  protected maxFees: TokenAmount[] = []
 
+  /**
+   * Sets the settler address for this intent.
+   * @param settler - The settler address as an Address instance
+   * @returns This IntentBuilder instance for method chaining
+   */
   addSettler(settler: Address): IntentBuilder {
     this.settler = settler
     return this
   }
 
+  /**
+   * Sets the settler address from a string.
+   * @param settler - The settler address as a hex string
+   * @returns This IntentBuilder instance for method chaining
+   */
   addSettlerAsString(settler: string): IntentBuilder {
     return this.addSettler(Address.fromString(settler))
   }
 
+  /**
+   * Sets the deadline for this intent.
+   * @param deadline - The deadline as a timestamp
+   * @returns This IntentBuilder instance for method chaining
+   */
   addDeadline(deadline: BigInt): IntentBuilder {
     this.deadline = deadline
     return this
   }
 
+  /**
+   * Sets the user address for this intent.
+   * @param user - The user address
+   * @returns This IntentBuilder instance for method chaining
+   */
   addUser(user: Address): IntentBuilder {
     this.user = user
     return this
   }
 
+  /**
+   * Sets the user address from a string.
+   * @param user - The user address as a hex string
+   * @returns This IntentBuilder instance for method chaining
+   */
   addUserAsString(user: string): IntentBuilder {
     return this.addUser(Address.fromString(user))
   }
 
+  /**
+   * Sets the nonce for this intent.
+   * @param nonce - The nonce to be set for the intent
+   * @returns This IntentBuilder instance for method chaining
+   */
   addNonce(nonce: string): IntentBuilder {
     this.nonce = nonce
     return this
   }
 
+  /**
+   * Adds a max fee for this intent.
+   * @param fee - The max fee token amount (must be on same chain)
+   * @returns This IntentBuilder instance for method chaining
+   */
+  abstract addMaxFee(fee: TokenAmount): IntentBuilder
+
+  /**
+   * Builds and returns the final intent.
+   * @returns A new intent
+   */
   abstract build(): Intent
 }
 
@@ -56,10 +102,23 @@ export abstract class Intent {
   public user: string
   public deadline: string
   public nonce: string
+  public maxFeeTokens: string[]
+  public maxFeeAmounts: string[]
 
+  /**
+   * Creates a new intent.
+   * @param op - The type of intent to be created
+   * @param chainId - The chain ID for fetch the settler
+   * @param maxFees - The list of max fees to pay for the 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)
+   */
   protected constructor(
     op: OperationType,
     chainId: ChainId,
+    maxFees: TokenAmount[],
     settler: Address | null,
     user: Address | null,
     deadline: BigInt | null,
@@ -71,10 +130,15 @@ export abstract class Intent {
     this.deadline = deadline ? deadline.toString() : (context.timestamp / 1000 + DEFAULT_DEADLINE).toString()
     this.user = user ? user.toString() : context.user.toString()
     this.nonce = nonce ? nonce : evm.keccak(`${context.configSig}${context.timestamp}${++INTENT_INDEX}`)
+    this.maxFeeTokens = maxFees.map((fee: TokenAmount) => fee.token.address.toString())
+    this.maxFeeAmounts = maxFees.map((fee: TokenAmount) => fee.amount.toString())
 
     if (!this.user || this.user == NULL_ADDRESS) throw new Error('A user must be specified')
     if (!this.settler || this.settler == NULL_ADDRESS) throw new Error('A settler contract must be specified')
   }
 
+  /**
+   * Sends this intent to the execution environment.
+   */
   abstract send(): void
 }

package/src/intents/Swap.ts

@@ -1,5 +1,5 @@
 import { environment } from '../environment'
-import { Token, TokenAmount } from '../tokens'
+import { ERC20Token, Token, TokenAmount } from '../tokens'
 import { Address, BigInt, ChainId } from '../types'
 
 import { Intent, IntentBuilder, OperationType } from './Intent'
@@ -90,7 +90,7 @@ export class SwapBuilder extends IntentBuilder {
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenInFromTokenAmount(tokenAmount: TokenAmount): SwapBuilder {
-    if (tokenAmount.token.chainId !== this.sourceChain) throw new Error('Tokens in must be on the same chain')
+    if (!tokenAmount.token.hasChain(this.sourceChain)) throw new Error('Tokens in must be on the same chain')
     return this.addTokenIn(TokenIn.fromTokenAmount(tokenAmount))
   }
 
@@ -111,7 +111,7 @@ export class SwapBuilder extends IntentBuilder {
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenInFromStringDecimal(token: Token, amount: string): SwapBuilder {
-    if (token.chainId !== this.sourceChain) throw new Error('Tokens in must be on the same chain')
+    if (!token.hasChain(this.sourceChain)) throw new Error('Tokens in must be on the source chain')
     return this.addTokenIn(TokenIn.fromStringDecimal(token, amount))
   }
 
@@ -122,7 +122,8 @@ export class SwapBuilder extends IntentBuilder {
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenOutFromTokenAmount(tokenAmount: TokenAmount, recipient: Address): SwapBuilder {
-    if (tokenAmount.token.chainId !== this.destinationChain) throw new Error('Tokens out must be on the same chain')
+    if (!tokenAmount.token.hasChain(this.destinationChain))
+      throw new Error('Tokens out must be on the destination chain')
     return this.addTokenOut(TokenOut.fromTokenAmount(tokenAmount, recipient))
   }
 
@@ -145,7 +146,7 @@ export class SwapBuilder extends IntentBuilder {
    * @returns This SwapBuilder instance for method chaining
    */
   addTokenOutFromStringDecimal(token: Token, amount: string, recipient: Address): SwapBuilder {
-    if (token.chainId !== this.destinationChain) throw new Error('Tokens out must be on the same chain')
+    if (!token.hasChain(this.destinationChain)) throw new Error('Tokens out must be on the destination chain')
     return this.addTokenOut(TokenOut.fromStringDecimal(token, amount, recipient))
   }
 
@@ -203,6 +204,17 @@ export class SwapBuilder extends IntentBuilder {
     return changetype<SwapBuilder>(super.addNonce(nonce))
   }
 
+  /**
+   * Adds a max fee for this intent.
+   * @param fee - The max fee token amount (must be on same chain)
+   * @returns This SwapBuilder instance for method chaining
+   */
+  addMaxFee(fee: TokenAmount): SwapBuilder {
+    if (!fee.token.hasChain(this.destinationChain)) throw new Error('Fee token must be on the destination chain')
+    this.maxFees.push(fee)
+    return this
+  }
+
   /**
    * Builds and returns the final Swap intent.
    * @returns A new Swap instance with all configured parameters
@@ -218,7 +230,8 @@ export class SwapBuilder extends IntentBuilder {
       this.settler,
       this.user,
       this.deadline,
-      this.nonce
+      this.nonce,
+      this.maxFees
     )
   }
 }
@@ -379,8 +392,8 @@ export class Swap extends Intent {
   ): Swap {
     const context = environment.getContext()
     const recipient = user || context.user
-    const swapIn = TokenIn.fromBigInt(Token.fromAddress(tokenIn, chainId), amountIn)
-    const swapOut = TokenOut.fromBigInt(Token.fromAddress(tokenOut, chainId), minAmountOut, recipient)
+    const swapIn = TokenIn.fromBigInt(ERC20Token.fromAddress(tokenIn, chainId), amountIn)
+    const swapOut = TokenOut.fromBigInt(ERC20Token.fromAddress(tokenOut, chainId), minAmountOut, recipient)
     return new Swap(chainId, [swapIn], [swapOut], chainId, settler, user, deadline, nonce)
   }
 
@@ -394,6 +407,7 @@ export class Swap extends Intent {
    * @param user - The user address (optional)
    * @param deadline - The deadline timestamp (optional)
    * @param nonce - The nonce for replay protection (optional)
+   * @param maxFees - The list of max fees to pay for the swap intent (optional)
    */
   constructor(
     public sourceChain: ChainId,
@@ -403,9 +417,10 @@ export class Swap extends Intent {
     settler: Address | null = null,
     user: Address | null = null,
     deadline: BigInt | null = null,
-    nonce: string | null = null
+    nonce: string | null = null,
+    maxFees: TokenAmount[] | null = null
   ) {
-    super(OperationType.Swap, sourceChain, settler, user, deadline, nonce)
+    super(OperationType.Swap, sourceChain, maxFees || [], settler, user, deadline, nonce)
     if (tokensIn.length === 0) throw new Error('TokenIn list cannot be empty')
     if (tokensOut.length === 0) throw new Error('TokenOut list cannot be empty')
   }