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

package/lib/chunk-K5OSTLHI.js

@@ -0,0 +1,916 @@
+import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
+import {
+  BaseProcessor,
+  BaseProcessorTemplate,
+  BoundContractView,
+  ContractView,
+  DummyProvider,
+  ERC1155__factory,
+  Interface,
+  addContractByABI,
+  addProcessor,
+  getContractByABI,
+  getProcessor,
+  getProvider,
+  import_chain,
+  transformEtherError
+} from "./chunk-RXO7SOTL.js";
+import {
+  makeEthCallKey
+} from "./chunk-Z5PQR6UE.js";
+import {
+  __export,
+  __publicField
+} from "./chunk-AXRHIURD.js";
+
+// src/eth/builtin/erc1155.ts
+var erc1155_exports = {};
+__export(erc1155_exports, {
+  ERC1155BoundContractView: () => ERC1155BoundContractView,
+  ERC1155ContractView: () => ERC1155ContractView,
+  ERC1155Processor: () => ERC1155Processor,
+  ERC1155ProcessorTemplate: () => ERC1155ProcessorTemplate,
+  ERC1155__factory: () => ERC1155__factory,
+  getERC1155Contract: () => getERC1155Contract,
+  getERC1155ContractOnContext: () => getERC1155ContractOnContext,
+  mockApprovalForAllLog: () => mockApprovalForAllLog,
+  mockTransferBatchLog: () => mockTransferBatchLog,
+  mockTransferSingleLog: () => mockTransferSingleLog,
+  mockURILog: () => mockURILog
+});
+
+// src/eth/builtin/internal/erc1155-processor.ts
+var templateContract = ERC1155__factory.connect("0x0", DummyProvider);
+var ERC1155ContractView = class extends ContractView {
+  constructor(contract) {
+    super(contract);
+    this.callStatic.contract = contract;
+  }
+  async balanceOf(account, id, overrides, preparedData, ethCallContext) {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function balanceOf(address,uint256) view returns (uint256)"
+        ]);
+        const calldata = iface.encodeFunctionData("balanceOf", [account, id]);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("balanceOf", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      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 {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function balanceOfBatch(address[],uint256[]) view returns (uint256[])"
+        ]);
+        const calldata = iface.encodeFunctionData("balanceOfBatch", [
+          accounts,
+          ids
+        ]);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("balanceOfBatch", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      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 {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function isApprovedForAll(address,address) view returns (bool)"
+        ]);
+        const calldata = iface.encodeFunctionData("isApprovedForAll", [
+          account,
+          operator
+        ]);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("isApprovedForAll", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      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 {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function supportsInterface(bytes4) view returns (bool)"
+        ]);
+        const calldata = iface.encodeFunctionData("supportsInterface", [
+          interfaceId
+        ]);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("supportsInterface", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      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 {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function uri(uint256) view returns (string)"
+        ]);
+        const calldata = iface.encodeFunctionData("uri", [id]);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("uri", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      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 {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function safeBatchTransferFrom(address,address,uint256[],uint256[],bytes) nonpayable returns ()"
+          ]);
+          const calldata = iface.encodeFunctionData("safeBatchTransferFrom", [
+            from,
+            to,
+            ids,
+            amounts,
+            data
+          ]);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("safeBatchTransferFrom", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        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 {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function safeTransferFrom(address,address,uint256,uint256,bytes) nonpayable returns ()"
+          ]);
+          const calldata = iface.encodeFunctionData("safeTransferFrom", [
+            from,
+            to,
+            id,
+            amount,
+            data
+          ]);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("safeTransferFrom", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        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 {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function setApprovalForAll(address,bool) nonpayable returns ()"
+          ]);
+          const calldata = iface.encodeFunctionData("setApprovalForAll", [
+            operator,
+            approved
+          ]);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("setApprovalForAll", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        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 iface = new Interface(["function balanceOf(address,uint256)"]);
+        const calldata = iface.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 iface = new Interface([
+          "function balanceOfBatch(address[],uint256[])"
+        ]);
+        const calldata = iface.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 iface = new Interface([
+          "function isApprovedForAll(address,address)"
+        ]);
+        const calldata = iface.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 iface = new Interface([
+          "function safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)"
+        ]);
+        const calldata = iface.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 iface = new Interface([
+          "function safeTransferFrom(address,address,uint256,uint256,bytes)"
+        ]);
+        const calldata = iface.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 iface = new Interface([
+          "function setApprovalForAll(address,bool)"
+        ]);
+        const calldata = iface.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 iface = new Interface(["function supportsInterface(bytes4)"]);
+        const calldata = iface.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 iface = new Interface(["function uri(uint256)"]);
+        const calldata = iface.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 {
+  async balanceOf(account, id, overrides) {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: 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: 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: 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: 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: 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: 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: 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: 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) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.balanceOf(account, id, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    balanceOfBatch(accounts, ids, overrides) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.balanceOfBatch(accounts, ids, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    isApprovedForAll(account, operator, overrides) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.isApprovedForAll(account, operator, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    safeBatchTransferFrom(from, to, ids, amounts, data, overrides) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.safeBatchTransferFrom(
+        from,
+        to,
+        ids,
+        amounts,
+        data,
+        { chainId, address, blockTag }
+      );
+    },
+    safeTransferFrom(from, to, id, amount, data, overrides) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.safeTransferFrom(from, to, id, amount, data, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    setApprovalForAll(operator, approved, overrides) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.setApprovalForAll(operator, approved, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    supportsInterface(interfaceId, overrides) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.supportsInterface(interfaceId, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    uri(id, overrides) {
+      const chainId = overrides?.chainId?.toString() ?? this.context.chainId.toString();
+      const blockTag = overrides?.blockTag?.toString() ?? this.context.blockNumber.toString(16);
+      const address = this.context.address;
+      return this.view.encodeCall.uri(id, { chainId, address, blockTag });
+    }
+  };
+};
+var _ERC1155Processor = class extends BaseProcessor {
+  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
+    );
+  }
+  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 ERC1155Processor = _ERC1155Processor;
+__publicField(ERC1155Processor, "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);
+  }
+});
+var ERC1155ProcessorTemplate = class extends BaseProcessorTemplate {
+  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;
+}
+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;
+}
+
+// src/eth/builtin/internal/erc1155-test-utils.ts
+var mockField = {
+  blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  blockNumber: 0,
+  logIndex: 0,
+  removed: false,
+  transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  transactionIndex: 0
+};
+function mockApprovalForAllLog(contractAddress, event) {
+  const contract = getERC1155Contract(import_chain.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
+  };
+}
+function mockTransferBatchLog(contractAddress, event) {
+  const contract = getERC1155Contract(import_chain.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
+  };
+}
+function mockTransferSingleLog(contractAddress, event) {
+  const contract = getERC1155Contract(import_chain.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
+  };
+}
+function mockURILog(contractAddress, event) {
+  const contract = getERC1155Contract(import_chain.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
+  };
+}
+
+export {
+  ERC1155ContractView,
+  ERC1155BoundContractView,
+  ERC1155Processor,
+  ERC1155ProcessorTemplate,
+  getERC1155Contract,
+  getERC1155ContractOnContext,
+  mockApprovalForAllLog,
+  mockTransferBatchLog,
+  mockTransferSingleLog,
+  mockURILog,
+  erc1155_exports
+};