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

package/test/preconditions/selectors.test.ts

@@ -15,104 +15,71 @@ import {
 } 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')
+// Test addresses (strings for TransactionPrecondition)
+const TEST_ADDRESS = '0x1234567890123456789012345678901234567890'
+const TOKEN_ADDRESS = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd'
+const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
+
+function nativePrecondition(overrides: Partial<TransactionPrecondition> = {}): TransactionPrecondition {
+  return {
+    type: 'native-balance',
+    chainId: Network.ChainId.MAINNET,
+    ownerAddress: TEST_ADDRESS,
+    tokenAddress: ZERO_ADDRESS,
+    minAmount: 1000000000000000000n,
+    ...overrides,
+  }
+}
+
+function erc20Precondition(overrides: Partial<TransactionPrecondition> = {}): TransactionPrecondition {
+  return {
+    type: 'erc20-balance',
+    chainId: Network.ChainId.MAINNET,
+    ownerAddress: TEST_ADDRESS,
+    tokenAddress: TOKEN_ADDRESS,
+    minAmount: 1000000n,
+    ...overrides,
+  }
+}
+
+function erc721OwnershipPrecondition(overrides: Partial<TransactionPrecondition> = {}): TransactionPrecondition {
+  return {
+    type: 'erc721-ownership',
+    chainId: Network.ChainId.MAINNET,
+    ownerAddress: TEST_ADDRESS,
+    tokenAddress: TOKEN_ADDRESS,
+    minAmount: 0n,
+    ...overrides,
+  }
+}
 
 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 precondition = nativePrecondition({ chainId: Network.ChainId.MAINNET })
       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 precondition = nativePrecondition({ chainId: Network.ChainId.ARBITRUM })
       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 precondition = { type: 'native-balance', ownerAddress: TEST_ADDRESS, tokenAddress: ZERO_ADDRESS, minAmount: 1n } as TransactionPrecondition
       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()
+      expect(extractChainID(null as unknown as TransactionPrecondition)).toBeUndefined()
+      expect(extractChainID(undefined as unknown as TransactionPrecondition)).toBeUndefined()
     })
 
     it('should handle chainID with value 0', () => {
-      const precondition: TransactionPrecondition = {
-        type: 'native-balance',
-        data: JSON.stringify({
-          address: TEST_ADDRESS,
-          chainID: '0',
-        }),
-      }
-
+      const precondition = nativePrecondition({ chainId: 0 })
       const chainId = extractChainID(precondition)
       expect(chainId).toBe(0)
     })
@@ -121,21 +88,8 @@ describe('Preconditions Selectors', () => {
   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',
-          }),
-        },
+        nativePrecondition(),
+        erc20Precondition(),
       ]
 
       const results = extractSupportedPreconditions(intents)
@@ -146,21 +100,9 @@ describe('Preconditions Selectors', () => {
 
     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',
-        },
+        nativePrecondition(),
+        { type: 'unknown-type', chainId: 1, ownerAddress: TEST_ADDRESS, tokenAddress: ZERO_ADDRESS, minAmount: 0n } as TransactionPrecondition,
+        nativePrecondition({ ownerAddress: '' }),
       ]
 
       const results = extractSupportedPreconditions(intents)
@@ -169,8 +111,8 @@ describe('Preconditions Selectors', () => {
     })
 
     it('should return empty array for null/undefined input', () => {
-      expect(extractSupportedPreconditions(null as any)).toEqual([])
-      expect(extractSupportedPreconditions(undefined as any)).toEqual([])
+      expect(extractSupportedPreconditions(null as unknown as TransactionPrecondition[])).toEqual([])
+      expect(extractSupportedPreconditions(undefined as unknown as TransactionPrecondition[])).toEqual([])
     })
 
     it('should return empty array for empty input', () => {
@@ -180,25 +122,9 @@ describe('Preconditions Selectors', () => {
 
     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 }),
-        },
+        nativePrecondition(),
+        erc721OwnershipPrecondition(),
+        { type: 'invalid-type', chainId: 1, ownerAddress: TEST_ADDRESS, tokenAddress: ZERO_ADDRESS, minAmount: 0n } as TransactionPrecondition,
       ]
 
       const results = extractSupportedPreconditions(intents)
