@1delta/providers 0.0.41 → 0.0.43

package/test/multicallRetry.test.ts

@@ -0,0 +1,808 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { Chain } from '@1delta/chain-registry'
+import { multicallRetryUniversal } from '../src/multicall/multicall'
+import { testContractAddress } from './contract'
+import {
+  encodeMulticallResponse,
+  createMockFetch,
+  type FetchCallHistory,
+} from './multicallRetry.testUtils'
+
+describe('multicallRetry - Revert Handling', () => {
+  const chain = Chain.ETHEREUM_MAINNET
+  const overrides = {
+    [Chain.ETHEREUM_MAINNET]: [
+      'https://eth.llamarpc.com',
+      'https://api.zan.top/eth-mainnet',
+      'https://rpc.flashbots.net/fast',
+      'https://rpc.owlracle.info/eth/70d38ce1826c4a60bb2a8e05a6c8b20f',
+      'https://eth.merkle.io',
+      'https://eth-mainnet.nodereal.io/v1/1659dfb40aa24bbb8153a677b98064d7',
+      'wss://eth-mainnet.nodereal.io/ws/v1/1659dfb40aa24bbb8153a677b98064d7',
+      'https://rpc.payload.de',
+      'https://ethereum-rpc.publicnode.com',
+      'https://eth-mainnet.g.alchemy.com/v2/demo',
+      'https://go.getblock.io/aefd01aa907c4805ba3c00a9e5b48c6b',
+      'https://rpc.flashbots.net',
+      'https://public-eth.nownodes.io',
+      'https://ethereum-json-rpc.stakely.io',
+      'https://eth.blockrazor.xyz',
+      'https://eth.drpc.org',
+      'https://ethereum.public.blockpi.network/v1/rpc/public',
+      'https://ethereum-public.nodies.app',
+      'https://0xrpc.io/eth',
+    ],
+  }
+
+  it('handle single revert, return 0x for revert', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'name',
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: overrides,
+    })
+    expect(results).toHaveLength(2)
+    expect(results[0]).toBe('0x')
+    expect(results[1]).not.toBe('0x')
+    expect(typeof results[1]).toBe('string')
+  }, 30000)
+
+  it('should handle multiple reverts', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [999999n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(4)
+    expect(results[0]).toBe('0x')
+    expect(results[1]).not.toBe('0x')
+    expect(results[2]).toBe('0x')
+    expect(results[3]).not.toBe('0x')
+  }, 30000)
+
+  it('should handle duplicate reverted calls', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(4)
+    expect(results[0]).toBe('0x')
+    expect(results[1]).not.toBe('0x')
+    expect(results[2]).toBe('0x')
+    expect(results[3]).not.toBe('0x')
+  }, 30000)
+
+  it('should handle all calls reverting', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [999999n],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).toBe('0x')
+    expect(results[1]).toBe('0x')
+  }, 30000)
+
+  it('should handle all calls succeeding', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).not.toBe('0x')
+    expect(results[1]).not.toBe('0x')
+    expect(typeof results[0]).toBe('string')
+    expect(typeof results[1]).toBe('string')
+  }, 30000)
+
+  it('should maintain correct order of results with reverts', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [999999n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'totalSupply',
+        args: [],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(5)
+    expect(results[0]).not.toBe('0x')
+    expect(results[1]).toBe('0x')
+    expect(results[2]).not.toBe('0x')
+    expect(results[3]).toBe('0x')
+    expect(results[4]).not.toBe('0x')
+  }, 30000)
+
+  it('should handle duplicates and multiple reverts', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [999999n],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(5)
+    expect(results[0]).not.toBe('0x')
+    expect(results[1]).toBe('0x')
+    expect(results[2]).toBe('0x')
+    expect(results[3]).not.toBe('0x')
+    expect(results[4]).toBe('0x')
+  }, 30000)
+
+  it('should work with allowFailure=false for non-revert errors', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: false,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).not.toBe('0x')
+    expect(results[1]).not.toBe('0x')
+  }, 30000)
+
+  it('should handle revert with allowFailure=false', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'ownerOf',
+        args: [543322n],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: false,
+      logErrors: false,
+      overrdies: overrides,
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).toBe('0x')
+    expect(results[1]).not.toBe('0x')
+  }, 30000)
+})
+
+describe('multicallRetry - HTTP and JSON-RPC Error Retry', () => {
+  const chain = Chain.ETHEREUM_MAINNET
+  const rpc1 = 'https://rpc1.test.com'
+  const rpc2 = 'https://rpc2.test.com'
+  const mockName = 'TestToken'
+  const mockSymbol = 'TEST'
+
+  let originalFetch: typeof fetch
+  let fetchCallHistory: FetchCallHistory[]
+
+  beforeEach(() => {
+    fetchCallHistory = []
+    originalFetch = globalThis.fetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    fetchCallHistory = []
+  })
+
+  it('should retry on JSON-RPC error object from first RPC', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const mockName = 'TestToken'
+    const mockSymbol = 'TEST'
+    const successResult = encodeMulticallResponse(
+      calls,
+      testContractAddress.abi,
+      [mockName, mockSymbol],
+    )
+
+    globalThis.fetch = createMockFetch(
+      { [rpc1]: 'jsonrpc-error', [rpc2]: 'success' },
+      successResult,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [rpc1, rpc2] },
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).toBe(mockName)
+    expect(results[1]).toBe(mockSymbol)
+    expect(fetchCallHistory.length).toBe(2)
+    expect(fetchCallHistory[0].url).toBe(rpc1)
+    expect(fetchCallHistory[1].url).toBe(rpc2)
+  }, 30000)
+
+  it('should retry on HTTP 429 from first RPC', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+    ]
+
+    const successResult = encodeMulticallResponse(
+      calls,
+      testContractAddress.abi,
+      [mockName],
+    )
+
+    globalThis.fetch = createMockFetch(
+      { [rpc1]: 'http-429', [rpc2]: 'success' },
+      successResult,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [rpc1, rpc2] },
+    })
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toBe(mockName)
+    expect(fetchCallHistory[0].url).toBe(rpc1)
+    expect(fetchCallHistory[1].url).toBe(rpc2)
+  }, 30000)
+
+  it('should retry on HTTP 5xx from first RPC', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const successResult = encodeMulticallResponse(
+      calls,
+      testContractAddress.abi,
+      [mockSymbol],
+    )
+
+    globalThis.fetch = createMockFetch(
+      { [rpc1]: 'http-503', [rpc2]: 'success' },
+      successResult,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [rpc1, rpc2] },
+    })
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toBe(mockSymbol)
+    expect(fetchCallHistory[0].url).toBe(rpc1)
+    expect(fetchCallHistory[1].url).toBe(rpc2)
+  }, 30000)
+
+  it('should return 0x array when all retries are used and allowFailure=true', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    globalThis.fetch = createMockFetch(
+      { [rpc1]: 'always-fail', [rpc2]: 'always-fail' },
+      undefined,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [rpc1, rpc2] },
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).toBe('0x')
+    expect(results[1]).toBe('0x')
+    expect(fetchCallHistory.length).toBe(4) // 1 initial call + 3 retries
+  }, 30000)
+
+  it('should throw when all retries are used and allowFailure=false', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+    ]
+
+    globalThis.fetch = createMockFetch(
+      { [rpc1]: 'always-fail', [rpc2]: 'always-fail' },
+      undefined,
+      fetchCallHistory,
+    )
+
+    await expect(
+      multicallRetryUniversal({
+        chain,
+        calls,
+        abi: testContractAddress.abi,
+        batchSize: 4096,
+        maxRetries: 0,
+        providerId: 0,
+        allowFailure: false,
+        logErrors: false,
+        overrdies: { [chain]: [rpc1, rpc2] },
+      }),
+    ).rejects.toThrow()
+  }, 30000)
+
+  it('should retry multiple times across all RPCs', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+    ]
+
+    const successResult = encodeMulticallResponse(
+      calls,
+      testContractAddress.abi,
+      [mockName],
+    )
+
+    const rpc3 = 'https://rpc3.test.com'
+    globalThis.fetch = createMockFetch(
+      {
+        [rpc1]: 'http-503',
+        [rpc2]: 'http-503',
+        [rpc3]: 'success',
+      },
+      successResult,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 2,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [rpc1, rpc2, rpc3] },
+    })
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toBe(mockName)
+    expect(fetchCallHistory.some((call) => call.url.includes(rpc3))).toBe(true)
+  }, 30000)
+})
+
+describe('multicallRetry - WebSocket Transport Error Retry', () => {
+  const chain = Chain.ETHEREUM_MAINNET
+  const wsRpc1 = 'wss://rpc1.test.com'
+  const wsRpc2 = 'wss://rpc2.test.com'
+  const httpRpc1 = 'https://rpc1.test.com'
+  const httpRpc2 = 'https://rpc2.test.com'
+  const mockName = 'TestToken'
+  const mockSymbol = 'TEST'
+
+  let originalFetch: typeof fetch
+  let fetchCallHistory: FetchCallHistory[]
+
+  beforeEach(() => {
+    fetchCallHistory = []
+    originalFetch = globalThis.fetch
+  })
+
+  afterEach(() => {
+    globalThis.fetch = originalFetch
+    fetchCallHistory = []
+  })
+
+  it('should retry on WebSocket connection failure and switch to HTTP RPC', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+    ]
+
+    const successResult = encodeMulticallResponse(
+      calls,
+      testContractAddress.abi,
+      [mockName],
+    )
+
+    globalThis.fetch = createMockFetch(
+      { [httpRpc2]: 'success' },
+      successResult,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 2,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [wsRpc1, httpRpc2] },
+    })
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toBe(mockName)
+    expect(fetchCallHistory.some((call) => call.url.includes(httpRpc2))).toBe(
+      true,
+    )
+  }, 30000)
+
+  it('should retry across multiple WebSocket RPCs and fallback to HTTP', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const successResult = encodeMulticallResponse(
+      calls,
+      testContractAddress.abi,
+      [mockSymbol],
+    )
+
+    globalThis.fetch = createMockFetch(
+      { [httpRpc2]: 'success' },
+      successResult,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 2,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [wsRpc1, wsRpc2, httpRpc2] },
+    })
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toBe(mockSymbol)
+    expect(fetchCallHistory.some((call) => call.url.includes(httpRpc2))).toBe(
+      true,
+    )
+  }, 30000)
+
+  it('should handle mixed WebSocket and HTTP RPCs with HTTP failure', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+      {
+        address: testContractAddress.address,
+        name: 'symbol',
+        args: [],
+      },
+    ]
+
+    const successResult = encodeMulticallResponse(
+      calls,
+      testContractAddress.abi,
+      [mockName, mockSymbol],
+    )
+
+    globalThis.fetch = createMockFetch(
+      { [httpRpc1]: 'http-429', [httpRpc2]: 'success' },
+      successResult,
+      fetchCallHistory,
+    )
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 3,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [wsRpc1, httpRpc1, httpRpc2] },
+    })
+
+    expect(results).toHaveLength(2)
+    expect(results[0]).toBe(mockName)
+    expect(results[1]).toBe(mockSymbol)
+    expect(fetchCallHistory.some((call) => call.url.includes(httpRpc2))).toBe(
+      true,
+    )
+  }, 30000)
+
+  it('should handle all WebSocket RPCs failing and return 0x array', async () => {
+    const calls = [
+      {
+        address: testContractAddress.address,
+        name: 'name',
+        args: [],
+      },
+    ]
+
+    const results = await multicallRetryUniversal({
+      chain,
+      calls,
+      abi: testContractAddress.abi,
+      batchSize: 4096,
+      maxRetries: 1,
+      providerId: 0,
+      allowFailure: true,
+      logErrors: false,
+      overrdies: { [chain]: [wsRpc1, wsRpc2] },
+    })
+
+    expect(results).toHaveLength(1)
+    expect(results[0]).toBe('0x')
+  }, 30000)
+})