viem 0.0.1-sushi.26 → 0.1.0

package/dist/chunk-O7T5NQLB.mjs

@@ -1,1091 +0,0 @@
-import {
-  AbiDecodingZeroDataError,
-  BlockNotFoundError,
-  InvalidGasArgumentsError,
-  RawContractError,
-  TransactionNotFoundError,
-  TransactionReceiptNotFoundError,
-  WaitForTransactionReceiptTimeoutError,
-  decodeFunctionResult,
-  encodeEventTopics,
-  encodeFunctionData,
-  extract,
-  extractFunctionName,
-  extractFunctionParams,
-  format,
-  formatBlock,
-  formatFeeHistory,
-  formatLog,
-  formatTransaction,
-  formatTransactionReceipt,
-  formatTransactionRequest,
-  getCache,
-  getContractError,
-  hexToNumber,
-  multicall3Abi,
-  numberToHex,
-  wait,
-  withCache
-} from "./chunk-SD5X7F4U.mjs";
-
-// src/actions/public/call.ts
-async function call(client, {
-  blockNumber,
-  blockTag = "latest",
-  chain,
-  from,
-  accessList,
-  data,
-  gas,
-  gasPrice,
-  maxFeePerGas,
-  maxPriorityFeePerGas,
-  nonce,
-  to,
-  value,
-  ...rest
-}) {
-  if (maxFeePerGas !== void 0 && maxPriorityFeePerGas !== void 0 && maxFeePerGas < maxPriorityFeePerGas)
-    throw new InvalidGasArgumentsError();
-  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
-  const formatter = chain?.formatters?.transactionRequest;
-  const request_ = format(
-    {
-      from,
-      accessList,
-      data,
-      gas,
-      gasPrice,
-      maxFeePerGas,
-      maxPriorityFeePerGas,
-      nonce,
-      to,
-      value,
-      // Pick out extra data that might exist on the chain's transaction request type.
-      ...extract(rest, { formatter })
-    },
-    {
-      formatter: formatter || formatTransactionRequest
-    }
-  );
-  const response = await client.request({
-    method: "eth_call",
-    params: [request_, blockNumberHex || blockTag]
-  });
-  if (response === "0x")
-    return { data: void 0 };
-  return { data: response };
-}
-
-// src/actions/public/simulateContract.ts
-async function simulateContract(client, {
-  abi,
-  address,
-  args,
-  functionName,
-  ...callRequest
-}) {
-  const calldata = encodeFunctionData({
-    abi,
-    args,
-    functionName
-  });
-  try {
-    const { data } = await call(client, {
-      data: calldata,
-      to: address,
-      ...callRequest
-    });
-    const result = decodeFunctionResult({
-      abi,
-      args,
-      functionName,
-      data: data || "0x"
-    });
-    return {
-      result,
-      request: {
-        abi,
-        address,
-        args,
-        functionName,
-        ...callRequest
-      }
-    };
-  } catch (err) {
-    throw getContractError(err, {
-      abi,
-      address,
-      args,
-      docsPath: "/docs/contract/simulateContract",
-      functionName,
-      sender: callRequest.from
-    });
-  }
-}
-
-// src/actions/public/createPendingTransactionFilter.ts
-async function createPendingTransactionFilter(client) {
-  const id = await client.request({
-    method: "eth_newPendingTransactionFilter"
-  });
-  return { id, type: "transaction" };
-}
-
-// src/actions/public/createBlockFilter.ts
-async function createBlockFilter(client) {
-  const id = await client.request({
-    method: "eth_newBlockFilter"
-  });
-  return { id, type: "block" };
-}
-
-// src/actions/public/estimateGas.ts
-async function estimateGas(client, {
-  blockNumber,
-  blockTag = "latest",
-  data,
-  from,
-  gas,
-  gasPrice,
-  maxFeePerGas,
-  maxPriorityFeePerGas,
-  to,
-  value
-}) {
-  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
-  const parameters = {
-    data,
-    from,
-    gas: gas ? numberToHex(gas) : void 0,
-    gasPrice: gasPrice ? numberToHex(gasPrice) : void 0,
-    maxFeePerGas: maxFeePerGas ? numberToHex(maxFeePerGas) : void 0,
-    maxPriorityFeePerGas: maxPriorityFeePerGas ? numberToHex(maxPriorityFeePerGas) : void 0,
-    to,
-    value: value ? numberToHex(value) : void 0
-  };
-  const balance = await client.request({
-    method: "eth_estimateGas",
-    params: [parameters, blockNumberHex || blockTag]
-  });
-  return BigInt(balance);
-}
-
-// src/actions/public/getBalance.ts
-async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
-  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
-  const balance = await client.request({
-    method: "eth_getBalance",
-    params: [address, blockNumberHex || blockTag]
-  });
-  return BigInt(balance);
-}
-
-// src/actions/public/getBlock.ts
-async function getBlock(client, {
-  blockHash,
-  blockNumber,
-  blockTag = "latest",
-  includeTransactions = false
-} = {}) {
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  let block = null;
-  if (blockHash) {
-    block = await client.request({
-      method: "eth_getBlockByHash",
-      params: [blockHash, includeTransactions]
-    });
-  } else {
-    block = await client.request({
-      method: "eth_getBlockByNumber",
-      params: [blockNumberHex || blockTag, includeTransactions]
-    });
-  }
-  if (!block)
-    throw new BlockNotFoundError({ blockHash, blockNumber });
-  return format(block, {
-    formatter: client.chain?.formatters?.block || formatBlock
-  });
-}
-
-// src/actions/public/getBlockNumber.ts
-var cacheKey = (id) => `blockNumber.${id}`;
-function getBlockNumberCache(id) {
-  return getCache(cacheKey(id));
-}
-async function getBlockNumber(client, { maxAge = client.pollingInterval } = {}) {
-  const blockNumberHex = await withCache(
-    () => client.request({
-      method: "eth_blockNumber"
-    }),
-    { cacheKey: cacheKey(client.uid), maxAge }
-  );
-  return BigInt(blockNumberHex);
-}
-
-// src/actions/public/getBlockTransactionCount.ts
-async function getBlockTransactionCount(client, {
-  blockHash,
-  blockNumber,
-  blockTag = "latest"
-} = {}) {
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  let count = null;
-  if (blockHash) {
-    count = await client.request({
-      method: "eth_getBlockTransactionCountByHash",
-      params: [blockHash]
-    });
-  } else {
-    count = await client.request({
-      method: "eth_getBlockTransactionCountByNumber",
-      params: [blockNumberHex || blockTag]
-    });
-  }
-  return hexToNumber(count);
-}
-
-// src/actions/public/getBytecode.ts
-async function getBytecode(client, { address, blockNumber, blockTag = "latest" }) {
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  const hex = await client.request({
-    method: "eth_getCode",
-    params: [address, blockNumberHex || blockTag]
-  });
-  if (hex === "0x")
-    return void 0;
-  return hex;
-}
-
-// src/actions/public/getChainId.ts
-async function getChainId(client) {
-  const chainIdHex = await client.request({ method: "eth_chainId" });
-  return hexToNumber(chainIdHex);
-}
-
-// src/actions/public/getFeeHistory.ts
-async function getFeeHistory(client, {
-  blockCount,
-  blockNumber,
-  blockTag = "latest",
-  rewardPercentiles
-}) {
-  const blockNumberHex = blockNumber ? numberToHex(blockNumber) : void 0;
-  const feeHistory = await client.request({
-    method: "eth_feeHistory",
-    params: [
-      numberToHex(blockCount),
-      blockNumberHex || blockTag,
-      rewardPercentiles
-    ]
-  });
-  return formatFeeHistory(feeHistory);
-}
-
-// src/actions/public/getFilterChanges.ts
-async function getFilterChanges(client, { filter }) {
-  const logs = await client.request({
-    method: "eth_getFilterChanges",
-    params: [filter.id]
-  });
-  return logs.map(
-    (log) => typeof log === "string" ? log : formatLog(log)
-  );
-}
-
-// src/actions/public/getFilterLogs.ts
-async function getFilterLogs(client, { filter }) {
-  const logs = await client.request({
-    method: "eth_getFilterLogs",
-    params: [filter.id]
-  });
-  return logs.map(formatLog);
-}
-
-// src/actions/public/getGasPrice.ts
-async function getGasPrice(client) {
-  const gasPrice = await client.request({
-    method: "eth_gasPrice"
-  });
-  return BigInt(gasPrice);
-}
-
-// src/actions/public/createEventFilter.ts
-async function createEventFilter(client, {
-  address,
-  event,
-  args,
-  fromBlock,
-  toBlock
-} = {}) {
-  let topics = [];
-  if (event)
-    topics = buildFilterTopics({ event, args });
-  const id = await client.request({
-    method: "eth_newFilter",
-    params: [
-      {
-        address,
-        fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
-        toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
-        ...topics.length ? { topics } : {}
-      }
-    ]
-  });
-  return { id, type: "event" };
-}
-function buildFilterTopics({
-  event,
-  args
-}) {
-  const eventName = extractFunctionName(event);
-  const abi = unstable_parseAbi(event);
-  return encodeEventTopics({ abi, eventName, args });
-}
-function unstable_parseAbi(definition) {
-  const name = extractFunctionName(definition);
-  const params = extractFunctionParams(definition);
-  return [
-    {
-      type: "event",
-      name,
-      inputs: params || []
-    }
-  ];
-}
-
-// src/actions/public/getLogs.ts
-async function getLogs(client, {
-  address,
-  blockHash,
-  fromBlock,
-  toBlock,
-  event,
-  args
-} = {}) {
-  let topics = [];
-  if (event) {
-    topics = buildFilterTopics({ event, args });
-  }
-  let logs;
-  if (blockHash) {
-    logs = await client.request({
-      method: "eth_getLogs",
-      params: [{ address, topics, blockHash }]
-    });
-  } else {
-    logs = await client.request({
-      method: "eth_getLogs",
-      params: [
-        {
-          address,
-          topics,
-          fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
-          toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock
-        }
-      ]
-    });
-  }
-  return logs.map(formatLog);
-}
-
-// src/actions/public/getStorageAt.ts
-async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  const data = await client.request({
-    method: "eth_getStorageAt",
-    params: [address, slot, blockNumberHex || blockTag]
-  });
-  return data;
-}
-
-// src/actions/public/getTransaction.ts
-async function getTransaction(client, {
-  blockHash,
-  blockNumber,
-  blockTag = "latest",
-  hash,
-  index
-}) {
-  const blockNumberHex = blockNumber !== void 0 ? numberToHex(blockNumber) : void 0;
-  let transaction = null;
-  if (hash) {
-    transaction = await client.request({
-      method: "eth_getTransactionByHash",
-      params: [hash]
-    });
-  } else if (blockHash) {
-    transaction = await client.request({
-      method: "eth_getTransactionByBlockHashAndIndex",
-      params: [blockHash, numberToHex(index)]
-    });
-  } else if (blockNumberHex || blockTag) {
-    transaction = await client.request({
-      method: "eth_getTransactionByBlockNumberAndIndex",
-      params: [blockNumberHex || blockTag, numberToHex(index)]
-    });
-  }
-  if (!transaction)
-    throw new TransactionNotFoundError({
-      blockHash,
-      blockNumber,
-      blockTag,
-      hash,
-      index
-    });
-  return format(transaction, {
-    formatter: client.chain?.formatters?.transaction || formatTransaction
-  });
-}
-
-// src/actions/public/getTransactionConfirmations.ts
-async function getTransactionConfirmations(client, { hash, transactionReceipt }) {
-  const [blockNumber, transaction] = await Promise.all([
-    getBlockNumber(client),
-    hash ? getTransaction(client, { hash }) : void 0
-  ]);
-  const transactionBlockNumber = transactionReceipt?.blockNumber || transaction?.blockNumber;
-  if (!transactionBlockNumber)
-    return 0n;
-  return blockNumber - transactionBlockNumber + 1n;
-}
-
-// src/actions/public/getTransactionCount.ts
-async function getTransactionCount(client, { address, blockTag = "latest", blockNumber }) {
-  const count = await client.request({
-    method: "eth_getTransactionCount",
-    params: [address, blockNumber ? numberToHex(blockNumber) : blockTag]
-  });
-  return hexToNumber(count);
-}
-
-// src/actions/public/getTransactionReceipt.ts
-async function getTransactionReceipt(client, { hash }) {
-  const receipt = await client.request({
-    method: "eth_getTransactionReceipt",
-    params: [hash]
-  });
-  if (!receipt)
-    throw new TransactionReceiptNotFoundError({ hash });
-  return format(receipt, {
-    formatter: client.chain?.formatters?.transactionReceipt || formatTransactionReceipt
-  });
-}
-
-// src/actions/public/readContract.ts
-async function readContract(client, {
-  abi,
-  address,
-  args,
-  functionName,
-  ...callRequest
-}) {
-  const calldata = encodeFunctionData({
-    abi,
-    args,
-    functionName
-  });
-  try {
-    const { data } = await call(client, {
-      data: calldata,
-      to: address,
-      ...callRequest
-    });
-    return decodeFunctionResult({
-      abi,
-      args,
-      functionName,
-      data: data || "0x"
-    });
-  } catch (err) {
-    throw getContractError(err, {
-      abi,
-      address,
-      args,
-      docsPath: "/docs/contract/readContract",
-      functionName
-    });
-  }
-}
-
-// src/actions/public/multicall.ts
-async function multicall(client, args) {
-  const {
-    allowFailure = true,
-    blockNumber,
-    blockTag,
-    contracts,
-    multicallAddress
-  } = args;
-  const calls = contracts.map(({ abi, address, args: args2, functionName }) => {
-    try {
-      const callData = encodeFunctionData({
-        abi,
-        args: args2,
-        functionName
-      });
-      return {
-        allowFailure: true,
-        callData,
-        target: address
-      };
-    } catch (err) {
-      const error = getContractError(err, {
-        abi,
-        address,
-        args: args2,
-        docsPath: "/docs/contract/multicall",
-        functionName
-      });
-      if (!allowFailure)
-        throw error;
-      return {
-        allowFailure: true,
-        callData: "0x",
-        target: address
-      };
-    }
-  });
-  const results = await readContract(client, {
-    abi: multicall3Abi,
-    address: multicallAddress,
-    args: [calls],
-    blockNumber,
-    blockTag,
-    functionName: "aggregate3"
-  });
-  return results.map(({ returnData, success }, i) => {
-    const { callData } = calls[i];
-    const { abi, address, functionName, args: args2 } = contracts[i];
-    try {
-      if (callData === "0x")
-        throw new AbiDecodingZeroDataError();
-      if (!success)
-        throw new RawContractError({ data: returnData });
-      const result = decodeFunctionResult({
-        abi,
-        data: returnData,
-        functionName
-      });
-      return { result, status: "success" };
-    } catch (err) {
-      const error = getContractError(err, {
-        abi,
-        address,
-        args: args2,
-        docsPath: "/docs/contract/multicall",
-        functionName
-      });
-      if (!allowFailure)
-        throw error;
-      return { error, result: void 0, status: "failure" };
-    }
-  });
-}
-
-// src/actions/public/uninstallFilter.ts
-async function uninstallFilter(client, { filter }) {
-  return client.request({
-    method: "eth_uninstallFilter",
-    params: [filter.id]
-  });
-}
-
-// src/utils/observe.ts
-var listenersCache = /* @__PURE__ */ new Map();
-var cleanupCache = /* @__PURE__ */ new Map();
-var callbackCount = 0;
-function observe(observerId, callbacks, fn) {
-  const callbackId = ++callbackCount;
-  const getListeners = () => listenersCache.get(observerId) || [];
-  const unsubscribe = () => {
-    const listeners2 = getListeners();
-    listenersCache.set(
-      observerId,
-      listeners2.filter((cb) => cb.id !== callbackId)
-    );
-  };
-  const unwatch = () => {
-    const cleanup2 = cleanupCache.get(observerId);
-    if (getListeners().length === 1 && cleanup2)
-      cleanup2();
-    unsubscribe();
-  };
-  const listeners = getListeners();
-  listenersCache.set(observerId, [
-    ...listeners,
-    { id: callbackId, fns: callbacks }
-  ]);
-  if (listeners && listeners.length > 0)
-    return unwatch;
-  let emit = {};
-  for (const key in callbacks) {
-    emit[key] = (...args) => {
-      const listeners2 = getListeners();
-      if (listeners2.length === 0)
-        return;
-      listeners2.forEach((listener) => listener.fns[key]?.(...args));
-    };
-  }
-  const cleanup = fn(emit);
-  if (typeof cleanup === "function")
-    cleanupCache.set(observerId, cleanup);
-  return unwatch;
-}
-
-// src/actions/public/createContractEventFilter.ts
-async function createContractEventFilter(client, {
-  address,
-  abi,
-  args,
-  eventName,
-  fromBlock,
-  toBlock
-}) {
-  const topics = eventName ? encodeEventTopics({
-    abi,
-    args,
-    eventName
-  }) : void 0;
-  const id = await client.request({
-    method: "eth_newFilter",
-    params: [
-      {
-        address,
-        fromBlock: typeof fromBlock === "bigint" ? numberToHex(fromBlock) : fromBlock,
-        toBlock: typeof toBlock === "bigint" ? numberToHex(toBlock) : toBlock,
-        topics
-      }
-    ]
-  });
-  return { id, type: "event" };
-}
-
-// src/utils/poll.ts
-function poll(fn, { emitOnBegin, initialWaitTime, interval }) {
-  let active = true;
-  const unwatch = () => active = false;
-  const watch = async () => {
-    let data;
-    if (emitOnBegin)
-      data = await fn({ unpoll: unwatch });
-    const initialWait = await initialWaitTime?.(data) ?? interval;
-    await wait(initialWait);
-    const poll2 = async () => {
-      if (!active)
-        return;
-      await fn({ unpoll: unwatch });
-      await wait(interval);
-      poll2();
-    };
-    poll2();
-  };
-  watch();
-  return unwatch;
-}
-
-// src/actions/public/watchBlockNumber.ts
-function watchBlockNumber(client, {
-  emitOnBegin = false,
-  emitMissed = false,
-  onBlockNumber,
-  onError,
-  pollingInterval = client.pollingInterval
-}) {
-  const observerId = JSON.stringify([
-    "watchBlockNumber",
-    client.uid,
-    emitOnBegin,
-    emitMissed,
-    pollingInterval
-  ]);
-  let prevBlockNumber;
-  return observe(
-    observerId,
-    { onBlockNumber, onError },
-    (emit) => poll(
-      async () => {
-        try {
-          const blockNumber = await getBlockNumber(client, { maxAge: 0 });
-          if (prevBlockNumber) {
-            if (blockNumber === prevBlockNumber)
-              return;
-            if (blockNumber - prevBlockNumber > 1 && emitMissed) {
-              for (let i = prevBlockNumber + 1n; i < blockNumber; i++) {
-                emit.onBlockNumber(i, prevBlockNumber);
-                prevBlockNumber = i;
-              }
-            }
-          }
-          prevBlockNumber = blockNumber;
-          emit.onBlockNumber(blockNumber, prevBlockNumber);
-        } catch (err) {
-          emit.onError?.(err);
-        }
-      },
-      {
-        emitOnBegin,
-        interval: pollingInterval
-      }
-    )
-  );
-}
-
-// src/actions/public/watchBlocks.ts
-function watchBlocks(client, {
-  blockTag = "latest",
-  emitMissed = false,
-  emitOnBegin = false,
-  onBlock,
-  onError,
-  includeTransactions = false,
-  pollingInterval = client.pollingInterval
-}) {
-  const observerId = JSON.stringify([
-    "watchBlocks",
-    client.uid,
-    emitMissed,
-    emitOnBegin,
-    includeTransactions,
-    pollingInterval
-  ]);
-  let prevBlock;
-  return observe(
-    observerId,
-    { onBlock, onError },
-    (emit) => poll(
-      async () => {
-        try {
-          const block = await getBlock(client, {
-            blockTag,
-            includeTransactions
-          });
-          if (block.number && prevBlock?.number) {
-            if (block.number === prevBlock.number)
-              return;
-            if (block.number - prevBlock.number > 1 && emitMissed) {
-              for (let i = prevBlock?.number + 1n; i < block.number; i++) {
-                const block2 = await getBlock(client, {
-                  blockNumber: i,
-                  includeTransactions
-                });
-                emit.onBlock(block2, prevBlock);
-                prevBlock = block2;
-              }
-            }
-          }
-          emit.onBlock(block, prevBlock);
-          prevBlock = block;
-        } catch (err) {
-          emit.onError?.(err);
-        }
-      },
-      {
-        emitOnBegin,
-        interval: pollingInterval
-      }
-    )
-  );
-}
-
-// src/actions/public/watchContractEvent.ts
-function watchContractEvent(client, {
-  abi,
-  address,
-  args,
-  batch = true,
-  eventName,
-  onError,
-  onLogs,
-  pollingInterval = client.pollingInterval
-}) {
-  const observerId = JSON.stringify([
-    "watchContractEvent",
-    address,
-    args,
-    batch,
-    client.uid,
-    eventName,
-    pollingInterval
-  ]);
-  return observe(observerId, { onLogs, onError }, (emit) => {
-    let filter;
-    const unwatch = poll(
-      async () => {
-        try {
-          if (!filter) {
-            try {
-              filter = await createContractEventFilter(client, {
-                abi,
-                address,
-                args,
-                eventName
-              });
-              return;
-            } catch (err) {
-              unwatch();
-              throw err;
-            }
-          }
-          const logs = await getFilterChanges(client, { filter });
-          if (logs.length === 0)
-            return;
-          if (batch)
-            emit.onLogs(logs);
-          else
-            logs.forEach((log) => emit.onLogs([log]));
-        } catch (err) {
-          emit.onError?.(err);
-        }
-      },
-      {
-        emitOnBegin: true,
-        interval: pollingInterval
-      }
-    );
-    return async () => {
-      if (filter)
-        await uninstallFilter(client, { filter });
-      unwatch();
-    };
-  });
-}
-
-// src/actions/public/watchEvent.ts
-function watchEvent(client, {
-  address,
-  args,
-  batch = true,
-  event,
-  onError,
-  onLogs,
-  pollingInterval = client.pollingInterval
-}) {
-  const observerId = JSON.stringify([
-    "watchEvent",
-    address,
-    args,
-    batch,
-    client.uid,
-    event,
-    pollingInterval
-  ]);
-  return observe(observerId, { onLogs, onError }, (emit) => {
-    let filter;
-    const unwatch = poll(
-      async () => {
-        try {
-          if (!filter) {
-            try {
-              filter = await createEventFilter(client, {
-                address,
-                args,
-                event
-              });
-              return;
-            } catch (err) {
-              unwatch();
-              throw err;
-            }
-          }
-          const logs = await getFilterChanges(client, { filter });
-          if (logs.length === 0)
-            return;
-          if (batch)
-            emit.onLogs(logs);
-          else
-            logs.forEach((log) => emit.onLogs([log]));
-        } catch (err) {
-          emit.onError?.(err);
-        }
-      },
-      {
-        emitOnBegin: true,
-        interval: pollingInterval
-      }
-    );
-    return async () => {
-      if (filter)
-        await uninstallFilter(client, { filter });
-      unwatch();
-    };
-  });
-}
-
-// src/actions/public/watchPendingTransactions.ts
-function watchPendingTransactions(client, {
-  batch = true,
-  onError,
-  onTransactions,
-  pollingInterval = client.pollingInterval
-}) {
-  const observerId = JSON.stringify([
-    "watchPendingTransactions",
-    client.uid,
-    batch,
-    pollingInterval
-  ]);
-  return observe(observerId, { onTransactions, onError }, (emit) => {
-    let filter;
-    const unwatch = poll(
-      async () => {
-        try {
-          if (!filter) {
-            try {
-              filter = await createPendingTransactionFilter(client);
-              return;
-            } catch (err) {
-              unwatch();
-              throw err;
-            }
-          }
-          const hashes = await getFilterChanges(client, { filter });
-          if (hashes.length === 0)
-            return;
-          if (batch)
-            emit.onTransactions(hashes);
-          else
-            hashes.forEach((hash) => emit.onTransactions([hash]));
-        } catch (err) {
-          emit.onError?.(err);
-        }
-      },
-      {
-        emitOnBegin: true,
-        interval: pollingInterval
-      }
-    );
-    return async () => {
-      if (filter)
-        await uninstallFilter(client, { filter });
-      unwatch();
-    };
-  });
-}
-
-// src/actions/public/waitForTransactionReceipt.ts
-async function waitForTransactionReceipt(client, {
-  confirmations = 1,
-  hash,
-  onReplaced,
-  pollingInterval = client.pollingInterval,
-  timeout
-}) {
-  const observerId = JSON.stringify([
-    "waitForTransactionReceipt",
-    client.uid,
-    hash
-  ]);
-  let transaction;
-  let replacedTransaction;
-  let receipt;
-  return new Promise((resolve, reject) => {
-    if (timeout)
-      setTimeout(
-        () => reject(new WaitForTransactionReceiptTimeoutError({ hash })),
-        timeout
-      );
-    const unobserve = observe(
-      observerId,
-      { onReplaced, resolve, reject },
-      (emit) => {
-        const unwatch = watchBlockNumber(client, {
-          emitMissed: true,
-          emitOnBegin: true,
-          pollingInterval,
-          async onBlockNumber(blockNumber) {
-            const done = async (fn) => {
-              unwatch();
-              fn();
-              unobserve();
-            };
-            try {
-              if (receipt) {
-                if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                  return;
-                done(() => emit.resolve(receipt));
-                return;
-              }
-              transaction = await getTransaction(client, { hash });
-              receipt = await getTransactionReceipt(client, { hash });
-              if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                return;
-              done(() => emit.resolve(receipt));
-            } catch (err) {
-              if (transaction && (err instanceof TransactionNotFoundError || err instanceof TransactionReceiptNotFoundError)) {
-                replacedTransaction = transaction;
-                const block = await getBlock(client, {
-                  blockNumber,
-                  includeTransactions: true
-                });
-                const replacementTransaction = block.transactions.find(
-                  ({ from, nonce }) => from === replacedTransaction.from && nonce === replacedTransaction.nonce
-                );
-                if (!replacementTransaction)
-                  return;
-                receipt = await getTransactionReceipt(client, {
-                  hash: replacementTransaction.hash
-                });
-                if (blockNumber - receipt.blockNumber + 1n < confirmations)
-                  return;
-                let reason = "replaced";
-                if (replacementTransaction.to === replacedTransaction.to && replacementTransaction.value === replacedTransaction.value) {
-                  reason = "repriced";
-                } else if (replacementTransaction.from === replacementTransaction.to && replacementTransaction.value === 0n) {
-                  reason = "cancelled";
-                }
-                done(() => {
-                  emit.onReplaced?.({
-                    reason,
-                    replacedTransaction,
-                    transaction: replacementTransaction,
-                    transactionReceipt: receipt
-                  });
-                  emit.resolve(receipt);
-                });
-              } else {
-                done(() => emit.reject(err));
-              }
-            }
-          }
-        });
-        return unwatch;
-      }
-    );
-  });
-}
-
-export {
-  call,
-  simulateContract,
-  createPendingTransactionFilter,
-  createBlockFilter,
-  estimateGas,
-  getBalance,
-  getBlock,
-  getBlockNumberCache,
-  getBlockNumber,
-  getBlockTransactionCount,
-  getBytecode,
-  getChainId,
-  getFeeHistory,
-  getFilterChanges,
-  getFilterLogs,
-  getGasPrice,
-  getLogs,
-  getStorageAt,
-  getTransaction,
-  getTransactionConfirmations,
-  getTransactionCount,
-  getTransactionReceipt,
-  readContract,
-  multicall,
-  uninstallFilter,
-  waitForTransactionReceipt,
-  watchBlockNumber,
-  watchBlocks,
-  watchContractEvent,
-  watchEvent,
-  watchPendingTransactions
-};
-//# sourceMappingURL=chunk-O7T5NQLB.mjs.map