@sentio/sdk 2.40.0-rc.5 → 2.40.0-rc.6

package/lib/chunk-LWKILLQ6.js

@@ -1,820 +0,0 @@
-import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
-import {
-  BaseProcessor,
-  BaseProcessorTemplate,
-  BoundContractView,
-  ContractView,
-  DummyProvider,
-  EACAggregatorProxy__factory,
-  addContractByABI,
-  addProcessor,
-  getContractByABI,
-  getProcessor,
-  getProvider,
-  import_chain,
-  transformEtherError
-} from "./chunk-OAIP7J4S.js";
-import {
-  __export,
-  __publicField
-} from "./chunk-AXRHIURD.js";
-
-// src/eth/builtin/eacaggregatorproxy.ts
-var eacaggregatorproxy_exports = {};
-__export(eacaggregatorproxy_exports, {
-  EACAggregatorProxyBoundContractView: () => EACAggregatorProxyBoundContractView,
-  EACAggregatorProxyContractView: () => EACAggregatorProxyContractView,
-  EACAggregatorProxyProcessor: () => EACAggregatorProxyProcessor,
-  EACAggregatorProxyProcessorTemplate: () => EACAggregatorProxyProcessorTemplate,
-  EACAggregatorProxy__factory: () => EACAggregatorProxy__factory,
-  getEACAggregatorProxyContract: () => getEACAggregatorProxyContract,
-  getEACAggregatorProxyContractOnContext: () => getEACAggregatorProxyContractOnContext,
-  mockAnswerUpdatedLog: () => mockAnswerUpdatedLog,
-  mockNewRoundLog: () => mockNewRoundLog,
-  mockOwnershipTransferRequestedLog: () => mockOwnershipTransferRequestedLog,
-  mockOwnershipTransferredLog: () => mockOwnershipTransferredLog
-});
-
-// src/eth/builtin/internal/eacaggregatorproxy-processor.ts
-var templateContract = EACAggregatorProxy__factory.connect(
-  "0x0",
-  DummyProvider
-);
-var EACAggregatorProxyContractView = class extends ContractView {
-  constructor(contract) {
-    super(contract);
-    this.callStatic.contract = contract;
-  }
-  async accessController(overrides) {
-    try {
-      return await this.contract.getFunction("accessController()")(
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async aggregator(overrides) {
-    try {
-      return await this.contract.getFunction("aggregator()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async decimals(overrides) {
-    try {
-      return await this.contract.getFunction("decimals()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async description(overrides) {
-    try {
-      return await this.contract.getFunction("description()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async getAnswer(_roundId, overrides) {
-    try {
-      return await this.contract.getFunction("getAnswer(uint256)")(
-        _roundId,
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async getRoundData(_roundId, overrides) {
-    try {
-      return await this.contract.getFunction("getRoundData(uint80)")(
-        _roundId,
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async getTimestamp(_roundId, overrides) {
-    try {
-      return await this.contract.getFunction("getTimestamp(uint256)")(
-        _roundId,
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async latestAnswer(overrides) {
-    try {
-      return await this.contract.getFunction("latestAnswer()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async latestRound(overrides) {
-    try {
-      return await this.contract.getFunction("latestRound()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async latestRoundData(overrides) {
-    try {
-      return await this.contract.getFunction("latestRoundData()")(
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async latestTimestamp(overrides) {
-    try {
-      return await this.contract.getFunction("latestTimestamp()")(
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async owner(overrides) {
-    try {
-      return await this.contract.getFunction("owner()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async phaseAggregators(arg0, overrides) {
-    try {
-      return await this.contract.getFunction("phaseAggregators(uint16)")(
-        arg0,
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async phaseId(overrides) {
-    try {
-      return await this.contract.getFunction("phaseId()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async proposedAggregator(overrides) {
-    try {
-      return await this.contract.getFunction("proposedAggregator()")(
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async proposedGetRoundData(_roundId, overrides) {
-    try {
-      return await this.contract.getFunction("proposedGetRoundData(uint80)")(
-        _roundId,
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async proposedLatestRoundData(overrides) {
-    try {
-      return await this.contract.getFunction("proposedLatestRoundData()")(
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async version(overrides) {
-    try {
-      return await this.contract.getFunction("version()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  callStatic = {
-    contract: this.contract,
-    async acceptOwnership(overrides) {
-      try {
-        return await this.contract.getFunction("acceptOwnership()").staticCall(overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async confirmAggregator(_aggregator, overrides) {
-      try {
-        return await this.contract.getFunction("confirmAggregator(address)").staticCall(_aggregator, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async proposeAggregator(_aggregator, overrides) {
-      try {
-        return await this.contract.getFunction("proposeAggregator(address)").staticCall(_aggregator, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async setController(_accessController, overrides) {
-      try {
-        return await this.contract.getFunction("setController(address)").staticCall(_accessController, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async transferOwnership(_to, overrides) {
-      try {
-        return await this.contract.getFunction("transferOwnership(address)").staticCall(_to, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    }
-  };
-};
-var EACAggregatorProxyBoundContractView = class extends BoundContractView {
-  async accessController(overrides) {
-    return await this.view.accessController({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async aggregator(overrides) {
-    return await this.view.aggregator({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async decimals(overrides) {
-    return await this.view.decimals({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async description(overrides) {
-    return await this.view.description({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async getAnswer(_roundId, overrides) {
-    return await this.view.getAnswer(_roundId, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async getRoundData(_roundId, overrides) {
-    return await this.view.getRoundData(_roundId, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async getTimestamp(_roundId, overrides) {
-    return await this.view.getTimestamp(_roundId, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async latestAnswer(overrides) {
-    return await this.view.latestAnswer({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async latestRound(overrides) {
-    return await this.view.latestRound({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async latestRoundData(overrides) {
-    return await this.view.latestRoundData({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async latestTimestamp(overrides) {
-    return await this.view.latestTimestamp({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async owner(overrides) {
-    return await this.view.owner({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async phaseAggregators(arg0, overrides) {
-    return await this.view.phaseAggregators(arg0, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async phaseId(overrides) {
-    return await this.view.phaseId({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async proposedAggregator(overrides) {
-    return await this.view.proposedAggregator({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async proposedGetRoundData(_roundId, overrides) {
-    return await this.view.proposedGetRoundData(_roundId, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async proposedLatestRoundData(overrides) {
-    return await this.view.proposedLatestRoundData({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async version(overrides) {
-    return await this.view.version({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  callStatic = {
-    view: this.view,
-    context: this.context,
-    async acceptOwnership(overrides) {
-      return await this.view.callStatic.acceptOwnership({
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    },
-    async confirmAggregator(_aggregator, overrides) {
-      return await this.view.callStatic.confirmAggregator(_aggregator, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    },
-    async proposeAggregator(_aggregator, overrides) {
-      return await this.view.callStatic.proposeAggregator(_aggregator, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    },
-    async setController(_accessController, overrides) {
-      return await this.view.callStatic.setController(_accessController, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    },
-    async transferOwnership(_to, overrides) {
-      return await this.view.callStatic.transferOwnership(_to, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    }
-  };
-};
-var _EACAggregatorProxyProcessor = class extends BaseProcessor {
-  onEventAnswerUpdated(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["AnswerUpdated(int256,uint256,uint256)"](null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventNewRound(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["NewRound(uint256,address,uint256)"](
-        null,
-        null,
-        null
-      );
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventOwnershipTransferRequested(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["OwnershipTransferRequested(address,address)"](null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventOwnershipTransferred(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["OwnershipTransferred(address,address)"](null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onCallAcceptOwnership(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x79ba5097",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallAccessController(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xbc43cbaf",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallAggregator(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x245a7bfc",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallConfirmAggregator(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xa928c096",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallDecimals(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x313ce567",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallDescription(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x7284e416",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallGetAnswer(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xb5ab58dc",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallGetRoundData(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x9a6fc8f5",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallGetTimestamp(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xb633620c",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallLatestAnswer(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x50d25bcd",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallLatestRound(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x668a0f02",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallLatestRoundData(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xfeaf968c",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallLatestTimestamp(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x8205bf6a",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallOwner(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x8da5cb5b",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallPhaseAggregators(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xc1597304",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallPhaseId(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x58303b10",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallProposeAggregator(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xf8a2abd3",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallProposedAggregator(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xe8c4be30",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallProposedGetRoundData(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x6001ac53",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallProposedLatestRoundData(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x8f6b4d91",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallSetController(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x92eefe9b",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallTransferOwnership(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xf2fde38b",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  onCallVersion(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0x54fd4d50",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  CreateBoundContractView() {
-    const view = getEACAggregatorProxyContract(
-      this.config.network,
-      this.config.address
-    );
-    return new EACAggregatorProxyBoundContractView(this.config.address, view);
-  }
-  static bind(options) {
-    if (!options.name) {
-      options.name = "EACAggregatorProxy";
-    }
-    let processor = getProcessor(options);
-    if (!processor) {
-      processor = new _EACAggregatorProxyProcessor(options);
-      addProcessor(options, processor);
-    }
-    return processor;
-  }
-};
-var EACAggregatorProxyProcessor = _EACAggregatorProxyProcessor;
-__publicField(EACAggregatorProxyProcessor, "filters", {
-  AnswerUpdated(current, roundId, updatedAt) {
-    return templateContract.filters["AnswerUpdated(int256,uint256,uint256)"](
-      current,
-      roundId,
-      updatedAt
-    );
-  },
-  NewRound(roundId, startedBy, startedAt) {
-    return templateContract.filters["NewRound(uint256,address,uint256)"](
-      roundId,
-      startedBy,
-      startedAt
-    );
-  },
-  OwnershipTransferRequested(from, to) {
-    return templateContract.filters["OwnershipTransferRequested(address,address)"](from, to);
-  },
-  OwnershipTransferred(from, to) {
-    return templateContract.filters["OwnershipTransferred(address,address)"](
-      from,
-      to
-    );
-  }
-});
-var EACAggregatorProxyProcessorTemplate = class extends BaseProcessorTemplate {
-  bindInternal(options) {
-    if (!options.name) {
-      options.name = "EACAggregatorProxy";
-    }
-    let processor = getProcessor(options);
-    if (!processor) {
-      processor = new EACAggregatorProxyProcessor(options);
-      addProcessor(options, processor);
-    }
-    return processor;
-  }
-  onEventAnswerUpdated(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["AnswerUpdated(int256,uint256,uint256)"](null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventNewRound(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["NewRound(uint256,address,uint256)"](
-        null,
-        null,
-        null
-      );
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventOwnershipTransferRequested(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["OwnershipTransferRequested(address,address)"](null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventOwnershipTransferred(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["OwnershipTransferred(address,address)"](null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-};
-function getEACAggregatorProxyContract(chainId, address) {
-  let contract = getContractByABI(
-    "EACAggregatorProxy",
-    address,
-    chainId
-  );
-  if (!contract) {
-    const rawContract = EACAggregatorProxy__factory.connect(
-      address,
-      getProvider(chainId)
-    );
-    contract = new EACAggregatorProxyContractView(rawContract);
-    addContractByABI("EACAggregatorProxy", address, chainId, contract);
-  }
-  return contract;
-}
-function getEACAggregatorProxyContractOnContext(context, address) {
-  const view = getEACAggregatorProxyContract(context.getChainId(), address);
-  const boundView = new EACAggregatorProxyBoundContractView(address, view);
-  boundView.context = context;
-  if (boundView.callStatic) {
-    boundView.callStatic.context = context;
-  }
-  return boundView;
-}
-
-// src/eth/builtin/internal/eacaggregatorproxy-test-utils.ts
-var mockField = {
-  blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  blockNumber: 0,
-  logIndex: 0,
-  removed: false,
-  transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  transactionIndex: 0
-};
-function mockAnswerUpdatedLog(contractAddress, event) {
-  const contract = getEACAggregatorProxyContract(
-    import_chain.EthChainId.ETHEREUM,
-    contractAddress
-  );
-  const encodedLog = contract.rawContract.interface.encodeEventLog(
-    "AnswerUpdated(int256,uint256,uint256)",
-    [event.current, event.roundId, event.updatedAt]
-  );
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-function mockNewRoundLog(contractAddress, event) {
-  const contract = getEACAggregatorProxyContract(
-    import_chain.EthChainId.ETHEREUM,
-    contractAddress
-  );
-  const encodedLog = contract.rawContract.interface.encodeEventLog(
-    "NewRound(uint256,address,uint256)",
-    [event.roundId, event.startedBy, event.startedAt]
-  );
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-function mockOwnershipTransferRequestedLog(contractAddress, event) {
-  const contract = getEACAggregatorProxyContract(
-    import_chain.EthChainId.ETHEREUM,
-    contractAddress
-  );
-  const encodedLog = contract.rawContract.interface.encodeEventLog(
-    "OwnershipTransferRequested(address,address)",
-    [event.from, event.to]
-  );
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-function mockOwnershipTransferredLog(contractAddress, event) {
-  const contract = getEACAggregatorProxyContract(
-    import_chain.EthChainId.ETHEREUM,
-    contractAddress
-  );
-  const encodedLog = contract.rawContract.interface.encodeEventLog(
-    "OwnershipTransferred(address,address)",
-    [event.from, event.to]
-  );
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-
-export {
-  EACAggregatorProxyContractView,
-  EACAggregatorProxyBoundContractView,
-  EACAggregatorProxyProcessor,
-  EACAggregatorProxyProcessorTemplate,
-  getEACAggregatorProxyContract,
-  getEACAggregatorProxyContractOnContext,
-  mockAnswerUpdatedLog,
-  mockNewRoundLog,
-  mockOwnershipTransferRequestedLog,
-  mockOwnershipTransferredLog,
-  eacaggregatorproxy_exports
-};