@0xsequence/relayer 3.0.0-beta.18 → 3.0.0-beta.19

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