@0xsequence/relayer 3.0.0-beta.8 → 3.0.0

package/src/relayer/standard/local.ts

@@ -1,9 +1,18 @@
-import { Constants, Payload } from '@0xsequence/wallet-primitives'
+import { Payload } from '@0xsequence/wallet-primitives'
 import { EIP1193Provider } from 'mipd'
-import { AbiFunction, Address, Bytes, Hex, TransactionReceipt } from 'ox'
+import { AbiFunction, Address, Hex, TransactionReceipt } from 'ox'
 import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js'
 import { FeeToken, TransactionPrecondition } from '../rpc-relayer/relayer.gen.js'
-import { decodePrecondition } from '../../preconditions/index.js'
+import {
+  decodePrecondition,
+  Erc1155ApprovalPrecondition,
+  Erc1155BalancePrecondition,
+  Erc20ApprovalPrecondition,
+  Erc20BalancePrecondition,
+  Erc721ApprovalPrecondition,
+  Erc721OwnershipPrecondition,
+  NativeBalancePrecondition,
+} from '../../preconditions/index.js'
 import {
   erc20BalanceOf,
   erc20Allowance,
@@ -23,7 +32,7 @@ export interface GenericProvider {
 }
 
 export class LocalRelayer implements Relayer {
-  public readonly kind: 'relayer' = 'relayer'
+  public readonly kind = 'relayer'
   public readonly type = 'local'
   public readonly id = 'local'
 
@@ -34,7 +43,7 @@ export class LocalRelayer implements Relayer {
   }
 
   static createFromWindow(window: Window): LocalRelayer | undefined {
-    const eth = (window as any).ethereum
+    const eth = (window as { ethereum?: EIP1193Provider }).ethereum
     if (!eth) {
       console.warn('Window.ethereum not found, skipping local relayer')
       return undefined
@@ -54,27 +63,14 @@ export class LocalRelayer implements Relayer {
   }
 
   feeOptions(
-    wallet: Address.Address,
-    chainId: number,
-    calls: Payload.Call[],
+    _wallet: Address.Address,
+    _chainId: number,
+    _to: Address.Address,
+    _calls: Payload.Call[],
   ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
     return Promise.resolve({ options: [] })
   }
 
-  private decodeCalls(data: Hex.Hex): Payload.Calls {
-    const executeSelector = AbiFunction.getSelector(Constants.EXECUTE)
-
-    let packedPayload
-    if (data.startsWith(executeSelector)) {
-      const decode = AbiFunction.decodeData(Constants.EXECUTE, data)
-      packedPayload = decode[0]
-    } else {
-      packedPayload = data
-    }
-
-    return Payload.decode(Bytes.fromHex(packedPayload))
-  }
-
   async relay(
     to: Address.Address,
     data: Hex.Hex,
@@ -177,8 +173,8 @@ export class LocalRelayer implements Relayer {
 
     switch (decoded.type()) {
       case 'native-balance': {
-        const native = decoded as any
-        const balance = await this.provider.getBalance(native.address.toString())
+        const native = decoded as NativeBalancePrecondition
+        const balance = await this.provider.getBalance(native.address)
         if (native.min !== undefined && balance < native.min) {
           return false
         }
@@ -189,10 +185,10 @@ export class LocalRelayer implements Relayer {
       }
 
       case 'erc20-balance': {
-        const erc20 = decoded as any
-        const data = AbiFunction.encodeData(erc20BalanceOf, [erc20.address.toString()])
+        const erc20 = decoded as Erc20BalancePrecondition
+        const data = AbiFunction.encodeData(erc20BalanceOf, [erc20.address])
         const result = await this.provider.call({
-          to: erc20.token.toString(),
+          to: erc20.token,
           data,
         })
         const balance = BigInt(result)
@@ -206,10 +202,10 @@ export class LocalRelayer implements Relayer {
       }
 
       case 'erc20-approval': {
-        const erc20 = decoded as any
-        const data = AbiFunction.encodeData(erc20Allowance, [erc20.address.toString(), erc20.operator.toString()])
+        const erc20 = decoded as Erc20ApprovalPrecondition
+        const data = AbiFunction.encodeData(erc20Allowance, [erc20.address, erc20.operator])
         const result = await this.provider.call({
-          to: erc20.token.toString(),
+          to: erc20.token,
           data,
         })
         const allowance = BigInt(result)
@@ -217,10 +213,10 @@ export class LocalRelayer implements Relayer {
       }
 
       case 'erc721-ownership': {
-        const erc721 = decoded as any
+        const erc721 = decoded as Erc721OwnershipPrecondition
         const data = AbiFunction.encodeData(erc721OwnerOf, [erc721.tokenId])
         const result = await this.provider.call({
-          to: erc721.token.toString(),
+          to: erc721.token,
           data,
         })
         const owner = '0x' + result.slice(26)
@@ -229,10 +225,10 @@ export class LocalRelayer implements Relayer {
       }
 
       case 'erc721-approval': {
-        const erc721 = decoded as any
+        const erc721 = decoded as Erc721ApprovalPrecondition
         const data = AbiFunction.encodeData(erc721GetApproved, [erc721.tokenId])
         const result = await this.provider.call({
-          to: erc721.token.toString(),
+          to: erc721.token,
           data,
         })
         const approved = '0x' + result.slice(26)
@@ -240,10 +236,10 @@ export class LocalRelayer implements Relayer {
       }
 
       case 'erc1155-balance': {
-        const erc1155 = decoded as any
-        const data = AbiFunction.encodeData(erc1155BalanceOf, [erc1155.address.toString(), erc1155.tokenId])
+        const erc1155 = decoded as Erc1155BalancePrecondition
+        const data = AbiFunction.encodeData(erc1155BalanceOf, [erc1155.address, erc1155.tokenId])
         const result = await this.provider.call({
-          to: erc1155.token.toString(),
+          to: erc1155.token,
           data,
         })
         const balance = BigInt(result)
@@ -257,13 +253,10 @@ export class LocalRelayer implements Relayer {
       }
 
       case 'erc1155-approval': {
-        const erc1155 = decoded as any
-        const data = AbiFunction.encodeData(erc1155IsApprovedForAll, [
-          erc1155.address.toString(),
-          erc1155.operator.toString(),
-        ])
+        const erc1155 = decoded as Erc1155ApprovalPrecondition
+        const data = AbiFunction.encodeData(erc1155IsApprovedForAll, [erc1155.address, erc1155.operator])
         const result = await this.provider.call({
-          to: erc1155.token.toString(),
+          to: erc1155.token,
           data,
         })
         return BigInt(result) === 1n
@@ -340,7 +333,7 @@ export class EIP1193ProviderAdapter implements GenericProvider {
     const rpcReceipt = await this.provider.request({ method: 'eth_getTransactionReceipt', params: [txHash] })
 
     if (rpcReceipt) {
-      const receipt = TransactionReceipt.fromRpc(rpcReceipt as any)
+      const receipt = TransactionReceipt.fromRpc(rpcReceipt as Parameters<typeof TransactionReceipt.fromRpc>[0])
       if (receipt?.status === 'success') {
         return 'success'
       } else if (receipt?.status === 'reverted') {

package/src/relayer/standard/pk-relayer.ts

@@ -5,7 +5,7 @@ import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js'
 import { FeeToken } from '../rpc-relayer/relayer.gen.js'
 
 export class PkRelayer implements Relayer {
-  public readonly kind: 'relayer' = 'relayer'
+  public readonly kind = 'relayer'
   public readonly type = 'pk'
   public readonly id = 'pk'
   private readonly relayer: LocalRelayer
@@ -114,9 +114,10 @@ export class PkRelayer implements Relayer {
   feeOptions(
     wallet: Address.Address,
     chainId: number,
+    to: Address.Address,
     calls: Payload.Call[],
   ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
-    return this.relayer.feeOptions(wallet, chainId, calls)
+    return this.relayer.feeOptions(wallet, chainId, to, calls)
   }
 
   async relay(to: Address.Address, data: Hex.Hex, chainId: number, _?: FeeQuote): Promise<{ opHash: Hex.Hex }> {
@@ -131,7 +132,7 @@ export class PkRelayer implements Relayer {
     return this.relayer.status(opHash, chainId)
   }
 
-  async checkPrecondition(precondition: Precondition.Precondition): Promise<boolean> {
+  async checkPrecondition(_precondition: Precondition.Precondition): Promise<boolean> {
     // TODO: Implement precondition check
     return true
   }

package/src/relayer/standard/sequence.ts

@@ -3,7 +3,7 @@ import { Payload } from '@0xsequence/wallet-primitives'
 import { AbiFunction, Address, Bytes, Hex } from 'ox'
 import { FeeOption, FeeQuote, OperationStatus, Relayer } from '../index.js'
 export class SequenceRelayer implements Relayer {
-  public readonly kind: 'relayer' = 'relayer'
+  public readonly kind = 'relayer'
   public readonly type = 'sequence'
   readonly id = 'sequence'
 
@@ -36,9 +36,9 @@ export class SequenceRelayer implements Relayer {
   async feeOptions(
     wallet: Address.Address,
     _chainId: number,
+    to: Address.Address,
     calls: Payload.Call[],
   ): Promise<{ options: FeeOption[]; quote?: FeeQuote }> {
-    const to = wallet // TODO: this might be the guest module
     const execute = AbiFunction.from('function execute(bytes calldata _payload, bytes calldata _signature)')
     const payload = Payload.encode({ type: 'call', space: 0n, nonce: 0n, calls }, to)
     const signature = '0x0001' // TODO: use a stub signature
@@ -52,7 +52,7 @@ export class SequenceRelayer implements Relayer {
     }
   }
 
-  async checkPrecondition(precondition: TransactionPrecondition): Promise<boolean> {
+  async checkPrecondition(_precondition: TransactionPrecondition): Promise<boolean> {
     // TODO: implement
     return false
   }

package/test/preconditions/codec.test.ts

@@ -36,8 +36,8 @@ describe('Preconditions Codec', () => {
 
   describe('decodePrecondition', () => {
     it('should return undefined for null/undefined input', () => {
-      expect(decodePrecondition(null as any)).toBeUndefined()
-      expect(decodePrecondition(undefined as any)).toBeUndefined()
+      expect(decodePrecondition(null as unknown as TransactionPrecondition)).toBeUndefined()
+      expect(decodePrecondition(undefined as unknown as TransactionPrecondition)).toBeUndefined()
     })
 
     it('should decode native balance precondition with only min', () => {
@@ -231,8 +231,8 @@ describe('Preconditions Codec', () => {
     it('should handle malformed addresses gracefully', () => {
       const intent: TransactionPrecondition = {
         type: 'native-balance',
-        ownerAddress: 'invalid-address' as any,
-        tokenAddress: NATIVE_TOKEN_ADDRESS,
+        ownerAddress: 'invalid-address',
+        tokenAddress: NATIVE_TOKEN_ADDRESS.toString(),
         chainId: ARBITRUM_CHAIN_ID,
         minAmount: BigInt('1000000000000000000'),
       }
@@ -243,13 +243,13 @@ describe('Preconditions Codec', () => {
     })
 
     it('should handle malformed BigInt values gracefully', () => {
-      const intent: TransactionPrecondition = {
+      const intent = {
         type: 'native-balance',
-        ownerAddress: TEST_ADDRESS,
-        tokenAddress: NATIVE_TOKEN_ADDRESS,
+        ownerAddress: TEST_ADDRESS.toString(),
+        tokenAddress: NATIVE_TOKEN_ADDRESS.toString(),
         chainId: ARBITRUM_CHAIN_ID,
-        minAmount: 'not-a-number' as any,
-      }
+        minAmount: 'not-a-number',
+      } as unknown as TransactionPrecondition
 
       const result = decodePrecondition(intent)
       expect(result).toBeUndefined()
@@ -316,8 +316,8 @@ describe('Preconditions Codec', () => {
         },
         {
           type: 'native-balance',
-          ownerAddress: 'invalid-address' as any,
-          tokenAddress: NATIVE_TOKEN_ADDRESS,
+          ownerAddress: 'invalid-address',
+          tokenAddress: NATIVE_TOKEN_ADDRESS.toString(),
           chainId: ARBITRUM_CHAIN_ID,
           minAmount: BigInt('1000000000000000000'),
         },

package/test/preconditions/preconditions.test.ts

@@ -1,4 +1,4 @@
-import { Address, Provider, RpcTransport, Secp256k1 } from 'ox'
+import { Address, Hex, Secp256k1 } from 'ox'
 import { describe, expect, it, vi } from 'vitest'
 import {
   Erc1155ApprovalPrecondition,
@@ -9,49 +9,50 @@ import {
   Erc721OwnershipPrecondition,
   NativeBalancePrecondition,
 } from '../../src/preconditions/types.js'
-import { LocalRelayer } from '../../src/standard/local.js'
-import { CAN_RUN_LIVE, RPC_URL } from '../../../../wallet/core/test/constants'
+import {
+  LocalRelayer,
+  type GenericProvider,
+} from '../../src/relayer/standard/local.js'
 import { Network } from '@0xsequence/wallet-primitives'
 
+const CAN_RUN_LIVE = false
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
 const ERC20_IMPLICIT_MINT_CONTRACT = '0x041E0CDC028050519C8e6485B2d9840caf63773F'
 
 function randomAddress(): Address.Address {
   return Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey: Secp256k1.randomPrivateKey() }))
 }
 
+function createMockProvider(): GenericProvider {
+  return {
+    sendTransaction: vi.fn(),
+    getBalance: vi.fn(),
+    call: vi.fn(),
+    getTransactionReceipt: vi.fn(),
+  }
+}
+
 describe('Preconditions', () => {
-  const getProvider = async (): Promise<{ provider: Provider.Provider; chainId: number }> => {
-    let provider: Provider.Provider
-    let chainId: number = Network.ChainId.MAINNET
+  const getProvider = async (): Promise<{ provider: GenericProvider; chainId: number }> => {
+    const chainId = Network.ChainId.MAINNET
     if (CAN_RUN_LIVE) {
-      provider = Provider.from(RpcTransport.fromHttp(RPC_URL!!))
-      chainId = Number(await provider.request({ method: 'eth_chainId' }))
-    } else {
-      provider = {
-        request: vi.fn(),
-        on: vi.fn(),
-        removeListener: vi.fn(),
-        call: vi.fn(),
-        sendTransaction: vi.fn(),
-        getBalance: vi.fn(),
-      } as unknown as Provider.Provider
+      throw new Error('Live tests not configured: set up RPC and GenericProvider adapter')
     }
-
-    return { provider: provider!, chainId }
+    const provider = createMockProvider()
+    return { provider, chainId }
   }
 
   const testWalletAddress = randomAddress()
 
-  const requireContractDeployed = async (provider: Provider.Provider, contract: Address.Address) => {
-    const code = await provider.request({ method: 'eth_getCode', params: [contract, 'latest'] })
-    if (code === '0x') {
-      throw new Error(`Contract ${contract} not deployed`)
+  const requireContractDeployed = async (_provider: GenericProvider, _contract: Address.Address) => {
+    if (CAN_RUN_LIVE) {
+      throw new Error('Live contract check not implemented')
     }
   }
 
   it('should create and check native balance precondition', async () => {
     const { provider, chainId } = await getProvider()
-    const relayer = new LocalRelayer(provider as any)
+    const relayer = new LocalRelayer(provider)
 
     const precondition = new NativeBalancePrecondition(
       testWalletAddress,
@@ -59,225 +60,183 @@ describe('Preconditions', () => {
       2000000000000000000n, // 2 ETH max
     )
 
-    const intentPrecondition = {
+    const transactionPrecondition = {
       type: precondition.type(),
-      chainId: chainId.toString(),
-      data: JSON.stringify({
-        address: precondition.address.toString(),
-        min: precondition.min?.toString(),
-        max: precondition.max?.toString(),
-      }),
+      chainId,
+      ownerAddress: precondition.address.toString(),
+      tokenAddress: ZERO_ADDRESS,
+      minAmount: precondition.min ?? 0n,
     }
 
-    if (!CAN_RUN_LIVE) {
-      // Mock the balance check
-      ;(provider as any).request.mockResolvedValue('0x16345785d8a0000') // 1.5 ETH in hex
-    }
+    vi.mocked(provider.getBalance).mockResolvedValue(1500000000000000000n) // 1.5 ETH
 
-    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    const isValid = await relayer.checkPrecondition(transactionPrecondition)
     expect(isValid).toBe(true)
   })
 
   it('should create and check ERC20 balance precondition', async () => {
     const { provider, chainId } = await getProvider()
-    const relayer = new LocalRelayer(provider as any)
-    await requireContractDeployed(provider, ERC20_IMPLICIT_MINT_CONTRACT)
+    const relayer = new LocalRelayer(provider)
+    await requireContractDeployed(provider, Address.from(ERC20_IMPLICIT_MINT_CONTRACT))
 
     const precondition = new Erc20BalancePrecondition(
       testWalletAddress,
-      ERC20_IMPLICIT_MINT_CONTRACT,
+      Address.from(ERC20_IMPLICIT_MINT_CONTRACT),
       1000000n, // 1 token min
       2000000n, // 2 tokens max
     )
 
-    const intentPrecondition = {
+    const transactionPrecondition = {
       type: precondition.type(),
-      chainId: chainId.toString(),
-      data: JSON.stringify({
-        address: precondition.address.toString(),
-        token: precondition.token.toString(),
-        min: precondition.min?.toString(),
-        max: precondition.max?.toString(),
-      }),
+      chainId,
+      ownerAddress: precondition.address.toString(),
+      tokenAddress: precondition.token.toString(),
+      minAmount: precondition.min ?? 0n,
     }
 
-    if (!CAN_RUN_LIVE) {
-      // Mock the balanceOf call
-      ;(provider as any).call.mockResolvedValue('0x1e8480') // 1.5 tokens in hex
-    }
+    vi.mocked(provider.call).mockResolvedValue('0x1e8480' as Hex.Hex) // 1.5 tokens in hex
 
-    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    const isValid = await relayer.checkPrecondition(transactionPrecondition)
     expect(isValid).toBe(true)
   })
 
   it('should create and check ERC20 approval precondition', async () => {
     const { provider, chainId } = await getProvider()
-    const relayer = new LocalRelayer(provider as any)
-    await requireContractDeployed(provider, ERC20_IMPLICIT_MINT_CONTRACT)
+    const relayer = new LocalRelayer(provider)
+    await requireContractDeployed(provider, Address.from(ERC20_IMPLICIT_MINT_CONTRACT))
 
     const operator = randomAddress()
     const precondition = new Erc20ApprovalPrecondition(
       testWalletAddress,
-      ERC20_IMPLICIT_MINT_CONTRACT,
+      Address.from(ERC20_IMPLICIT_MINT_CONTRACT),
       operator,
       1000000n, // 1 token min approval
     )
 
-    const intentPrecondition = {
+    const transactionPrecondition = {
       type: precondition.type(),
-      chainId: chainId.toString(),
-      data: JSON.stringify({
-        address: precondition.address.toString(),
-        token: precondition.token.toString(),
-        operator: precondition.operator.toString(),
-        min: precondition.min.toString(),
-      }),
+      chainId,
+      ownerAddress: precondition.address.toString(),
+      tokenAddress: precondition.token.toString(),
+      minAmount: precondition.min,
     }
 
-    if (!CAN_RUN_LIVE) {
-      // Mock the allowance call
-      ;(provider as any).call.mockResolvedValue('0x1e8480') // 1.5 tokens in hex
-    }
+    vi.mocked(provider.call).mockResolvedValue('0x1e8480' as Hex.Hex) // 1.5 tokens in hex
 
-    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    const isValid = await relayer.checkPrecondition(transactionPrecondition)
     expect(isValid).toBe(true)
   })
 
   it('should create and check ERC721 ownership precondition', async () => {
     const { provider, chainId } = await getProvider()
-    const relayer = new LocalRelayer(provider as any)
-    await requireContractDeployed(provider, ERC20_IMPLICIT_MINT_CONTRACT)
+    const relayer = new LocalRelayer(provider)
+    await requireContractDeployed(provider, Address.from(ERC20_IMPLICIT_MINT_CONTRACT))
 
     const precondition = new Erc721OwnershipPrecondition(
       testWalletAddress,
-      ERC20_IMPLICIT_MINT_CONTRACT,
+      Address.from(ERC20_IMPLICIT_MINT_CONTRACT),
       1n, // tokenId
       true, // must own
     )
 
-    const intentPrecondition = {
+    const transactionPrecondition = {
       type: precondition.type(),
-      chainId: chainId.toString(),
-      data: JSON.stringify({
-        address: precondition.address.toString(),
-        token: precondition.token.toString(),
-        tokenId: precondition.tokenId.toString(),
-        owned: precondition.owned,
-      }),
+      chainId,
+      ownerAddress: precondition.address.toString(),
+      tokenAddress: precondition.token.toString(),
+      minAmount: 0n,
     }
 
-    if (!CAN_RUN_LIVE) {
-      // Mock the ownerOf call
-      ;(provider as any).call.mockResolvedValue(
-        '0x000000000000000000000000' + testWalletAddress.toString().slice(2).toLowerCase(),
-      )
-    }
+    vi.mocked(provider.call).mockResolvedValue(
+      ('0x000000000000000000000000' + testWalletAddress.toString().slice(2).toLowerCase()) as Hex.Hex,
+    )
 
-    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    const isValid = await relayer.checkPrecondition(transactionPrecondition)
     expect(isValid).toBe(true)
   })
 
   it('should create and check ERC721 approval precondition', async () => {
     const { provider, chainId } = await getProvider()
-    const relayer = new LocalRelayer(provider as any)
-    await requireContractDeployed(provider, ERC20_IMPLICIT_MINT_CONTRACT)
+    const relayer = new LocalRelayer(provider)
+    await requireContractDeployed(provider, Address.from(ERC20_IMPLICIT_MINT_CONTRACT))
 
     const operator = randomAddress()
     const precondition = new Erc721ApprovalPrecondition(
       testWalletAddress,
-      ERC20_IMPLICIT_MINT_CONTRACT,
+      Address.from(ERC20_IMPLICIT_MINT_CONTRACT),
       1n, // tokenId
       operator,
     )
 
-    const intentPrecondition = {
+    const transactionPrecondition = {
       type: precondition.type(),
-      chainId: chainId.toString(),
-      data: JSON.stringify({
-        address: precondition.address.toString(),
-        token: precondition.token.toString(),
-        tokenId: precondition.tokenId.toString(),
-        operator: precondition.operator.toString(),
-      }),
+      chainId,
+      ownerAddress: precondition.address.toString(),
+      tokenAddress: precondition.token.toString(),
+      minAmount: 0n,
     }
 
-    if (!CAN_RUN_LIVE) {
-      // Mock the getApproved call
-      ;(provider as any).call.mockResolvedValue(
-        '0x000000000000000000000000' + operator.toString().slice(2).toLowerCase(),
-      )
-    }
+    // getApproved returns 32-byte word: 12 zero bytes + 20-byte address. Codec uses ownerAddress as operator.
+    const approvedHex =
+      '0x' + '0'.repeat(24) + testWalletAddress.toString().slice(2).toLowerCase()
+    vi.mocked(provider.call).mockResolvedValue(approvedHex as Hex.Hex)
 
-    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    const isValid = await relayer.checkPrecondition(transactionPrecondition)
     expect(isValid).toBe(true)
   })
 
   it('should create and check ERC1155 balance precondition', async () => {
     const { provider, chainId } = await getProvider()
-    const relayer = new LocalRelayer(provider as any)
-    await requireContractDeployed(provider, ERC20_IMPLICIT_MINT_CONTRACT)
+    const relayer = new LocalRelayer(provider)
+    await requireContractDeployed(provider, Address.from(ERC20_IMPLICIT_MINT_CONTRACT))
 
     const precondition = new Erc1155BalancePrecondition(
       testWalletAddress,
-      ERC20_IMPLICIT_MINT_CONTRACT,
+      Address.from(ERC20_IMPLICIT_MINT_CONTRACT),
       1n, // tokenId
       1000000n, // 1 token min
       2000000n, // 2 tokens max
     )
 
-    const intentPrecondition = {
+    const transactionPrecondition = {
       type: precondition.type(),
-      chainId: chainId.toString(),
-      data: JSON.stringify({
-        address: precondition.address.toString(),
-        token: precondition.token.toString(),
-        tokenId: precondition.tokenId.toString(),
-        min: precondition.min?.toString(),
-        max: precondition.max?.toString(),
-      }),
+      chainId,
+      ownerAddress: precondition.address.toString(),
+      tokenAddress: precondition.token.toString(),
+      minAmount: precondition.min ?? 0n,
     }
 
-    if (!CAN_RUN_LIVE) {
-      // Mock the balanceOf call
-      ;(provider as any).call.mockResolvedValue('0x1e8480') // 1.5 tokens in hex
-    }
+    vi.mocked(provider.call).mockResolvedValue('0x1e8480' as Hex.Hex) // 1.5 tokens in hex
 
-    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    const isValid = await relayer.checkPrecondition(transactionPrecondition)
     expect(isValid).toBe(true)
   })
 
   it('should create and check ERC1155 approval precondition', async () => {
     const { provider, chainId } = await getProvider()
-    const relayer = new LocalRelayer(provider as any)
-    await requireContractDeployed(provider, ERC20_IMPLICIT_MINT_CONTRACT)
+    const relayer = new LocalRelayer(provider)
+    await requireContractDeployed(provider, Address.from(ERC20_IMPLICIT_MINT_CONTRACT))
 
     const operator = randomAddress()
     const precondition = new Erc1155ApprovalPrecondition(
       testWalletAddress,
-      ERC20_IMPLICIT_MINT_CONTRACT,
+      Address.from(ERC20_IMPLICIT_MINT_CONTRACT),
       1n, // tokenId
       operator,
       1000000n, // 1 token min approval
     )
 
-    const intentPrecondition = {
+    const transactionPrecondition = {
       type: precondition.type(),
-      chainId: chainId.toString(),
-      data: JSON.stringify({
-        address: precondition.address.toString(),
-        token: precondition.token.toString(),
-        tokenId: precondition.tokenId.toString(),
-        operator: precondition.operator.toString(),
-        min: precondition.min.toString(),
-      }),
+      chainId,
+      ownerAddress: precondition.address.toString(),
+      tokenAddress: precondition.token.toString(),
+      minAmount: precondition.min,
     }
 
-    if (!CAN_RUN_LIVE) {
-      // Mock the isApprovedForAll call
-      ;(provider as any).call.mockResolvedValue('0x1') // true
-    }
+    vi.mocked(provider.call).mockResolvedValue('0x1' as Hex.Hex) // true
 
-    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    const isValid = await relayer.checkPrecondition(transactionPrecondition)
     expect(isValid).toBe(true)
   })
 })