@sentio/sdk 2.57.12-rc.j → 2.57.13-rc.1

package/lib/chunk-N36N7RXJ.js

@@ -1,653 +0,0 @@
-import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
-import {
-  BaseProcessor,
-  BaseProcessorTemplate,
-  BoundContractView,
-  ContractView,
-  DummyProvider,
-  ERC1155__factory,
-  EthChainId,
-  addContractByABI,
-  addProcessor,
-  getContractByABI,
-  getProcessor,
-  getProvider,
-  transformEtherError
-} from "./chunk-OJG2VJ5T.js";
-import {
-  Interface
-} from "./chunk-RMT2JEWA.js";
-import {
-  __name
-} from "./chunk-R7PMHHKJ.js";
-
-// src/eth/builtin/internal/erc1155-processor.js
-var templateContract = ERC1155__factory.connect("0x0", DummyProvider);
-var iface = new Interface([
-  "function balanceOf(address account, uint256 id) view returns (uint256)",
-  "function balanceOfBatch(address[] accounts, uint256[] ids) view returns (uint256[])",
-  "function isApprovedForAll(address account, address operator) view returns (bool)",
-  "function safeBatchTransferFrom(address from, address to, uint256[] ids, uint256[] amounts, bytes data) returns ()",
-  "function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes data) returns ()",
-  "function setApprovalForAll(address operator, bool approved) returns ()",
-  "function supportsInterface(bytes4 interfaceId) view returns (bool)",
-  "function uri(uint256 id) view returns (string)"
-]);
-var ERC1155ContractView = class extends ContractView {
-  static {
-    __name(this, "ERC1155ContractView");
-  }
-  constructor(contract) {
-    super(contract);
-    this.callStatic.contract = contract;
-  }
-  async balanceOf(account, id, overrides, preparedData, ethCallContext) {
-    try {
-      return await this.contract.getFunction("balanceOf(address,uint256)")(account, id, overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async balanceOfBatch(accounts, ids, overrides, preparedData, ethCallContext) {
-    try {
-      return await this.contract.getFunction("balanceOfBatch(address[],uint256[])")(accounts, ids, overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async isApprovedForAll(account, operator, overrides, preparedData, ethCallContext) {
-    try {
-      return await this.contract.getFunction("isApprovedForAll(address,address)")(account, operator, overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async supportsInterface(interfaceId, overrides, preparedData, ethCallContext) {
-    try {
-      return await this.contract.getFunction("supportsInterface(bytes4)")(interfaceId, overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async uri(id, overrides, preparedData, ethCallContext) {
-    try {
-      return await this.contract.getFunction("uri(uint256)")(id, overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  callStatic = {
-    contract: this.contract,
-    async safeBatchTransferFrom(from, to, ids, amounts, data, overrides, preparedData, ethCallContext) {
-      try {
-        return await this.contract.getFunction("safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)").staticCall(from, to, ids, amounts, data, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async safeTransferFrom(from, to, id, amount, data, overrides, preparedData, ethCallContext) {
-      try {
-        return await this.contract.getFunction("safeTransferFrom(address,address,uint256,uint256,bytes)").staticCall(from, to, id, amount, data, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async setApprovalForAll(operator, approved, overrides, preparedData, ethCallContext) {
-      try {
-        return await this.contract.getFunction("setApprovalForAll(address,bool)").staticCall(operator, approved, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    }
-  };
-  encodeCall = {
-    balanceOf(account, id, ethCallContext) {
-      try {
-        const iface2 = new Interface(["function balanceOf(address,uint256)"]);
-        const calldata = iface2.encodeFunctionData("balanceOf", [account, id]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    balanceOfBatch(accounts, ids, ethCallContext) {
-      try {
-        const iface2 = new Interface([
-          "function balanceOfBatch(address[],uint256[])"
-        ]);
-        const calldata = iface2.encodeFunctionData("balanceOfBatch", [
-          accounts,
-          ids
-        ]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    isApprovedForAll(account, operator, ethCallContext) {
-      try {
-        const iface2 = new Interface([
-          "function isApprovedForAll(address,address)"
-        ]);
-        const calldata = iface2.encodeFunctionData("isApprovedForAll", [
-          account,
-          operator
-        ]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    safeBatchTransferFrom(from, to, ids, amounts, data, ethCallContext) {
-      try {
-        const iface2 = new Interface([
-          "function safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)"
-        ]);
-        const calldata = iface2.encodeFunctionData("safeBatchTransferFrom", [
-          from,
-          to,
-          ids,
-          amounts,
-          data
-        ]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    safeTransferFrom(from, to, id, amount, data, ethCallContext) {
-      try {
-        const iface2 = new Interface([
-          "function safeTransferFrom(address,address,uint256,uint256,bytes)"
-        ]);
-        const calldata = iface2.encodeFunctionData("safeTransferFrom", [
-          from,
-          to,
-          id,
-          amount,
-          data
-        ]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    setApprovalForAll(operator, approved, ethCallContext) {
-      try {
-        const iface2 = new Interface([
-          "function setApprovalForAll(address,bool)"
-        ]);
-        const calldata = iface2.encodeFunctionData("setApprovalForAll", [
-          operator,
-          approved
-        ]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    supportsInterface(interfaceId, ethCallContext) {
-      try {
-        const iface2 = new Interface(["function supportsInterface(bytes4)"]);
-        const calldata = iface2.encodeFunctionData("supportsInterface", [
-          interfaceId
-        ]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    uri(id, ethCallContext) {
-      try {
-        const iface2 = new Interface(["function uri(uint256)"]);
-        const calldata = iface2.encodeFunctionData("uri", [id]);
-        return {
-          context: ethCallContext,
-          calldata
-        };
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    }
-  };
-};
-var ERC1155BoundContractView = class extends BoundContractView {
-  static {
-    __name(this, "ERC1155BoundContractView");
-  }
-  async balanceOf(account, id, overrides) {
-    const ethCallContext = {
-      chainId: this.context.chainId,
-      blockTag: "0x" + this.context.blockNumber.toString(16),
-      address: this.context.address
-    };
-    return await this.view.balanceOf(account, id, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    }, this.context.preparedData, ethCallContext);
-  }
-  async balanceOfBatch(accounts, ids, overrides) {
-    const ethCallContext = {
-      chainId: this.context.chainId,
-      blockTag: "0x" + this.context.blockNumber.toString(16),
-      address: this.context.address
-    };
-    return await this.view.balanceOfBatch(accounts, ids, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    }, this.context.preparedData, ethCallContext);
-  }
-  async isApprovedForAll(account, operator, overrides) {
-    const ethCallContext = {
-      chainId: this.context.chainId,
-      blockTag: "0x" + this.context.blockNumber.toString(16),
-      address: this.context.address
-    };
-    return await this.view.isApprovedForAll(account, operator, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    }, this.context.preparedData, ethCallContext);
-  }
-  async supportsInterface(interfaceId, overrides) {
-    const ethCallContext = {
-      chainId: this.context.chainId,
-      blockTag: "0x" + this.context.blockNumber.toString(16),
-      address: this.context.address
-    };
-    return await this.view.supportsInterface(interfaceId, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    }, this.context.preparedData, ethCallContext);
-  }
-  async uri(id, overrides) {
-    const ethCallContext = {
-      chainId: this.context.chainId,
-      blockTag: "0x" + this.context.blockNumber.toString(16),
-      address: this.context.address
-    };
-    return await this.view.uri(id, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    }, this.context.preparedData, ethCallContext);
-  }
-  callStatic = {
-    view: this.view,
-    context: this.context,
-    async safeBatchTransferFrom(from, to, ids, amounts, data, overrides) {
-      const ethCallContext = {
-        chainId: this.context.chainId,
-        blockTag: "0x" + this.context.blockNumber.toString(16),
-        address: this.context.address
-      };
-      return await this.view.callStatic.safeBatchTransferFrom(from, to, ids, amounts, data, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      }, this.context.preparedData, ethCallContext);
-    },
-    async safeTransferFrom(from, to, id, amount, data, overrides) {
-      const ethCallContext = {
-        chainId: this.context.chainId,
-        blockTag: "0x" + this.context.blockNumber.toString(16),
-        address: this.context.address
-      };
-      return await this.view.callStatic.safeTransferFrom(from, to, id, amount, data, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      }, this.context.preparedData, ethCallContext);
-    },
-    async setApprovalForAll(operator, approved, overrides) {
-      const ethCallContext = {
-        chainId: this.context.chainId,
-        blockTag: "0x" + this.context.blockNumber.toString(16),
-        address: this.context.address
-      };
-      return await this.view.callStatic.setApprovalForAll(operator, approved, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      }, this.context.preparedData, ethCallContext);
-    }
-  };
-  encodeCall = {
-    view: this.view,
-    context: this.context,
-    balanceOf(account, id, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.balanceOf(account, id, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    },
-    balanceOfBatch(accounts, ids, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.balanceOfBatch(accounts, ids, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    },
-    isApprovedForAll(account, operator, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.isApprovedForAll(account, operator, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    },
-    safeBatchTransferFrom(from, to, ids, amounts, data, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.safeBatchTransferFrom(from, to, ids, amounts, data, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    },
-    safeTransferFrom(from, to, id, amount, data, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.safeTransferFrom(from, to, id, amount, data, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    },
-    setApprovalForAll(operator, approved, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.setApprovalForAll(operator, approved, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    },
-    supportsInterface(interfaceId, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.supportsInterface(interfaceId, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    },
-    uri(id, overrides) {
-      let blockTagWithOverride = "0x" + this.context.blockNumber.toString(16);
-      if (overrides?.blockTag) {
-        blockTagWithOverride = typeof overrides.blockTag == "string" ? overrides.blockTag : "0x" + overrides.blockTag.toString(16);
-      }
-      return this.view.encodeCall.uri(id, {
-        chainId: this.context.chainId.toString(),
-        address: this.context.address,
-        blockTag: blockTagWithOverride
-      });
-    }
-  };
-};
-var ERC1155Processor = class _ERC1155Processor extends BaseProcessor {
-  static {
-    __name(this, "ERC1155Processor");
-  }
-  onEventApprovalForAll(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["ApprovalForAll(address,address,bool)"](null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventTransferBatch(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["TransferBatch(address,address,address,uint256[],uint256[])"](null, null, null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventTransferSingle(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["TransferSingle(address,address,address,uint256,uint256)"](null, null, null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventURI(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["URI(string,uint256)"](null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onCallBalanceOf(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0x00fdd58e", handler, fetchConfig, preprocessHandler);
-  }
-  onCallBalanceOfBatch(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0x4e1273f4", handler, fetchConfig, preprocessHandler);
-  }
-  onCallIsApprovedForAll(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0xe985e9c5", handler, fetchConfig, preprocessHandler);
-  }
-  onCallSafeBatchTransferFrom(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0x2eb2c2d6", handler, fetchConfig, preprocessHandler);
-  }
-  onCallSafeTransferFrom(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0xf242432a", handler, fetchConfig, preprocessHandler);
-  }
-  onCallSetApprovalForAll(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0xa22cb465", handler, fetchConfig, preprocessHandler);
-  }
-  onCallSupportsInterface(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0x01ffc9a7", handler, fetchConfig, preprocessHandler);
-  }
-  onCallUri(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace("0x0e89341c", handler, fetchConfig, preprocessHandler);
-  }
-  static filters = {
-    ApprovalForAll(account, operator, approved) {
-      return templateContract.filters["ApprovalForAll(address,address,bool)"](account, operator, approved);
-    },
-    TransferBatch(operator, from, to, ids, values) {
-      return templateContract.filters["TransferBatch(address,address,address,uint256[],uint256[])"](operator, from, to, ids, values);
-    },
-    TransferSingle(operator, from, to, id, value) {
-      return templateContract.filters["TransferSingle(address,address,address,uint256,uint256)"](operator, from, to, id, value);
-    },
-    URI(value, id) {
-      return templateContract.filters["URI(string,uint256)"](value, id);
-    }
-  };
-  CreateBoundContractView() {
-    const view = getERC1155Contract(this.config.network, this.config.address);
-    return new ERC1155BoundContractView(this.config.address, view);
-  }
-  static bind(options) {
-    if (!options.name) {
-      options.name = "ERC1155";
-    }
-    let processor = getProcessor(options);
-    if (!processor) {
-      processor = new _ERC1155Processor(options);
-      addProcessor(options, processor);
-    }
-    return processor;
-  }
-};
-var ERC1155ProcessorTemplate = class extends BaseProcessorTemplate {
-  static {
-    __name(this, "ERC1155ProcessorTemplate");
-  }
-  bindInternal(options) {
-    if (!options.name) {
-      options.name = "ERC1155";
-    }
-    let processor = getProcessor(options);
-    if (!processor) {
-      processor = new ERC1155Processor(options);
-      addProcessor(options, processor);
-    }
-    return processor;
-  }
-  onEventApprovalForAll(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["ApprovalForAll(address,address,bool)"](null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventTransferBatch(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["TransferBatch(address,address,address,uint256[],uint256[])"](null, null, null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventTransferSingle(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["TransferSingle(address,address,address,uint256,uint256)"](null, null, null, null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-  onEventURI(handler, filter, fetchConfig, preprocessHandler) {
-    if (!filter) {
-      filter = templateContract.filters["URI(string,uint256)"](null, null);
-    }
-    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
-  }
-};
-function getERC1155Contract(chainId, address) {
-  let contract = getContractByABI("ERC1155", address, chainId);
-  if (!contract) {
-    const rawContract = ERC1155__factory.connect(address, getProvider(chainId));
-    contract = new ERC1155ContractView(rawContract);
-    addContractByABI("ERC1155", address, chainId, contract);
-  }
-  return contract;
-}
-__name(getERC1155Contract, "getERC1155Contract");
-function getERC1155ContractOnContext(context, address) {
-  const view = getERC1155Contract(context.getChainId(), address);
-  const boundView = new ERC1155BoundContractView(address, view);
-  boundView.context = context;
-  if (boundView.callStatic) {
-    boundView.callStatic.context = context;
-  }
-  return boundView;
-}
-__name(getERC1155ContractOnContext, "getERC1155ContractOnContext");
-
-// src/eth/builtin/internal/erc1155-test-utils.js
-var mockField = {
-  blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  blockNumber: 0,
-  logIndex: 0,
-  removed: false,
-  transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  transactionIndex: 0
-};
-function mockApprovalForAllLog(contractAddress, event) {
-  const contract = getERC1155Contract(EthChainId.ETHEREUM, contractAddress);
-  const encodedLog = contract.rawContract.interface.encodeEventLog("ApprovalForAll(address,address,bool)", [event.account, event.operator, event.approved]);
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-__name(mockApprovalForAllLog, "mockApprovalForAllLog");
-function mockTransferBatchLog(contractAddress, event) {
-  const contract = getERC1155Contract(EthChainId.ETHEREUM, contractAddress);
-  const encodedLog = contract.rawContract.interface.encodeEventLog("TransferBatch(address,address,address,uint256[],uint256[])", [event.operator, event.from, event.to, event.ids, event.values]);
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-__name(mockTransferBatchLog, "mockTransferBatchLog");
-function mockTransferSingleLog(contractAddress, event) {
-  const contract = getERC1155Contract(EthChainId.ETHEREUM, contractAddress);
-  const encodedLog = contract.rawContract.interface.encodeEventLog("TransferSingle(address,address,address,uint256,uint256)", [event.operator, event.from, event.to, event.id, event.value]);
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-__name(mockTransferSingleLog, "mockTransferSingleLog");
-function mockURILog(contractAddress, event) {
-  const contract = getERC1155Contract(EthChainId.ETHEREUM, contractAddress);
-  const encodedLog = contract.rawContract.interface.encodeEventLog("URI(string,uint256)", [event.value, event.id]);
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-__name(mockURILog, "mockURILog");
-
-export {
-  ERC1155ContractView,
-  ERC1155BoundContractView,
-  ERC1155Processor,
-  ERC1155ProcessorTemplate,
-  getERC1155Contract,
-  getERC1155ContractOnContext,
-  mockApprovalForAllLog,
-  mockTransferBatchLog,
-  mockTransferSingleLog,
-  mockURILog
-};
-//# sourceMappingURL=chunk-N36N7RXJ.js.map