@0xsequence/relayer 2.3.35 → 3.0.0-beta.2

package/test/preconditions/preconditions.test.ts

@@ -0,0 +1,283 @@
+import { Address, Provider, RpcTransport, Secp256k1 } from 'ox'
+import { describe, expect, it, vi } from 'vitest'
+import {
+  Erc1155ApprovalPrecondition,
+  Erc1155BalancePrecondition,
+  Erc20ApprovalPrecondition,
+  Erc20BalancePrecondition,
+  Erc721ApprovalPrecondition,
+  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 { Network } from '@0xsequence/wallet-primitives'
+
+const ERC20_IMPLICIT_MINT_CONTRACT = '0x041E0CDC028050519C8e6485B2d9840caf63773F'
+
+function randomAddress(): Address.Address {
+  return Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey: Secp256k1.randomPrivateKey() }))
+}
+
+describe('Preconditions', () => {
+  const getProvider = async (): Promise<{ provider: Provider.Provider; chainId: number }> => {
+    let provider: Provider.Provider
+    let chainId: number = 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
+    }
+
+    return { provider: 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`)
+    }
+  }
+
+  it('should create and check native balance precondition', async () => {
+    const { provider, chainId } = await getProvider()
+    const relayer = new LocalRelayer(provider as any)
+
+    const precondition = new NativeBalancePrecondition(
+      testWalletAddress,
+      1000000000000000000n, // 1 ETH min
+      2000000000000000000n, // 2 ETH max
+    )
+
+    const intentPrecondition = {
+      type: precondition.type(),
+      chainId: chainId.toString(),
+      data: JSON.stringify({
+        address: precondition.address.toString(),
+        min: precondition.min?.toString(),
+        max: precondition.max?.toString(),
+      }),
+    }
+
+    if (!CAN_RUN_LIVE) {
+      // Mock the balance check
+      ;(provider as any).request.mockResolvedValue('0x16345785d8a0000') // 1.5 ETH in hex
+    }
+
+    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    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 precondition = new Erc20BalancePrecondition(
+      testWalletAddress,
+      ERC20_IMPLICIT_MINT_CONTRACT,
+      1000000n, // 1 token min
+      2000000n, // 2 tokens max
+    )
+
+    const intentPrecondition = {
+      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(),
+      }),
+    }
+
+    if (!CAN_RUN_LIVE) {
+      // Mock the balanceOf call
+      ;(provider as any).call.mockResolvedValue('0x1e8480') // 1.5 tokens in hex
+    }
+
+    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    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 operator = randomAddress()
+    const precondition = new Erc20ApprovalPrecondition(
+      testWalletAddress,
+      ERC20_IMPLICIT_MINT_CONTRACT,
+      operator,
+      1000000n, // 1 token min approval
+    )
+
+    const intentPrecondition = {
+      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(),
+      }),
+    }
+
+    if (!CAN_RUN_LIVE) {
+      // Mock the allowance call
+      ;(provider as any).call.mockResolvedValue('0x1e8480') // 1.5 tokens in hex
+    }
+
+    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    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 precondition = new Erc721OwnershipPrecondition(
+      testWalletAddress,
+      ERC20_IMPLICIT_MINT_CONTRACT,
+      1n, // tokenId
+      true, // must own
+    )
+
+    const intentPrecondition = {
+      type: precondition.type(),
+      chainId: chainId.toString(),
+      data: JSON.stringify({
+        address: precondition.address.toString(),
+        token: precondition.token.toString(),
+        tokenId: precondition.tokenId.toString(),
+        owned: precondition.owned,
+      }),
+    }
+
+    if (!CAN_RUN_LIVE) {
+      // Mock the ownerOf call
+      ;(provider as any).call.mockResolvedValue(
+        '0x000000000000000000000000' + testWalletAddress.toString().slice(2).toLowerCase(),
+      )
+    }
+
+    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    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 operator = randomAddress()
+    const precondition = new Erc721ApprovalPrecondition(
+      testWalletAddress,
+      ERC20_IMPLICIT_MINT_CONTRACT,
+      1n, // tokenId
+      operator,
+    )
+
+    const intentPrecondition = {
+      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(),
+      }),
+    }
+
+    if (!CAN_RUN_LIVE) {
+      // Mock the getApproved call
+      ;(provider as any).call.mockResolvedValue(
+        '0x000000000000000000000000' + operator.toString().slice(2).toLowerCase(),
+      )
+    }
+
+    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    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 precondition = new Erc1155BalancePrecondition(
+      testWalletAddress,
+      ERC20_IMPLICIT_MINT_CONTRACT,
+      1n, // tokenId
+      1000000n, // 1 token min
+      2000000n, // 2 tokens max
+    )
+
+    const intentPrecondition = {
+      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(),
+      }),
+    }
+
+    if (!CAN_RUN_LIVE) {
+      // Mock the balanceOf call
+      ;(provider as any).call.mockResolvedValue('0x1e8480') // 1.5 tokens in hex
+    }
+
+    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    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 operator = randomAddress()
+    const precondition = new Erc1155ApprovalPrecondition(
+      testWalletAddress,
+      ERC20_IMPLICIT_MINT_CONTRACT,
+      1n, // tokenId
+      operator,
+      1000000n, // 1 token min approval
+    )
+
+    const intentPrecondition = {
+      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(),
+      }),
+    }
+
+    if (!CAN_RUN_LIVE) {
+      // Mock the isApprovedForAll call
+      ;(provider as any).call.mockResolvedValue('0x1') // true
+    }
+
+    const isValid = await relayer.checkPrecondition(intentPrecondition)
+    expect(isValid).toBe(true)
+  })
+})

package/test/preconditions/selectors.test.ts

@@ -0,0 +1,415 @@
+import { Address } from 'ox'
+import { describe, expect, it } from 'vitest'
+
+import {
+  extractChainID,
+  extractSupportedPreconditions,
+  extractNativeBalancePreconditions,
+  extractERC20BalancePreconditions,
+} from '../../src/preconditions/selectors.js'
+import { TransactionPrecondition } from '../../src/preconditions/codec.js'
+import {
+  NativeBalancePrecondition,
+  Erc20BalancePrecondition,
+  Erc721OwnershipPrecondition,
+} from '../../src/preconditions/types.js'
+import { Network } from '@0xsequence/wallet-primitives'
+
+// Test addresses
+const TEST_ADDRESS = Address.from('0x1234567890123456789012345678901234567890')
+const TOKEN_ADDRESS = Address.from('0xabcdefabcdefabcdefabcdefabcdefabcdefabcd')
+
+describe('Preconditions Selectors', () => {
+  describe('extractChainID', () => {
+    it('should extract chainID from valid precondition data', () => {
+      const precondition: TransactionPrecondition = {
+        type: 'native-balance',
+        data: JSON.stringify({
+          address: TEST_ADDRESS,
+          chainID: '1',
+          min: '1000000000000000000',
+        }),
+      }
+
+      const chainId = extractChainID(precondition)
+      expect(chainId).toBe(Network.ChainId.MAINNET)
+    })
+
+    it('should extract large chainID values', () => {
+      const precondition: TransactionPrecondition = {
+        type: 'native-balance',
+        data: JSON.stringify({
+          address: TEST_ADDRESS,
+          chainID: '42161', // Arbitrum chainID
+        }),
+      }
+
+      const chainId = extractChainID(precondition)
+      expect(chainId).toBe(Network.ChainId.ARBITRUM)
+    })
+
+    it('should return undefined when chainID is not present', () => {
+      const precondition: TransactionPrecondition = {
+        type: 'native-balance',
+        data: JSON.stringify({
+          address: TEST_ADDRESS,
+          min: '1000000000000000000',
+        }),
+      }
+
+      const chainId = extractChainID(precondition)
+      expect(chainId).toBeUndefined()
+    })
+
+    it('should return undefined when chainID is falsy', () => {
+      const precondition: TransactionPrecondition = {
+        type: 'native-balance',
+        data: JSON.stringify({
+          address: TEST_ADDRESS,
+          chainID: '',
+          min: '1000000000000000000',
+        }),
+      }
+
+      const chainId = extractChainID(precondition)
+      expect(chainId).toBeUndefined()
+    })
+
+    it('should return undefined when chainID is null', () => {
+      const precondition: TransactionPrecondition = {
+        type: 'native-balance',
+        data: JSON.stringify({
+          address: TEST_ADDRESS,
+          chainID: null,
+          min: '1000000000000000000',
+        }),
+      }
+
+      const chainId = extractChainID(precondition)
+      expect(chainId).toBeUndefined()
+    })
+
+    it('should return undefined for null/undefined precondition', () => {
+      expect(extractChainID(null as any)).toBeUndefined()
+      expect(extractChainID(undefined as any)).toBeUndefined()
+    })
+
+    it('should return undefined for invalid JSON', () => {
+      const precondition: TransactionPrecondition = {
+        type: 'native-balance',
+        data: 'invalid json',
+      }
+
+      const chainId = extractChainID(precondition)
+      expect(chainId).toBeUndefined()
+    })
+
+    it('should handle chainID with value 0', () => {
+      const precondition: TransactionPrecondition = {
+        type: 'native-balance',
+        data: JSON.stringify({
+          address: TEST_ADDRESS,
+          chainID: '0',
+        }),
+      }
+
+      const chainId = extractChainID(precondition)
+      expect(chainId).toBe(0)
+    })
+  })
+
+  describe('extractSupportedPreconditions', () => {
+    it('should extract valid preconditions', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            min: '1000000000000000000',
+          }),
+        },
+        {
+          type: 'erc20-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            min: '1000000',
+          }),
+        },
+      ]
+
+      const results = extractSupportedPreconditions(intents)
+      expect(results).toHaveLength(2)
+      expect(results[0]).toBeInstanceOf(NativeBalancePrecondition)
+      expect(results[1]).toBeInstanceOf(Erc20BalancePrecondition)
+    })
+
+    it('should filter out invalid preconditions', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            min: '1000000000000000000',
+          }),
+        },
+        {
+          type: 'unknown-type',
+          data: JSON.stringify({ address: TEST_ADDRESS }),
+        },
+        {
+          type: 'native-balance',
+          data: 'invalid json',
+        },
+      ]
+
+      const results = extractSupportedPreconditions(intents)
+      expect(results).toHaveLength(1)
+      expect(results[0]).toBeInstanceOf(NativeBalancePrecondition)
+    })
+
+    it('should return empty array for null/undefined input', () => {
+      expect(extractSupportedPreconditions(null as any)).toEqual([])
+      expect(extractSupportedPreconditions(undefined as any)).toEqual([])
+    })
+
+    it('should return empty array for empty input', () => {
+      const results = extractSupportedPreconditions([])
+      expect(results).toEqual([])
+    })
+
+    it('should handle mixed valid and invalid preconditions', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            min: '1000000000000000000',
+          }),
+        },
+        {
+          type: 'erc721-ownership',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            tokenId: '123',
+          }),
+        },
+        {
+          type: 'invalid-type',
+          data: JSON.stringify({ address: TEST_ADDRESS }),
+        },
+      ]
+
+      const results = extractSupportedPreconditions(intents)
+      expect(results).toHaveLength(2)
+      expect(results[0]).toBeInstanceOf(NativeBalancePrecondition)
+      expect(results[1]).toBeInstanceOf(Erc721OwnershipPrecondition)
+    })
+  })
+
+  describe('extractNativeBalancePreconditions', () => {
+    it('should extract only native balance preconditions', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            min: '1000000000000000000',
+          }),
+        },
+        {
+          type: 'erc20-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            min: '1000000',
+          }),
+        },
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            max: '2000000000000000000',
+          }),
+        },
+      ]
+
+      const results = extractNativeBalancePreconditions(intents)
+      expect(results).toHaveLength(2)
+      expect(results[0]).toBeInstanceOf(NativeBalancePrecondition)
+      expect(results[1]).toBeInstanceOf(NativeBalancePrecondition)
+
+      // Verify the specific properties
+      expect(results[0].min).toBe(1000000000000000000n)
+      expect(results[1].max).toBe(2000000000000000000n)
+    })
+
+    it('should return empty array when no native balance preconditions exist', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'erc20-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            min: '1000000',
+          }),
+        },
+        {
+          type: 'erc721-ownership',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            tokenId: '123',
+          }),
+        },
+      ]
+
+      const results = extractNativeBalancePreconditions(intents)
+      expect(results).toEqual([])
+    })
+
+    it('should return empty array for null/undefined input', () => {
+      expect(extractNativeBalancePreconditions(null as any)).toEqual([])
+      expect(extractNativeBalancePreconditions(undefined as any)).toEqual([])
+    })
+
+    it('should return empty array for empty input', () => {
+      const results = extractNativeBalancePreconditions([])
+      expect(results).toEqual([])
+    })
+
+    it('should filter out invalid native balance preconditions', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            min: '1000000000000000000',
+          }),
+        },
+        {
+          type: 'native-balance',
+          data: 'invalid json', // This will be filtered out
+        },
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            // Missing address - this will be filtered out
+            min: '1000000000000000000',
+          }),
+        },
+      ]
+
+      const results = extractNativeBalancePreconditions(intents)
+      expect(results).toHaveLength(1)
+      expect(results[0]).toBeInstanceOf(NativeBalancePrecondition)
+      expect(results[0].min).toBe(1000000000000000000n)
+    })
+  })
+
+  describe('extractERC20BalancePreconditions', () => {
+    it('should extract only ERC20 balance preconditions', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            min: '1000000000000000000',
+          }),
+        },
+        {
+          type: 'erc20-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            min: '1000000',
+          }),
+        },
+        {
+          type: 'erc20-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            max: '2000000',
+          }),
+        },
+      ]
+
+      const results = extractERC20BalancePreconditions(intents)
+      expect(results).toHaveLength(2)
+      expect(results[0]).toBeInstanceOf(Erc20BalancePrecondition)
+      expect(results[1]).toBeInstanceOf(Erc20BalancePrecondition)
+
+      // Verify the specific properties
+      expect(results[0].min).toBe(1000000n)
+      expect(results[1].max).toBe(2000000n)
+      expect(results[0].token).toBe(TOKEN_ADDRESS)
+      expect(results[1].token).toBe(TOKEN_ADDRESS)
+    })
+
+    it('should return empty array when no ERC20 balance preconditions exist', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'native-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            min: '1000000000000000000',
+          }),
+        },
+        {
+          type: 'erc721-ownership',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            tokenId: '123',
+          }),
+        },
+      ]
+
+      const results = extractERC20BalancePreconditions(intents)
+      expect(results).toEqual([])
+    })
+
+    it('should return empty array for null/undefined input', () => {
+      expect(extractERC20BalancePreconditions(null as any)).toEqual([])
+      expect(extractERC20BalancePreconditions(undefined as any)).toEqual([])
+    })
+
+    it('should return empty array for empty input', () => {
+      const results = extractERC20BalancePreconditions([])
+      expect(results).toEqual([])
+    })
+
+    it('should filter out invalid ERC20 balance preconditions', () => {
+      const intents: TransactionPrecondition[] = [
+        {
+          type: 'erc20-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            token: TOKEN_ADDRESS,
+            min: '1000000',
+          }),
+        },
+        {
+          type: 'erc20-balance',
+          data: 'invalid json', // This will be filtered out
+        },
+        {
+          type: 'erc20-balance',
+          data: JSON.stringify({
+            address: TEST_ADDRESS,
+            // Missing token address - this will be filtered out
+            min: '1000000',
+          }),
+        },
+      ]
+
+      const results = extractERC20BalancePreconditions(intents)
+      expect(results).toHaveLength(1)
+      expect(results[0]).toBeInstanceOf(Erc20BalancePrecondition)
+      expect(results[0].min).toBe(1000000n)
+      expect(results[0].token).toBe(TOKEN_ADDRESS)
+    })
+  })
+})