viem 2.30.0 → 2.30.2

package/actions/public/waitForTransactionReceipt.ts

@@ -152,195 +152,196 @@ export async function waitForTransactionReceipt<
   let receipt: GetTransactionReceiptReturnType<chain>
   let retrying = false
 
+  // biome-ignore lint/style/useConst:
+  let _unobserve: () => void
+  let _unwatch: () => void
+
   const { promise, resolve, reject } =
     withResolvers<WaitForTransactionReceiptReturnType<chain>>()
 
   const timer = timeout
-    ? setTimeout(
-        () => reject(new WaitForTransactionReceiptTimeoutError({ hash })),
-        timeout,
-      )
+    ? setTimeout(() => {
+        _unwatch()
+        _unobserve()
+        reject(new WaitForTransactionReceiptTimeoutError({ hash }))
+      }, timeout)
     : undefined
 
-  const _unobserve = observe(
-    observerId,
-    { onReplaced, resolve, reject },
-    (emit) => {
-      const _unwatch = getAction(
-        client,
-        watchBlockNumber,
-        'watchBlockNumber',
-      )({
-        emitMissed: true,
-        emitOnBegin: true,
-        poll: true,
-        pollingInterval,
-        async onBlockNumber(blockNumber_) {
-          const done = (fn: () => void) => {
-            clearTimeout(timer)
-            _unwatch()
-            fn()
-            _unobserve()
+  _unobserve = observe(observerId, { onReplaced, resolve, reject }, (emit) => {
+    _unwatch = getAction(
+      client,
+      watchBlockNumber,
+      'watchBlockNumber',
+    )({
+      emitMissed: true,
+      emitOnBegin: true,
+      poll: true,
+      pollingInterval,
+      async onBlockNumber(blockNumber_) {
+        const done = (fn: () => void) => {
+          clearTimeout(timer)
+          _unwatch()
+          fn()
+          _unobserve()
+        }
+
+        let blockNumber = blockNumber_
+
+        if (retrying) return
+
+        try {
+          // If we already have a valid receipt, let's check if we have enough
+          // confirmations. If we do, then we can resolve.
+          if (receipt) {
+            if (
+              confirmations > 1 &&
+              (!receipt.blockNumber ||
+                blockNumber - receipt.blockNumber + 1n < confirmations)
+            )
+              return
+
+            done(() => emit.resolve(receipt))
+            return
           }
 
-          let blockNumber = blockNumber_
+          // Get the transaction to check if it's been replaced.
+          // We need to retry as some RPC Providers may be slow to sync
+          // up mined transactions.
+          if (!transaction) {
+            retrying = true
+            await withRetry(
+              async () => {
+                transaction = (await getAction(
+                  client,
+                  getTransaction,
+                  'getTransaction',
+                )({ hash })) as GetTransactionReturnType<chain>
+                if (transaction.blockNumber)
+                  blockNumber = transaction.blockNumber
+              },
+              {
+                delay: retryDelay,
+                retryCount,
+              },
+            )
+            retrying = false
+          }
 
-          if (retrying) return
+          // Get the receipt to check if it's been processed.
+          receipt = await getAction(
+            client,
+            getTransactionReceipt,
+            'getTransactionReceipt',
+          )({ hash })
 
-          try {
-            // If we already have a valid receipt, let's check if we have enough
-            // confirmations. If we do, then we can resolve.
-            if (receipt) {
-              if (
-                confirmations > 1 &&
-                (!receipt.blockNumber ||
-                  blockNumber - receipt.blockNumber + 1n < confirmations)
-              )
-                return
+          // Check if we have enough confirmations. If not, continue polling.
+          if (
+            confirmations > 1 &&
+            (!receipt.blockNumber ||
+              blockNumber - receipt.blockNumber + 1n < confirmations)
+          )
+            return
 
-              done(() => emit.resolve(receipt))
+          done(() => emit.resolve(receipt))
+        } catch (err) {
+          // If the receipt is not found, the transaction will be pending.
+          // We need to check if it has potentially been replaced.
+          if (
+            err instanceof TransactionNotFoundError ||
+            err instanceof TransactionReceiptNotFoundError
+          ) {
+            if (!transaction) {
+              retrying = false
               return
             }
 
-            // Get the transaction to check if it's been replaced.
-            // We need to retry as some RPC Providers may be slow to sync
-            // up mined transactions.
-            if (!transaction) {
+            try {
+              replacedTransaction = transaction
+
+              // Let's retrieve the transactions from the current block.
+              // We need to retry as some RPC Providers may be slow to sync
+              // up mined blocks.
               retrying = true
-              await withRetry(
-                async () => {
-                  transaction = (await getAction(
+              const block = await withRetry(
+                () =>
+                  getAction(
                     client,
-                    getTransaction,
-                    'getTransaction',
-                  )({ hash })) as GetTransactionReturnType<chain>
-                  if (transaction.blockNumber)
-                    blockNumber = transaction.blockNumber
-                },
+                    getBlock,
+                    'getBlock',
+                  )({
+                    blockNumber,
+                    includeTransactions: true,
+                  }),
                 {
                   delay: retryDelay,
                   retryCount,
+                  shouldRetry: ({ error }) =>
+                    error instanceof BlockNotFoundError,
                 },
               )
               retrying = false
-            }
 
-            // Get the receipt to check if it's been processed.
-            receipt = await getAction(
-              client,
-              getTransactionReceipt,
-              'getTransactionReceipt',
-            )({ hash })
-
-            // Check if we have enough confirmations. If not, continue polling.
-            if (
-              confirmations > 1 &&
-              (!receipt.blockNumber ||
-                blockNumber - receipt.blockNumber + 1n < confirmations)
-            )
-              return
-
-            done(() => emit.resolve(receipt))
-          } catch (err) {
-            // If the receipt is not found, the transaction will be pending.
-            // We need to check if it has potentially been replaced.
-            if (
-              err instanceof TransactionNotFoundError ||
-              err instanceof TransactionReceiptNotFoundError
-            ) {
-              if (!transaction) {
-                retrying = false
-                return
-              }
-
-              try {
-                replacedTransaction = transaction
-
-                // Let's retrieve the transactions from the current block.
-                // We need to retry as some RPC Providers may be slow to sync
-                // up mined blocks.
-                retrying = true
-                const block = await withRetry(
-                  () =>
-                    getAction(
-                      client,
-                      getBlock,
-                      'getBlock',
-                    )({
-                      blockNumber,
-                      includeTransactions: true,
-                    }),
-                  {
-                    delay: retryDelay,
-                    retryCount,
-                    shouldRetry: ({ error }) =>
-                      error instanceof BlockNotFoundError,
-                  },
-                )
-                retrying = false
-
-                const replacementTransaction = (
-                  block.transactions as {} as Transaction[]
-                ).find(
-                  ({ from, nonce }) =>
-                    from === replacedTransaction!.from &&
-                    nonce === replacedTransaction!.nonce,
-                )
+              const replacementTransaction = (
+                block.transactions as {} as Transaction[]
+              ).find(
+                ({ from, nonce }) =>
+                  from === replacedTransaction!.from &&
+                  nonce === replacedTransaction!.nonce,
+              )
 
-                // If we couldn't find a replacement transaction, continue polling.
-                if (!replacementTransaction) return
+              // If we couldn't find a replacement transaction, continue polling.
+              if (!replacementTransaction) return
 
-                // If we found a replacement transaction, return it's receipt.
-                receipt = await getAction(
-                  client,
-                  getTransactionReceipt,
-                  'getTransactionReceipt',
-                )({
-                  hash: replacementTransaction.hash,
-                })
+              // If we found a replacement transaction, return it's receipt.
+              receipt = await getAction(
+                client,
+                getTransactionReceipt,
+                'getTransactionReceipt',
+              )({
+                hash: replacementTransaction.hash,
+              })
 
-                // Check if we have enough confirmations. If not, continue polling.
-                if (
-                  confirmations > 1 &&
-                  (!receipt.blockNumber ||
-                    blockNumber - receipt.blockNumber + 1n < confirmations)
-                )
-                  return
+              // Check if we have enough confirmations. If not, continue polling.
+              if (
+                confirmations > 1 &&
+                (!receipt.blockNumber ||
+                  blockNumber - receipt.blockNumber + 1n < confirmations)
+              )
+                return
 
-                let reason: ReplacementReason = 'replaced'
-                if (
-                  replacementTransaction.to === replacedTransaction.to &&
-                  replacementTransaction.value === replacedTransaction.value &&
-                  replacementTransaction.input === replacedTransaction.input
-                ) {
-                  reason = 'repriced'
-                } else if (
-                  replacementTransaction.from === replacementTransaction.to &&
-                  replacementTransaction.value === 0n
-                ) {
-                  reason = 'cancelled'
-                }
+              let reason: ReplacementReason = 'replaced'
+              if (
+                replacementTransaction.to === replacedTransaction.to &&
+                replacementTransaction.value === replacedTransaction.value &&
+                replacementTransaction.input === replacedTransaction.input
+              ) {
+                reason = 'repriced'
+              } else if (
+                replacementTransaction.from === replacementTransaction.to &&
+                replacementTransaction.value === 0n
+              ) {
+                reason = 'cancelled'
+              }
 
-                done(() => {
-                  emit.onReplaced?.({
-                    reason,
-                    replacedTransaction: replacedTransaction! as any,
-                    transaction: replacementTransaction,
-                    transactionReceipt: receipt,
-                  })
-                  emit.resolve(receipt)
+              done(() => {
+                emit.onReplaced?.({
+                  reason,
+                  replacedTransaction: replacedTransaction! as any,
+                  transaction: replacementTransaction,
+                  transactionReceipt: receipt,
                 })
-              } catch (err_) {
-                done(() => emit.reject(err_))
-              }
-            } else {
-              done(() => emit.reject(err))
+                emit.resolve(receipt)
+              })
+            } catch (err_) {
+              done(() => emit.reject(err_))
             }
+          } else {
+            done(() => emit.reject(err))
           }
-        },
-      })
-    },
-  )
+        }
+      },
+    })
+  })
 
   return promise
 }

package/actions/public/watchBlocks.ts

@@ -213,12 +213,14 @@ export function watchBlocks<
           )({
             blockTag,
             includeTransactions,
-          }).then((block) => {
-            if (!active) return
-            if (!emitFetched) return
-            onBlock(block as any, undefined)
-            emitFetched = false
           })
+            .then((block) => {
+              if (!active) return
+              if (!emitFetched) return
+              onBlock(block as any, undefined)
+              emitFetched = false
+            })
+            .catch(onError)
         }
 
         const transport = (() => {

package/chains/definitions/bitkub.ts

@@ -2,8 +2,8 @@ import { defineChain } from '../../utils/chain/defineChain.js'
 
 export const bitkub = /*#__PURE__*/ defineChain({
   id: 96,
-  name: 'Bitkub',
-  nativeCurrency: { name: 'Bitkub', symbol: 'KUB', decimals: 18 },
+  name: 'KUB Mainnet',
+  nativeCurrency: { name: 'KUB Coin', symbol: 'KUB', decimals: 18 },
   rpcUrls: {
     default: {
       http: ['https://rpc.bitkubchain.io'],
@@ -11,7 +11,7 @@ export const bitkub = /*#__PURE__*/ defineChain({
   },
   blockExplorers: {
     default: {
-      name: 'Bitkub Chain Mainnet Explorer',
+      name: 'KUB Chain Mainnet Explorer',
       url: 'https://www.bkcscan.com',
       apiUrl: 'https://www.bkcscan.com/api',
     },

package/chains/definitions/chiliz.ts

@@ -11,7 +11,7 @@ export const chiliz = /*#__PURE__*/ defineChain({
   },
   rpcUrls: {
     default: {
-      http: ['https://chiliz-rpc.publicnode.com'],
+      http: ['https://rpc.chiliz.com'],
     },
   },
   blockExplorers: {

package/chains/definitions/jbc.ts

@@ -2,7 +2,7 @@ import { defineChain } from '../../utils/chain/defineChain.js'
 
 export const jbc = /*#__PURE__*/ defineChain({
   id: 8899,
-  name: 'JIBCHAIN L1',
+  name: 'JB Chain',
   network: 'jbc',
   nativeCurrency: { name: 'JBC', symbol: 'JBC', decimals: 18 },
   rpcUrls: {

package/chains/definitions/riseTestnet.ts

@@ -0,0 +1,26 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const riseTestnet = /*#__PURE__*/ defineChain({
+  id: 11_155_931,
+  name: 'RISE Testnet',
+  nativeCurrency: { name: 'RISE Testnet Ether', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://testnet.riselabs.xyz'],
+      webSocket: ['wss://testnet.riselabs.xyz/ws'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Blockscout',
+      url: 'https://explorer.testnet.riselabs.xyz/',
+      apiUrl: 'https://explorer.testnet.riselabs.xyz/api',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xca11bde05977b3631167028862be2a173976ca11',
+    },
+  },
+  testnet: true,
+})

package/chains/index.ts

@@ -427,6 +427,7 @@ export { redstone } from './definitions/redstone.js'
 export { rei } from './definitions/rei.js'
 export { reyaNetwork } from './definitions/reyaNetwork.js'
 export { reddioSepolia } from './definitions/reddioSepolia.js'
+export { riseTestnet } from './definitions/riseTestnet.js'
 export { rivalz } from './definitions/rivalz.js'
 export { rollux } from './definitions/rollux.js'
 export { rolluxTestnet } from './definitions/rolluxTestnet.js'
@@ -602,6 +603,7 @@ export { zilliqa } from './definitions/zilliqa.js'
 export { zilliqaTestnet } from './definitions/zilliqaTestnet.js'
 export { zircuit } from './definitions/zircuit.js'
 export { zircuitGarfieldTestnet } from './definitions/zircuitGarfieldTestnet.js'
+/** @deprecated Use zircuitGarfieldTestnet instead */
 export { zircuitTestnet } from './definitions/zircuitTestnet.js'
 export { zkFair } from './definitions/zkFair.js'
 export { zkFairTestnet } from './definitions/zkFairTestnet.js'

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.30.0'
+export const version = '2.30.2'

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.30.0",
+  "version": "2.30.2",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -190,14 +190,14 @@
     }
   },
   "dependencies": {
-    "@noble/curves": "1.8.2",
-    "@noble/hashes": "1.7.2",
-    "@scure/bip32": "1.6.2",
-    "@scure/bip39": "1.5.4",
+    "@noble/curves": "1.9.1",
+    "@noble/hashes": "1.8.0",
+    "@scure/bip32": "1.7.0",
+    "@scure/bip39": "1.6.0",
     "abitype": "1.0.8",
     "isows": "1.0.7",
-    "ox": "0.6.9",
-    "ws": "8.18.1"
+    "ox": "0.7.1",
+    "ws": "8.18.2"
   },
   "license": "MIT",
   "homepage": "https://viem.sh",

package/utils/rpc/socket.ts

@@ -140,16 +140,17 @@ export async function getSocketRpcClient<socket extends {}>(
             for (const subscription of subscriptions.values())
               subscription.onError?.(new SocketClosedError({ url }))
 
-            // Clear all requests and subscriptions.
-            requests.clear()
-            subscriptions.clear()
-
             // Attempt to reconnect.
             if (reconnect && reconnectCount < attempts)
               setTimeout(async () => {
                 reconnectCount++
                 await setup().catch(console.error)
               }, delay)
+            // Otherwise, clear all requests and subscriptions.
+            else {
+              requests.clear()
+              subscriptions.clear()
+            }
           },
           onError(error_) {
             error = error_
@@ -159,10 +160,6 @@ export async function getSocketRpcClient<socket extends {}>(
             for (const subscription of subscriptions.values())
               subscription.onError?.(error)
 
-            // Clear all requests and subscriptions.
-            requests.clear()
-            subscriptions.clear()
-
             // Make sure socket is definitely closed.
             socketClient?.close()
 
@@ -172,6 +169,11 @@ export async function getSocketRpcClient<socket extends {}>(
                 reconnectCount++
                 await setup().catch(console.error)
               }, delay)
+            // Otherwise, clear all requests and subscriptions.
+            else {
+              requests.clear()
+              subscriptions.clear()
+            }
           },
           onOpen() {
             error = undefined