@@ -211,58 +137,23 @@ describe('Preconditions Selectors', () => {
   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',
-          }),
-        },
+        nativePrecondition({ minAmount: 1000000000000000000n }),
+        erc20Precondition(),
+        nativePrecondition({ minAmount: 2000000000000000000n }),
       ]
 
       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)
+      expect(results[1].min).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',
-          }),
-        },
+        erc20Precondition(),
+        erc721OwnershipPrecondition(),
       ]
 
       const results = extractNativeBalancePreconditions(intents)
@@ -270,8 +161,8 @@ describe('Preconditions Selectors', () => {
     })
 
     it('should return empty array for null/undefined input', () => {
-      expect(extractNativeBalancePreconditions(null as any)).toEqual([])
-      expect(extractNativeBalancePreconditions(undefined as any)).toEqual([])
+      expect(extractNativeBalancePreconditions(null as unknown as TransactionPrecondition[])).toEqual([])
+      expect(extractNativeBalancePreconditions(undefined as unknown as TransactionPrecondition[])).toEqual([])
     })
 
     it('should return empty array for empty input', () => {
@@ -281,24 +172,8 @@ describe('Preconditions Selectors', () => {
 
     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',
-          }),
-        },
+        nativePrecondition({ minAmount: 1000000000000000000n }),
+        nativePrecondition({ ownerAddress: '' }),
       ]
 
       const results = extractNativeBalancePreconditions(intents)
@@ -311,60 +186,25 @@ describe('Preconditions Selectors', () => {
   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',
-          }),
-        },
+        nativePrecondition(),
+        erc20Precondition({ minAmount: 1000000n }),
+        erc20Precondition({ minAmount: 2000000n }),
       ]
 
       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)
+      expect(results[1].min).toBe(2000000n)
+      expect(results[0].token).toEqual(Address.from(TOKEN_ADDRESS))
+      expect(results[1].token).toEqual(Address.from(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',
-          }),
-        },
+        nativePrecondition(),
+        erc721OwnershipPrecondition(),
       ]
 
       const results = extractERC20BalancePreconditions(intents)
@@ -372,8 +212,8 @@ describe('Preconditions Selectors', () => {
     })
 
     it('should return empty array for null/undefined input', () => {
-      expect(extractERC20BalancePreconditions(null as any)).toEqual([])
-      expect(extractERC20BalancePreconditions(undefined as any)).toEqual([])
+      expect(extractERC20BalancePreconditions(null as unknown as TransactionPrecondition[])).toEqual([])
+      expect(extractERC20BalancePreconditions(undefined as unknown as TransactionPrecondition[])).toEqual([])
     })
 
     it('should return empty array for empty input', () => {
@@ -383,33 +223,15 @@ describe('Preconditions Selectors', () => {
 
     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',
-          }),
-        },
+        erc20Precondition({ minAmount: 1000000n }),
+        erc20Precondition({ tokenAddress: '' }),
       ]
 
       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)
+      expect(results[0].token).toEqual(Address.from(TOKEN_ADDRESS))
     })
   })
 })

package/test/preconditions/types.test.ts

