viem 2.56.1 → 2.56.3

package/tempo/Storage.ts

@@ -1,115 +0,0 @@
-import type { MaybePromise } from '../types/utils.js'
-
-export type Storage = {
-  getItem(key: string): MaybePromise<string | null | undefined>
-  setItem(key: string, value: string): MaybePromise<void>
-  removeItem(key: string): MaybePromise<void>
-}
-
-/**
- * Wraps a base storage with an optional key prefix and request
- * deduplication — concurrent `getItem` calls for the same key share
- * a single in-flight promise.
- *
- * @example
- * ```ts
- * import { Storage } from 'viem/tempo'
- *
- * const storage = Storage.from(Storage.memory(), { key: 'tempo' })
- * await storage.setItem('foo', 'bar')
- * // stored under "tempo:foo"
- * ```
- */
-export function from(storage: Storage, options: from.Options = {}): Storage {
-  const { key } = options
-  const prefix = key ? `${key}:` : ''
-  const inflight = new Map<string, Promise<string | null | undefined>>()
-  return {
-    getItem(k) {
-      const fullKey = `${prefix}${k}`
-      const existing = inflight.get(fullKey)
-      if (existing) return existing
-      const result = Promise.resolve(storage.getItem(fullKey)).finally(() => {
-        inflight.delete(fullKey)
-      })
-      inflight.set(fullKey, result)
-      return result
-    },
-    setItem(k, value) {
-      const fullKey = `${prefix}${k}`
-      inflight.delete(fullKey)
-      return storage.setItem(fullKey, value)
-    },
-    removeItem(k) {
-      const fullKey = `${prefix}${k}`
-      inflight.delete(fullKey)
-      return storage.removeItem(fullKey)
-    },
-  }
-}
-
-export declare namespace from {
-  type Options = {
-    /** Key prefix prepended to all storage keys. */
-    key?: string | undefined
-  }
-}
-
-/** Creates an in-memory storage backed by a `Map`. */
-export function memory(options: from.Options = {}): Storage {
-  const store = new Map<string, string>()
-  return from(
-    {
-      getItem(key) {
-        return store.get(key) ?? null
-      },
-      setItem(key, value) {
-        store.set(key, value)
-      },
-      removeItem(key) {
-        store.delete(key)
-      },
-    },
-    options,
-  )
-}
-
-/** Creates a storage backed by `globalThis.sessionStorage`. */
-export function session(options: from.Options = {}): Storage {
-  return from(
-    {
-      getItem(key) {
-        return globalThis.sessionStorage.getItem(key)
-      },
-      setItem(key, value) {
-        try {
-          globalThis.sessionStorage.setItem(key, value)
-        } catch {}
-      },
-      removeItem(key) {
-        globalThis.sessionStorage.removeItem(key)
-      },
-    },
-    options,
-  )
-}
-
-let _default: Storage | undefined
-
-/**
- * Returns the default storage for the current environment.
- *
- * Returns a singleton so that the zone transport and actions share the
- * same instance without requiring explicit plumbing.
- *
- * - Browser: `sessionStorage`
- * - Server/unsupported: in-memory `Map`-based storage
- */
-export function defaultStorage(): Storage {
-  if (_default) return _default
-  try {
-    if (globalThis.sessionStorage) _default = session()
-  } catch {}
-  _default ??= memory()
-  return _default
-}

package/tempo/internal/multisig.ts

@@ -1,72 +0,0 @@
-import type { Address } from 'abitype'
-import type { MultisigConfig } from 'ox/tempo'
-import { BaseError } from '../../errors/base.js'
-import { ContractFunctionRevertedError } from '../../errors/contract.js'
-import type { MultisigAccount } from '../Account.js'
-import type { MultisigOwnerState } from '../Transaction.js'
-
-/** @internal */
-export function createMultisigStateResolver(
-  getConfig: (account: Address) => Promise<{
-    owners: MultisigConfig.Config['owners']
-    threshold: MultisigConfig.Config['threshold']
-    version: bigint
-  }>,
-) {
-  // Cache only within one operation because config versions can change between requests.
-  const cache = new Map<Address, Promise<MultisigOwnerState>>()
-  return (account: Address): Promise<MultisigOwnerState> => {
-    const address = account.toLowerCase() as Address
-    const cached = cache.get(address)
-    if (cached) return cached
-
-    const state = (async () => {
-      try {
-        const config = await getConfig(account)
-        return {
-          account,
-          config: { owners: config.owners, threshold: config.threshold },
-          initialized: true,
-          version: config.version,
-        }
-      } catch (error) {
-        const cause =
-          error instanceof BaseError
-            ? error.walk(
-                (error) => error instanceof ContractFunctionRevertedError,
-              )
-            : undefined
-        if (
-          !(cause instanceof ContractFunctionRevertedError) ||
-          cause.data?.errorName !== 'NotMultisigAccount'
-        )
-          throw error
-        return { account, initialized: false, version: 0n }
-      }
-    })()
-    cache.set(address, state)
-    return state
-  }
-}
-
-/** @internal */
-export function getMultisigOwnerStates(
-  account: MultisigAccount,
-  getState: (account: Address) => Promise<MultisigOwnerState>,
-): Promise<readonly MultisigOwnerState[]> {
-  // Collect locally first so all config reads start in one latency wave.
-  const owners: MultisigAccount[] = [account]
-  const seen = new Set<Address>([account.address.toLowerCase() as Address])
-  const visit = (account: MultisigAccount) => {
-    for (const owner of account.owners) {
-      if (owner.source !== 'multisig') continue
-      const address = owner.address.toLowerCase() as Address
-      if (seen.has(address)) continue
-      seen.add(address)
-      owners.push(owner as MultisigAccount)
-      visit(owner as MultisigAccount)
-    }
-  }
-  visit(account)
-  return Promise.all(owners.map((owner) => getState(owner.address)))
-}