viem 2.57.4 → 2.57.5

package/actions/public/waitForTransactionReceipt.ts

@@ -11,6 +11,7 @@ import type { ErrorType } from '../../errors/utils.js'
 import type { Chain } from '../../types/chain.js'
 import type { Hash } from '../../types/misc.js'
 import type { Transaction } from '../../types/transaction.js'
+import { isAddressEqual } from '../../utils/address/isAddressEqual.js'
 import { getAction } from '../../utils/getAction.js'
 import { type ObserveErrorType, observe } from '../../utils/observe.js'
 import { withResolvers } from '../../utils/promise/withResolvers.js'
@@ -329,7 +330,7 @@ export async function waitForTransactionReceipt<
                   block.transactions as {} as Transaction[]
                 ).find(
                   ({ from, hash, nonce }) =>
-                    from === replacedTransaction!.from &&
+                    isAddressEqual(from, replacedTransaction!.from) &&
                     hash !== replacedTransaction!.hash &&
                     nonce === replacedTransaction!.nonce,
                 )
@@ -356,7 +357,12 @@ export async function waitForTransactionReceipt<
 
                 let reason: ReplacementReason = 'replaced'
                 if (
-                  replacementTransaction.to === replacedTransaction.to &&
+                  (replacementTransaction.to && replacedTransaction.to
+                    ? isAddressEqual(
+                        replacementTransaction.to,
+                        replacedTransaction.to,
+                      )
+                    : replacementTransaction.to === replacedTransaction.to) &&
                   replacementTransaction.value === replacedTransaction.value &&
                   replacementTransaction.input === replacedTransaction.input
                 ) {

package/actions/wallet/waitForCallsStatus.ts

@@ -69,6 +69,17 @@ export type WaitForCallsStatusErrorType =
   | WaitForCallsStatusTimeoutError
   | ErrorType
 
+const functionIds = /*#__PURE__*/ new WeakMap<object, number>()
+let functionCount = 0
+function getFunctionId(fn: object): number {
+  let fnId = functionIds.get(fn)
+  if (fnId === undefined) {
+    fnId = ++functionCount
+    functionIds.set(fn, fnId)
+  }
+  return fnId
+}
+
 /**
  * Waits for the status & receipts of a call bundle that was sent via `sendCalls`.
  *
@@ -104,7 +115,31 @@ export async function waitForCallsStatus<chain extends Chain | undefined>(
     timeout = 60_000,
     throwOnFailure = false,
   } = parameters
-  const observerId = stringify(['waitForCallsStatus', client.uid, id])
+  const observerId = stringify([
+    'waitForCallsStatus',
+    client.uid,
+    id,
+    // Concurrent calls with different behavior-defining options must not
+    // share an observer: the first call's polling closure decides the
+    // status check, failure handling and retry behavior for everyone.
+    // `timeout` is enforced per caller below, so it is not included.
+    {
+      pollingInterval,
+      retryCount,
+      // Caller-provided functions are keyed by identity, not source text:
+      // two predicates built by the same factory have identical source
+      // but capture different values, so they must not share an observer.
+      // Keying on `parameters.*` (not the destructured defaults) keeps
+      // calls that use the defaults on one shared observer, since the
+      // default functions are recreated on every call.
+      retryDelay:
+        typeof parameters.retryDelay === 'function'
+          ? ['function', getFunctionId(parameters.retryDelay)]
+          : parameters.retryDelay,
+      status: parameters.status ? getFunctionId(parameters.status) : undefined,
+      throwOnFailure,
+    },
+  ])
 
   const { promise, resolve, reject } =
     withResolvers<WaitForCallsStatusReturnType>()
@@ -161,7 +196,11 @@ export async function waitForCallsStatus<chain extends Chain | undefined>(
       }, timeout)
     : undefined
 
-  return await promise
+  // Remove this caller's listener once its promise settles. `done` only
+  // unobserves the caller that started the poll, so a listener from a
+  // concurrent caller would otherwise stay cached and block every later
+  // wait for the same id from polling.
+  return await promise.finally(() => unobserve())
 }
 
 export type WaitForCallsStatusTimeoutErrorType =

package/chains/definitions/arcTestnet.ts

@@ -11,21 +11,24 @@ export const arcTestnet = /*#__PURE__*/ defineChain({
   rpcUrls: {
     default: {
       http: [
-        'https://rpc.testnet.arc.network',
-        'https://rpc.quicknode.testnet.arc.network',
-        'https://rpc.blockdaemon.testnet.arc.network',
+        'https://rpc.testnet.arc.io',
+        'https://rpc.blockdaemon.testnet.arc.io',
+        'https://rpc.drpc.testnet.arc.io',
+        'https://rpc.quicknode.testnet.arc.io',
       ],
       webSocket: [
-        'wss://rpc.testnet.arc.network',
-        'wss://rpc.quicknode.testnet.arc.network',
+        'wss://rpc.testnet.arc.io',
+        'wss://rpc.blockdaemon.testnet.arc.io:443/websocket',
+        'wss://rpc.drpc.testnet.arc.io',
+        'wss://rpc.quicknode.testnet.arc.io',
       ],
     },
   },
   blockExplorers: {
     default: {
-      name: 'ArcScan',
-      url: 'https://testnet.arcscan.app',
-      apiUrl: 'https://testnet.arcscan.app/api',
+      name: 'Arc Explorer',
+      url: 'https://explorer.testnet.arc.io',
+      apiUrl: 'https://explorer.testnet.arc.io/api',
     },
   },
   contracts: {

package/chains/definitions/qmsTestnet.ts

@@ -0,0 +1,27 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const qmsTestnet = /*#__PURE__*/ defineChain({
+  id: 19480,
+  name: 'QMS Testnet',
+  nativeCurrency: { name: 'QMS', symbol: 'QMS', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.testnet.qms.finance'],
+      webSocket: ['wss://rpc.testnet.qms.finance'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'QMS Testnet Explorer',
+      url: 'https://testnet.qmsscan.io',
+      apiUrl: 'https://testnet.qmsscan.io/api',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 0,
+    },
+  },
+  testnet: true,
+})

package/chains/definitions/tempo.ts

@@ -12,7 +12,7 @@ export const tempo = /*#__PURE__*/ defineChain({
   },
   contracts: {
     earnFactory: {
-      address: '0xb5889A96114014d4C032ebD76772c10bF3b97137',
+      address: '0x3085A8003f340CD51C72D9e1a1298CDafB171B02',
     },
     erc4626EngineFactory: {
       address: '0xd43D00981222a8db444A528E69f19E3cE5A7D2Ff',

package/chains/definitions/tempoModerato.ts

@@ -13,10 +13,10 @@ export const tempoModerato = /*#__PURE__*/ defineChain({
   },
   contracts: {
     earnFactory: {
-      address: '0xb5889A96114014d4C032ebD76772c10bF3b97137',
+      address: '0x1de6B233984583F4d936ae4265f3b60282b70cc6',
     },
     erc4626EngineFactory: {
-      address: '0xd43D00981222a8db444A528E69f19E3cE5A7D2Ff',
+      address: '0x0d57c10249eb3a92b7d81bBA6221F80F2865448A',
     },
   },
   name: 'Tempo Testnet (Moderato)',

package/chains/index.ts

@@ -519,6 +519,7 @@ export { pumpfiTestnet } from './definitions/pumpfiTestnet.js'
 export { pyrope } from './definitions/pyrope.js'
 export { ql1 } from './definitions/ql1.js'
 export { qMainnet } from './definitions/qMainnet.js'
+export { qmsTestnet } from './definitions/qmsTestnet.js'
 export { qTestnet } from './definitions/qTestnet.js'
 export { quai } from './definitions/quai.js'
 export { quaiTestnet } from './definitions/quaiTestnet.js'

package/clients/transports/ipc.ts

@@ -133,42 +133,51 @@ export function ipc(
         },
         async subscribe({ params, onData, onError }: any) {
           const rpcClient = await getIpcRpcClient(path)
-          const { result: subscriptionId } = await new Promise<any>(
-            (resolve, reject) =>
+          // Updated when the subscription is re-established after a reconnect.
+          let subscriptionId: Hash
+          let unsubscribed = false
+          function unsubscribe() {
+            unsubscribed = true
+            return new Promise<any>((resolve) =>
               rpcClient.request({
                 body: {
-                  method: 'eth_subscribe',
-                  params,
-                },
-                onResponse(response) {
-                  if (response.error) {
-                    reject(response.error)
-                    onError?.(response.error)
-                    return
-                  }
-
-                  if (typeof response.id === 'number') {
-                    resolve(response)
-                    return
-                  }
-                  if (response.method !== 'eth_subscription') return
-                  onData(response.params)
+                  method: 'eth_unsubscribe',
+                  params: [subscriptionId],
                 },
+                onResponse: resolve,
               }),
+            )
+          }
+          await new Promise<any>((resolve, reject) =>
+            rpcClient.request({
+              body: {
+                method: 'eth_subscribe',
+                params,
+              },
+              onResponse(response) {
+                if (response.error) {
+                  reject(response.error)
+                  onError?.(response.error)
+                  return
+                }
+
+                if (typeof response.id === 'number') {
+                  subscriptionId = response.result
+                  // Re-subscribed while an unsubscribe was in flight.
+                  if (unsubscribed) unsubscribe()
+                  resolve(response)
+                  return
+                }
+                if (response.method !== 'eth_subscription') return
+                onData(response.params)
+              },
+            }),
           )
           return {
-            subscriptionId,
-            async unsubscribe() {
-              return new Promise<any>((resolve) =>
-                rpcClient.request({
-                  body: {
-                    method: 'eth_unsubscribe',
-                    params: [subscriptionId],
-                  },
-                  onResponse: resolve,
-                }),
-              )
+            get subscriptionId() {
+              return subscriptionId
             },
+            unsubscribe,
           }
         },
       },

package/clients/transports/webSocket.ts

@@ -154,47 +154,56 @@ export function webSocket(
         },
         async subscribe({ params, onData, onError }: any) {
           const rpcClient = await getWebSocketRpcClient(url_, wsRpcClientOpts)
-          const { result: subscriptionId } = await new Promise<any>(
-            (resolve, reject) =>
+          // Updated when the subscription is re-established after a reconnect.
+          let subscriptionId: Hash
+          let unsubscribed = false
+          function unsubscribe() {
+            unsubscribed = true
+            return new Promise<any>((resolve) =>
               rpcClient.request({
                 body: {
-                  method: 'eth_subscribe',
-                  params,
+                  method: 'eth_unsubscribe',
+                  params: [subscriptionId],
                 },
-                onError(error) {
-                  reject(error)
-                  onError?.(error)
+                onResponse: resolve,
+              }),
+            )
+          }
+          await new Promise<any>((resolve, reject) =>
+            rpcClient.request({
+              body: {
+                method: 'eth_subscribe',
+                params,
+              },
+              onError(error) {
+                reject(error)
+                onError?.(error)
+                return
+              },
+              onResponse(response) {
+                if (response.error) {
+                  reject(response.error)
+                  onError?.(response.error)
                   return
-                },
-                onResponse(response) {
-                  if (response.error) {
-                    reject(response.error)
-                    onError?.(response.error)
-                    return
-                  }
+                }
 
-                  if (typeof response.id === 'number') {
-                    resolve(response)
-                    return
-                  }
-                  if (response.method !== 'eth_subscription') return
-                  onData(response.params)
-                },
-              }),
+                if (typeof response.id === 'number') {
+                  subscriptionId = response.result
+                  // Re-subscribed while an unsubscribe was in flight.
+                  if (unsubscribed) unsubscribe()
+                  resolve(response)
+                  return
+                }
+                if (response.method !== 'eth_subscription') return
+                onData(response.params)
+              },
+            }),
           )
           return {
-            subscriptionId,
-            async unsubscribe() {
-              return new Promise<any>((resolve) =>
-                rpcClient.request({
-                  body: {
-                    method: 'eth_unsubscribe',
-                    params: [subscriptionId],
-                  },
-                  onResponse: resolve,
-                }),
-              )
+            get subscriptionId() {
+              return subscriptionId
             },
+            unsubscribe,
           }
         },
       },

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.57.4'
+export const version = '2.57.5'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.57.4",
+  "version": "2.57.5",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -229,7 +229,7 @@
     "@scure/bip39": "1.6.0",
     "abitype": "1.2.3",
     "isows": "1.0.7",
-    "ox": "0.14.54",
+    "ox": "0.14.56",
     "ws": "8.21.0"
   },
   "license": "MIT",