@@ -179,7 +179,7 @@ describe('Preconditions Types', () => {
         TEST_ADDRESS,
         TOKEN_ADDRESS,
         OPERATOR_ADDRESS,
-        undefined as any,
+        undefined as unknown as bigint,
       )
 
       const error = precondition.isValid()
@@ -224,7 +224,7 @@ describe('Preconditions Types', () => {
     })
 
     it('should validate tokenId is required', () => {
-      const precondition = new Erc721OwnershipPrecondition(TEST_ADDRESS, TOKEN_ADDRESS, undefined as any)
+      const precondition = new Erc721OwnershipPrecondition(TEST_ADDRESS, TOKEN_ADDRESS, undefined as unknown as bigint)
 
       const error = precondition.isValid()
       expect(error).toBeInstanceOf(Error)
@@ -271,7 +271,7 @@ describe('Preconditions Types', () => {
       const precondition = new Erc721ApprovalPrecondition(
         TEST_ADDRESS,
         TOKEN_ADDRESS,
-        undefined as any,
+        undefined as unknown as bigint,
         OPERATOR_ADDRESS,
       )
 
@@ -319,7 +319,7 @@ describe('Preconditions Types', () => {
     })
 
     it('should validate tokenId is required', () => {
-      const precondition = new Erc1155BalancePrecondition(TEST_ADDRESS, TOKEN_ADDRESS, undefined as any)
+      const precondition = new Erc1155BalancePrecondition(TEST_ADDRESS, TOKEN_ADDRESS, undefined as unknown as bigint)
 
       const error = precondition.isValid()
       expect(error).toBeInstanceOf(Error)
@@ -402,7 +402,7 @@ describe('Preconditions Types', () => {
       const precondition = new Erc1155ApprovalPrecondition(
         TEST_ADDRESS,
         TOKEN_ADDRESS,
-        undefined as any,
+        undefined as unknown as bigint,
         OPERATOR_ADDRESS,
         1000000n,
       )
@@ -432,7 +432,7 @@ describe('Preconditions Types', () => {
         TOKEN_ADDRESS,
         123n,
         OPERATOR_ADDRESS,
-        undefined as any,
+        undefined as unknown as bigint,
       )
 
       const error = precondition.isValid()

package/test/relayer/relayer.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi, beforeEach } from 'vitest'
 import { Address, Hex } from 'ox'
 import { Network, Payload } from '@0xsequence/wallet-primitives'
-import { Relayer, RelayerGen } from '@0xsequence/relayer'
+import { Relayer, RpcRelayerGen } from '@0xsequence/relayer'
 
 // Test addresses and data
 const TEST_WALLET_ADDRESS = Address.from('0x1234567890123456789012345678901234567890')
@@ -127,7 +127,7 @@ describe('Relayer', () => {
           symbol: 'ETH',
           decimals: 18,
           logoURL: 'https://example.com/eth.png',
-          type: 'NATIVE' as RelayerGen.FeeTokenType,
+          type: 'NATIVE' as RpcRelayerGen.FeeTokenType,
           contractAddress: undefined,
         },
         to: TEST_TO_ADDRESS,
@@ -310,7 +310,7 @@ describe('Relayer', () => {
       const isAvailable = await mockRelayer.isAvailable(TEST_WALLET_ADDRESS, TEST_CHAIN_ID)
       expect(isAvailable).toBe(true)
 
-      const feeOptions = await mockRelayer.feeOptions(TEST_WALLET_ADDRESS, TEST_CHAIN_ID, [])
+      const feeOptions = await mockRelayer.feeOptions(TEST_WALLET_ADDRESS, TEST_CHAIN_ID, TEST_TO_ADDRESS, [])
       expect(feeOptions.options).toEqual([])
 
       const relayResult = await mockRelayer.relay(TEST_TO_ADDRESS, TEST_DATA, TEST_CHAIN_ID)
@@ -319,7 +319,7 @@ describe('Relayer', () => {
       const statusResult = await mockRelayer.status(TEST_OP_HASH, TEST_CHAIN_ID)
       expect(statusResult.status).toBe('confirmed')
 
-      const preconditionResult = await mockRelayer.checkPrecondition({} as any)
+      const preconditionResult = await mockRelayer.checkPrecondition({} as { type: string })
       expect(preconditionResult).toBe(true)
     })
   })