viem 0.0.1-alpha.3 → 0.0.1-alpha.31

package/dist/chunk-NCPBWOQA.js

@@ -0,0 +1,1216 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkJ7QHQ26Yjs = require('./chunk-J7QHQ26Y.js');
+
+// src/actions/public/call.ts
+async function call(client, args) {
+  const {
+    blockNumber,
+    blockTag = "latest",
+    from,
+    accessList,
+    data,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...rest
+  } = args;
+  try {
+    _chunkJ7QHQ26Yjs.assertRequest.call(void 0, args);
+    const blockNumberHex = blockNumber ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, blockNumber) : void 0;
+    const formatter = _optionalChain([client, 'access', _ => _.chain, 'optionalAccess', _2 => _2.formatters, 'optionalAccess', _3 => _3.transactionRequest]);
+    const request_ = _chunkJ7QHQ26Yjs.format.call(void 0, 
+      {
+        from,
+        accessList,
+        data,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ..._chunkJ7QHQ26Yjs.extract.call(void 0, rest, { formatter })
+      },
+      {
+        formatter: formatter || _chunkJ7QHQ26Yjs.formatTransactionRequest
+      }
+    );
+    const response = await client.request({
+      method: "eth_call",
+      params: [request_, blockNumberHex || blockTag]
+    });
+    if (response === "0x")
+      return { data: void 0 };
+    return { data: response };
+  } catch (err) {
+    throw _chunkJ7QHQ26Yjs.getCallError.call(void 0, err, {
+      ...args,
+      chain: client.chain
+    });
+  }
+}
+
+// src/actions/public/simulateContract.ts
+async function simulateContract(client, {
+  abi,
+  address,
+  args,
+  functionName,
+  ...callRequest
+}) {
+  const calldata = _chunkJ7QHQ26Yjs.encodeFunctionData.call(void 0, {
+    abi,
+    args,
+    functionName
+  });
+  try {
+    const { data } = await call(client, {
+      data: calldata,
+      to: address,
+      ...callRequest
+    });
+    const result = _chunkJ7QHQ26Yjs.decodeFunctionResult.call(void 0, {
+      abi,
+      args,
+      functionName,
+      data: data || "0x"
+    });
+    return {
+      result,
+      request: {
+        abi,
+        address,
+        args,
+        functionName,
+        ...callRequest
+      }
+    };
+  } catch (err) {
+    throw _chunkJ7QHQ26Yjs.getContractError.call(void 0, 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/createEventFilter.ts
+async function createEventFilter(client, {
+  address,
+  args,
+  event,
+  fromBlock,
+  toBlock
+} = {}) {
+  let topics = [];
+  if (event)
+    topics = _chunkJ7QHQ26Yjs.encodeEventTopics.call(void 0, {
+      abi: [event],
+      eventName: event.name,
+      args
+    });
+  const id = await client.request({
+    method: "eth_newFilter",
+    params: [
+      {
+        address,
+        fromBlock: typeof fromBlock === "bigint" ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, fromBlock) : fromBlock,
+        toBlock: typeof toBlock === "bigint" ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, toBlock) : toBlock,
+        ...topics.length ? { topics } : {}
+      }
+    ]
+  });
+  return {
+    abi: event ? [event] : void 0,
+    args,
+    eventName: event ? event.name : void 0,
+    id,
+    type: "event"
+  };
+}
+
+// src/actions/public/createContractEventFilter.ts
+async function createContractEventFilter(client, {
+  address,
+  abi,
+  args,
+  eventName,
+  fromBlock,
+  toBlock
+}) {
+  const topics = eventName ? _chunkJ7QHQ26Yjs.encodeEventTopics.call(void 0, {
+    abi,
+    args,
+    eventName
+  }) : void 0;
+  const id = await client.request({
+    method: "eth_newFilter",
+    params: [
+      {
+        address,
+        fromBlock: typeof fromBlock === "bigint" ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, fromBlock) : fromBlock,
+        toBlock: typeof toBlock === "bigint" ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, toBlock) : toBlock,
+        topics
+      }
+    ]
+  });
+  return {
+    abi,
+    args,
+    eventName,
+    id,
+    type: "event"
+  };
+}
+
+// src/actions/public/estimateGas.ts
+async function estimateGas(client, args) {
+  const {
+    accessList,
+    blockNumber,
+    blockTag = "latest",
+    data,
+    from,
+    gas,
+    gasPrice,
+    maxFeePerGas,
+    maxPriorityFeePerGas,
+    nonce,
+    to,
+    value,
+    ...rest
+  } = args;
+  try {
+    _chunkJ7QHQ26Yjs.assertRequest.call(void 0, args);
+    const blockNumberHex = blockNumber ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, blockNumber) : void 0;
+    const formatter = _optionalChain([client, 'access', _4 => _4.chain, 'optionalAccess', _5 => _5.formatters, 'optionalAccess', _6 => _6.transactionRequest]);
+    const request_ = _chunkJ7QHQ26Yjs.format.call(void 0, 
+      {
+        from,
+        accessList,
+        data,
+        gas,
+        gasPrice,
+        maxFeePerGas,
+        maxPriorityFeePerGas,
+        nonce,
+        to,
+        value,
+        // Pick out extra data that might exist on the chain's transaction request type.
+        ..._chunkJ7QHQ26Yjs.extract.call(void 0, rest, { formatter })
+      },
+      {
+        formatter: formatter || _chunkJ7QHQ26Yjs.formatTransactionRequest
+      }
+    );
+    const balance = await client.request({
+      method: "eth_estimateGas",
+      params: [request_, blockNumberHex || blockTag]
+    });
+    return BigInt(balance);
+  } catch (err) {
+    throw _chunkJ7QHQ26Yjs.getEstimateGasError.call(void 0, err, {
+      ...args,
+      chain: client.chain
+    });
+  }
+}
+
+// src/actions/public/estimateContractGas.ts
+async function estimateContractGas(client, {
+  abi,
+  address,
+  args,
+  functionName,
+  ...request
+}) {
+  const data = _chunkJ7QHQ26Yjs.encodeFunctionData.call(void 0, {
+    abi,
+    args,
+    functionName
+  });
+  try {
+    const gas = await estimateGas(client, {
+      data,
+      to: address,
+      ...request
+    });
+    return gas;
+  } catch (err) {
+    throw _chunkJ7QHQ26Yjs.getContractError.call(void 0, err, {
+      abi,
+      address,
+      args,
+      docsPath: "/docs/contract/simulateContract",
+      functionName,
+      sender: request.from
+    });
+  }
+}
+
+// src/actions/public/getBalance.ts
+async function getBalance(client, { address, blockNumber, blockTag = "latest" }) {
+  const blockNumberHex = blockNumber ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, 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 ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, 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 (0, _chunkJ7QHQ26Yjs.BlockNotFoundError)({ blockHash, blockNumber });
+  return _chunkJ7QHQ26Yjs.format.call(void 0, block, {
+    formatter: _optionalChain([client, 'access', _7 => _7.chain, 'optionalAccess', _8 => _8.formatters, 'optionalAccess', _9 => _9.block]) || _chunkJ7QHQ26Yjs.formatBlock
+  });
+}
+
+// src/actions/public/getBlockNumber.ts
+var cacheKey = (id) => `blockNumber.${id}`;
+function getBlockNumberCache(id) {
+  return _chunkJ7QHQ26Yjs.getCache.call(void 0, cacheKey(id));
+}
+async function getBlockNumber(client, { maxAge = client.pollingInterval } = {}) {
+  const blockNumberHex = await _chunkJ7QHQ26Yjs.withCache.call(void 0, 
+    () => 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 ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, 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 _chunkJ7QHQ26Yjs.hexToNumber.call(void 0, count);
+}
+
+// src/actions/public/getBytecode.ts
+async function getBytecode(client, { address, blockNumber, blockTag = "latest" }) {
+  const blockNumberHex = blockNumber !== void 0 ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, 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 _chunkJ7QHQ26Yjs.hexToNumber.call(void 0, chainIdHex);
+}
+
+// src/actions/public/getFeeHistory.ts
+async function getFeeHistory(client, {
+  blockCount,
+  blockNumber,
+  blockTag = "latest",
+  rewardPercentiles
+}) {
+  const blockNumberHex = blockNumber ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, blockNumber) : void 0;
+  const feeHistory = await client.request({
+    method: "eth_feeHistory",
+    params: [
+      _chunkJ7QHQ26Yjs.numberToHex.call(void 0, blockCount),
+      blockNumberHex || blockTag,
+      rewardPercentiles
+    ]
+  });
+  return _chunkJ7QHQ26Yjs.formatFeeHistory.call(void 0, 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) => {
+    if (typeof log === "string")
+      return log;
+    const { eventName, args } = "abi" in filter && filter.abi ? _chunkJ7QHQ26Yjs.decodeEventLog.call(void 0, {
+      abi: filter.abi,
+      data: log.data,
+      topics: log.topics
+    }) : { eventName: void 0, args: void 0 };
+    return _chunkJ7QHQ26Yjs.formatLog.call(void 0, log, { args, eventName });
+  });
+}
+
+// src/actions/public/getFilterLogs.ts
+async function getFilterLogs(client, { filter }) {
+  const logs = await client.request({
+    method: "eth_getFilterLogs",
+    params: [filter.id]
+  });
+  return logs.map((log) => {
+    const { eventName, args } = "abi" in filter && filter.abi ? _chunkJ7QHQ26Yjs.decodeEventLog.call(void 0, {
+      abi: filter.abi,
+      data: log.data,
+      topics: log.topics
+    }) : { eventName: void 0, args: void 0 };
+    return _chunkJ7QHQ26Yjs.formatLog.call(void 0, log, { args, eventName });
+  });
+}
+
+// src/actions/public/getGasPrice.ts
+async function getGasPrice(client) {
+  const gasPrice = await client.request({
+    method: "eth_gasPrice"
+  });
+  return BigInt(gasPrice);
+}
+
+// src/actions/public/getLogs.ts
+async function getLogs(client, {
+  address,
+  blockHash,
+  fromBlock,
+  toBlock,
+  event,
+  args
+} = {}) {
+  let topics = [];
+  if (event)
+    topics = _chunkJ7QHQ26Yjs.encodeEventTopics.call(void 0, {
+      abi: [event],
+      eventName: event.name,
+      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" ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, fromBlock) : fromBlock,
+          toBlock: typeof toBlock === "bigint" ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, toBlock) : toBlock
+        }
+      ]
+    });
+  }
+  return logs.map((log) => {
+    const { eventName, args: args2 } = event ? _chunkJ7QHQ26Yjs.decodeEventLog.call(void 0, {
+      abi: [event],
+      data: log.data,
+      topics: log.topics
+    }) : { eventName: void 0, args: void 0 };
+    return _chunkJ7QHQ26Yjs.formatLog.call(void 0, log, { args: args2, eventName });
+  });
+}
+
+// src/actions/public/getStorageAt.ts
+async function getStorageAt(client, { address, blockNumber, blockTag = "latest", slot }) {
+  const blockNumberHex = blockNumber !== void 0 ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, 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 ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, 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, _chunkJ7QHQ26Yjs.numberToHex.call(void 0, index)]
+    });
+  } else if (blockNumberHex || blockTag) {
+    transaction = await client.request({
+      method: "eth_getTransactionByBlockNumberAndIndex",
+      params: [blockNumberHex || blockTag, _chunkJ7QHQ26Yjs.numberToHex.call(void 0, index)]
+    });
+  }
+  if (!transaction)
+    throw new (0, _chunkJ7QHQ26Yjs.TransactionNotFoundError)({
+      blockHash,
+      blockNumber,
+      blockTag,
+      hash,
+      index
+    });
+  return _chunkJ7QHQ26Yjs.format.call(void 0, transaction, {
+    formatter: _optionalChain([client, 'access', _10 => _10.chain, 'optionalAccess', _11 => _11.formatters, 'optionalAccess', _12 => _12.transaction]) || _chunkJ7QHQ26Yjs.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 = _optionalChain([transactionReceipt, 'optionalAccess', _13 => _13.blockNumber]) || _optionalChain([transaction, 'optionalAccess', _14 => _14.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 ? _chunkJ7QHQ26Yjs.numberToHex.call(void 0, blockNumber) : blockTag]
+  });
+  return _chunkJ7QHQ26Yjs.hexToNumber.call(void 0, 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 (0, _chunkJ7QHQ26Yjs.TransactionReceiptNotFoundError)({ hash });
+  return _chunkJ7QHQ26Yjs.format.call(void 0, receipt, {
+    formatter: _optionalChain([client, 'access', _15 => _15.chain, 'optionalAccess', _16 => _16.formatters, 'optionalAccess', _17 => _17.transactionReceipt]) || _chunkJ7QHQ26Yjs.formatTransactionReceipt
+  });
+}
+
+// src/actions/public/readContract.ts
+async function readContract(client, {
+  abi,
+  address,
+  args,
+  functionName,
+  ...callRequest
+}) {
+  const calldata = _chunkJ7QHQ26Yjs.encodeFunctionData.call(void 0, {
+    abi,
+    args,
+    functionName
+  });
+  try {
+    const { data } = await call(client, {
+      data: calldata,
+      to: address,
+      ...callRequest
+    });
+    return _chunkJ7QHQ26Yjs.decodeFunctionResult.call(void 0, {
+      abi,
+      args,
+      functionName,
+      data: data || "0x"
+    });
+  } catch (err) {
+    throw _chunkJ7QHQ26Yjs.getContractError.call(void 0, 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 = _chunkJ7QHQ26Yjs.encodeFunctionData.call(void 0, {
+        abi,
+        args: args2,
+        functionName
+      });
+      return {
+        allowFailure: true,
+        callData,
+        target: address
+      };
+    } catch (err) {
+      const error = _chunkJ7QHQ26Yjs.getContractError.call(void 0, 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: _chunkJ7QHQ26Yjs.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 (0, _chunkJ7QHQ26Yjs.AbiDecodingZeroDataError)();
+      if (!success)
+        throw new (0, _chunkJ7QHQ26Yjs.RawContractError)({ data: returnData });
+      const result = _chunkJ7QHQ26Yjs.decodeFunctionResult.call(void 0, {
+        abi,
+        data: returnData,
+        functionName
+      });
+      return { result, status: "success" };
+    } catch (err) {
+      const error = _chunkJ7QHQ26Yjs.getContractError.call(void 0, 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) => _optionalChain([listener, 'access', _18 => _18.fns, 'access', _19 => _19[key], 'optionalCall', _20 => _20(...args)]));
+    };
+  }
+  const cleanup = fn(emit);
+  if (typeof cleanup === "function")
+    cleanupCache.set(observerId, cleanup);
+  return unwatch;
+}
+
+// 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 _asyncNullishCoalesce(await _optionalChain([initialWaitTime, 'optionalCall', _21 => _21(data)]), async () => ( interval));
+    await _chunkJ7QHQ26Yjs.wait.call(void 0, initialWait);
+    const poll2 = async () => {
+      if (!active)
+        return;
+      await fn({ unpoll: unwatch });
+      await _chunkJ7QHQ26Yjs.wait.call(void 0, 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) {
+          _optionalChain([emit, 'access', _22 => _22.onError, 'optionalCall', _23 => _23(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 && _optionalChain([prevBlock, 'optionalAccess', _24 => _24.number])) {
+            if (block.number === prevBlock.number)
+              return;
+            if (block.number - prevBlock.number > 1 && emitMissed) {
+              for (let i = _optionalChain([prevBlock, 'optionalAccess', _25 => _25.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) {
+          _optionalChain([emit, 'access', _26 => _26.onError, 'optionalCall', _27 => _27(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 currentBlockNumber;
+    let filter;
+    let initialized = false;
+    const unwatch = poll(
+      async () => {
+        if (!initialized) {
+          try {
+            filter = await createContractEventFilter(client, {
+              abi,
+              address,
+              args,
+              eventName
+            });
+          } catch (e) {
+          }
+          initialized = true;
+          return;
+        }
+        try {
+          let logs;
+          if (filter) {
+            logs = await getFilterChanges(client, { filter });
+          } else {
+            const blockNumber = await getBlockNumber(client);
+            if (currentBlockNumber && currentBlockNumber !== blockNumber) {
+              logs = await getLogs(client, {
+                address,
+                args,
+                fromBlock: blockNumber,
+                toBlock: blockNumber,
+                event: _chunkJ7QHQ26Yjs.getAbiItem.call(void 0, {
+                  abi,
+                  name: eventName
+                })
+              });
+            } else {
+              logs = [];
+            }
+            currentBlockNumber = blockNumber;
+          }
+          if (logs.length === 0)
+            return;
+          if (batch)
+            emit.onLogs(logs);
+          else
+            logs.forEach((log) => emit.onLogs([log]));
+        } catch (err) {
+          _optionalChain([emit, 'access', _28 => _28.onError, 'optionalCall', _29 => _29(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 currentBlockNumber;
+    let filter;
+    let initialized = false;
+    const unwatch = poll(
+      async () => {
+        if (!initialized) {
+          try {
+            filter = await createEventFilter(client, {
+              address,
+              args,
+              event
+            });
+          } catch (e2) {
+          }
+          initialized = true;
+          return;
+        }
+        try {
+          let logs;
+          if (filter) {
+            logs = await getFilterChanges(client, { filter });
+          } else {
+            const blockNumber = await getBlockNumber(client);
+            if (currentBlockNumber && currentBlockNumber !== blockNumber) {
+              logs = await getLogs(client, {
+                address,
+                args,
+                fromBlock: blockNumber,
+                toBlock: blockNumber,
+                event
+              });
+            } else {
+              logs = [];
+            }
+            currentBlockNumber = blockNumber;
+          }
+          if (logs.length === 0)
+            return;
+          if (batch)
+            emit.onLogs(logs);
+          else
+            logs.forEach((log) => emit.onLogs([log]));
+        } catch (err) {
+          _optionalChain([emit, 'access', _30 => _30.onError, 'optionalCall', _31 => _31(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) {
+          _optionalChain([emit, 'access', _32 => _32.onError, 'optionalCall', _33 => _33(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 (0, _chunkJ7QHQ26Yjs.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 _chunkJ7QHQ26Yjs.TransactionNotFoundError || err instanceof _chunkJ7QHQ26Yjs.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(() => {
+                  _optionalChain([emit, 'access', _34 => _34.onReplaced, 'optionalCall', _35 => _35({
+                    reason,
+                    replacedTransaction,
+                    transaction: replacementTransaction,
+                    transactionReceipt: receipt
+                  })]);
+                  emit.resolve(receipt);
+                });
+              } else {
+                done(() => emit.reject(err));
+              }
+            }
+          }
+        });
+        return unwatch;
+      }
+    );
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.call = call; exports.simulateContract = simulateContract; exports.createPendingTransactionFilter = createPendingTransactionFilter; exports.createBlockFilter = createBlockFilter; exports.createEventFilter = createEventFilter; exports.createContractEventFilter = createContractEventFilter; exports.estimateGas = estimateGas; exports.estimateContractGas = estimateContractGas; exports.getBalance = getBalance; exports.getBlock = getBlock; exports.getBlockNumberCache = getBlockNumberCache; exports.getBlockNumber = getBlockNumber; exports.getBlockTransactionCount = getBlockTransactionCount; exports.getBytecode = getBytecode; exports.getChainId = getChainId; exports.getFeeHistory = getFeeHistory; exports.getFilterChanges = getFilterChanges; exports.getFilterLogs = getFilterLogs; exports.getGasPrice = getGasPrice; exports.getLogs = getLogs; exports.getStorageAt = getStorageAt; exports.getTransaction = getTransaction; exports.getTransactionConfirmations = getTransactionConfirmations; exports.getTransactionCount = getTransactionCount; exports.getTransactionReceipt = getTransactionReceipt; exports.readContract = readContract; exports.multicall = multicall; exports.uninstallFilter = uninstallFilter; exports.waitForTransactionReceipt = waitForTransactionReceipt; exports.watchBlockNumber = watchBlockNumber; exports.watchBlocks = watchBlocks; exports.watchContractEvent = watchContractEvent; exports.watchEvent = watchEvent; exports.watchPendingTransactions = watchPendingTransactions;
+//# sourceMappingURL=chunk-NCPBWOQA.js.map