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

package/lib/chunk-2QEQTKQY.js

@@ -0,0 +1,1050 @@
+import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
+import {
+  BaseProcessor,
+  BaseProcessorTemplate,
+  BoundContractView,
+  ContractView,
+  DummyProvider,
+  Interface,
+  WETH9__factory,
+  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/weth9.ts
+var weth9_exports = {};
+__export(weth9_exports, {
+  WETH9BoundContractView: () => WETH9BoundContractView,
+  WETH9ContractView: () => WETH9ContractView,
+  WETH9Processor: () => WETH9Processor,
+  WETH9ProcessorTemplate: () => WETH9ProcessorTemplate,
+  WETH9__factory: () => WETH9__factory,
+  getWETH9Contract: () => getWETH9Contract,
+  getWETH9ContractOnContext: () => getWETH9ContractOnContext,
+  mockApprovalLog: () => mockApprovalLog,
+  mockDepositLog: () => mockDepositLog,
+  mockTransferLog: () => mockTransferLog,
+  mockWithdrawalLog: () => mockWithdrawalLog
+});
+
+// src/eth/builtin/internal/weth9-processor.ts
+var templateContract = WETH9__factory.connect("0x0", DummyProvider);
+var WETH9ContractView = class extends ContractView {
+  constructor(contract) {
+    super(contract);
+    this.callStatic.contract = contract;
+  }
+  async name(overrides, preparedData, ethCallContext) {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface(["function name() view returns (string)"]);
+        const calldata = iface.encodeFunctionData("name", []);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("name", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      return await this.contract.getFunction("name()")(overrides || {});
+    } catch (e) {
+      const stack = new Error().stack;
+      throw transformEtherError(e, void 0, stack);
+    }
+  }
+  async totalSupply(overrides, preparedData, ethCallContext) {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function totalSupply() view returns (uint256)"
+        ]);
+        const calldata = iface.encodeFunctionData("totalSupply", []);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("totalSupply", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      return await this.contract.getFunction("totalSupply()")(overrides || {});
+    } catch (e) {
+      const stack = new Error().stack;
+      throw transformEtherError(e, void 0, stack);
+    }
+  }
+  async decimals(overrides, preparedData, ethCallContext) {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function decimals() view returns (uint8)"
+        ]);
+        const calldata = iface.encodeFunctionData("decimals", []);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("decimals", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      return await this.contract.getFunction("decimals()")(overrides || {});
+    } catch (e) {
+      const stack = new Error().stack;
+      throw transformEtherError(e, void 0, stack);
+    }
+  }
+  async balanceOf(arg0, overrides, preparedData, ethCallContext) {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function balanceOf(address) view returns (uint256)"
+        ]);
+        const calldata = iface.encodeFunctionData("balanceOf", [arg0]);
+        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)")(
+        arg0,
+        overrides || {}
+      );
+    } catch (e) {
+      const stack = new Error().stack;
+      throw transformEtherError(e, void 0, stack);
+    }
+  }
+  async symbol(overrides, preparedData, ethCallContext) {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function symbol() view returns (string)"
+        ]);
+        const calldata = iface.encodeFunctionData("symbol", []);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("symbol", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      return await this.contract.getFunction("symbol()")(overrides || {});
+    } catch (e) {
+      const stack = new Error().stack;
+      throw transformEtherError(e, void 0, stack);
+    }
+  }
+  async allowance(arg0, arg1, overrides, preparedData, ethCallContext) {
+    try {
+      if (preparedData?.ethCallResults && ethCallContext) {
+        const iface = new Interface([
+          "function allowance(address,address) view returns (uint256)"
+        ]);
+        const calldata = iface.encodeFunctionData("allowance", [arg0, arg1]);
+        const key = makeEthCallKey({
+          context: ethCallContext,
+          calldata
+        });
+        const ret = preparedData.ethCallResults[key];
+        if (ret) {
+          const result = iface.decodeFunctionResult("allowance", ret).toArray();
+          return result.length == 1 ? result[0] : result;
+        }
+      }
+      return await this.contract.getFunction("allowance(address,address)")(
+        arg0,
+        arg1,
+        overrides || {}
+      );
+    } catch (e) {
+      const stack = new Error().stack;
+      throw transformEtherError(e, void 0, stack);
+    }
+  }
+  callStatic = {
+    contract: this.contract,
+    async approve(guy, wad, overrides, preparedData, ethCallContext) {
+      try {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function approve(address,uint256) nonpayable returns (bool)"
+          ]);
+          const calldata = iface.encodeFunctionData("approve", [guy, wad]);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("approve", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        return await this.contract.getFunction("approve(address,uint256)").staticCall(guy, wad, overrides || {});
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    async transferFrom(src, dst, wad, overrides, preparedData, ethCallContext) {
+      try {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function transferFrom(address,address,uint256) nonpayable returns (bool)"
+          ]);
+          const calldata = iface.encodeFunctionData("transferFrom", [
+            src,
+            dst,
+            wad
+          ]);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("transferFrom", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        return await this.contract.getFunction("transferFrom(address,address,uint256)").staticCall(src, dst, wad, overrides || {});
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    async withdraw(wad, overrides, preparedData, ethCallContext) {
+      try {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function withdraw(uint256) nonpayable returns ()"
+          ]);
+          const calldata = iface.encodeFunctionData("withdraw", [wad]);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("withdraw", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        return await this.contract.getFunction("withdraw(uint256)").staticCall(wad, overrides || {});
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    async transfer(dst, wad, overrides, preparedData, ethCallContext) {
+      try {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function transfer(address,uint256) nonpayable returns (bool)"
+          ]);
+          const calldata = iface.encodeFunctionData("transfer", [dst, wad]);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("transfer", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        return await this.contract.getFunction("transfer(address,uint256)").staticCall(dst, wad, overrides || {});
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    async deposit(overrides, preparedData, ethCallContext) {
+      try {
+        if (preparedData?.ethCallResults && ethCallContext) {
+          const iface = new Interface([
+            "function deposit() payable returns ()"
+          ]);
+          const calldata = iface.encodeFunctionData("deposit", []);
+          const key = makeEthCallKey({
+            context: ethCallContext,
+            calldata
+          });
+          const ret = preparedData.ethCallResults[key];
+          if (ret) {
+            const result = iface.decodeFunctionResult("deposit", ret).toArray();
+            return result.length == 1 ? result[0] : result;
+          }
+        }
+        return await this.contract.getFunction("deposit()").staticCall(overrides || {});
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    }
+  };
+  encodeCall = {
+    name(ethCallContext) {
+      try {
+        const iface = new Interface(["function name()"]);
+        const calldata = iface.encodeFunctionData("name", []);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    approve(guy, wad, ethCallContext) {
+      try {
+        const iface = new Interface(["function approve(address,uint256)"]);
+        const calldata = iface.encodeFunctionData("approve", [guy, wad]);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    totalSupply(ethCallContext) {
+      try {
+        const iface = new Interface(["function totalSupply()"]);
+        const calldata = iface.encodeFunctionData("totalSupply", []);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    transferFrom(src, dst, wad, ethCallContext) {
+      try {
+        const iface = new Interface([
+          "function transferFrom(address,address,uint256)"
+        ]);
+        const calldata = iface.encodeFunctionData("transferFrom", [
+          src,
+          dst,
+          wad
+        ]);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    withdraw(wad, ethCallContext) {
+      try {
+        const iface = new Interface(["function withdraw(uint256)"]);
+        const calldata = iface.encodeFunctionData("withdraw", [wad]);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    decimals(ethCallContext) {
+      try {
+        const iface = new Interface(["function decimals()"]);
+        const calldata = iface.encodeFunctionData("decimals", []);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    balanceOf(arg0, ethCallContext) {
+      try {
+        const iface = new Interface(["function balanceOf(address)"]);
+        const calldata = iface.encodeFunctionData("balanceOf", [arg0]);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    symbol(ethCallContext) {
+      try {
+        const iface = new Interface(["function symbol()"]);
+        const calldata = iface.encodeFunctionData("symbol", []);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    transfer(dst, wad, ethCallContext) {
+      try {
+        const iface = new Interface(["function transfer(address,uint256)"]);
+        const calldata = iface.encodeFunctionData("transfer", [dst, wad]);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    deposit(ethCallContext) {
+      try {
+        const iface = new Interface(["function deposit()"]);
+        const calldata = iface.encodeFunctionData("deposit", []);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    },
+    allowance(arg0, arg1, ethCallContext) {
+      try {
+        const iface = new Interface(["function allowance(address,address)"]);
+        const calldata = iface.encodeFunctionData("allowance", [arg0, arg1]);
+        return {
+          context: ethCallContext,
+          calldata
+        };
+      } catch (e) {
+        const stack = new Error().stack;
+        throw transformEtherError(e, void 0, stack);
+      }
+    }
+  };
+};
+var WETH9BoundContractView = class extends BoundContractView {
+  async name(overrides) {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: this.context.blockNumber.toString(16),
+      address: this.context.address
+    };
+    return await this.view.name(
+      {
+        blockTag: this.context.blockNumber,
+        ...overrides
+      },
+      this.context.preparedData,
+      ethCallContext
+    );
+  }
+  async totalSupply(overrides) {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: this.context.blockNumber.toString(16),
+      address: this.context.address
+    };
+    return await this.view.totalSupply(
+      {
+        blockTag: this.context.blockNumber,
+        ...overrides
+      },
+      this.context.preparedData,
+      ethCallContext
+    );
+  }
+  async decimals(overrides) {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: this.context.blockNumber.toString(16),
+      address: this.context.address
+    };
+    return await this.view.decimals(
+      {
+        blockTag: this.context.blockNumber,
+        ...overrides
+      },
+      this.context.preparedData,
+      ethCallContext
+    );
+  }
+  async balanceOf(arg0, overrides) {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: this.context.blockNumber.toString(16),
+      address: this.context.address
+    };
+    return await this.view.balanceOf(
+      arg0,
+      {
+        blockTag: this.context.blockNumber,
+        ...overrides
+      },
+      this.context.preparedData,
+      ethCallContext
+    );
+  }
+  async symbol(overrides) {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: this.context.blockNumber.toString(16),
+      address: this.context.address
+    };
+    return await this.view.symbol(
+      {
+        blockTag: this.context.blockNumber,
+        ...overrides
+      },
+      this.context.preparedData,
+      ethCallContext
+    );
+  }
+  async allowance(arg0, arg1, overrides) {
+    const ethCallContext = {
+      chainId: this.context.chainId,
+      blockTag: this.context.blockNumber.toString(16),
+      address: this.context.address
+    };
+    return await this.view.allowance(
+      arg0,
+      arg1,
+      {
+        blockTag: this.context.blockNumber,
+        ...overrides
+      },
+      this.context.preparedData,
+      ethCallContext
+    );
+  }
+  callStatic = {
+    view: this.view,
+    context: this.context,
+    async approve(guy, wad, overrides) {
+      const ethCallContext = {
+        chainId: this.context.chainId,
+        blockTag: this.context.blockNumber.toString(16),
+        address: this.context.address
+      };
+      return await this.view.callStatic.approve(
+        guy,
+        wad,
+        {
+          blockTag: this.context.blockNumber,
+          ...overrides
+        },
+        this.context.preparedData,
+        ethCallContext
+      );
+    },
+    async transferFrom(src, dst, wad, overrides) {
+      const ethCallContext = {
+        chainId: this.context.chainId,
+        blockTag: this.context.blockNumber.toString(16),
+        address: this.context.address
+      };
+      return await this.view.callStatic.transferFrom(
+        src,
+        dst,
+        wad,
+        {
+          blockTag: this.context.blockNumber,
+          ...overrides
+        },
+        this.context.preparedData,
+        ethCallContext
+      );
+    },
+    async withdraw(wad, overrides) {
+      const ethCallContext = {
+        chainId: this.context.chainId,
+        blockTag: this.context.blockNumber.toString(16),
+        address: this.context.address
+      };
+      return await this.view.callStatic.withdraw(
+        wad,
+        {
+          blockTag: this.context.blockNumber,
+          ...overrides
+        },
+        this.context.preparedData,
+        ethCallContext
+      );
+    },
+    async transfer(dst, wad, overrides) {
+      const ethCallContext = {
+        chainId: this.context.chainId,
+        blockTag: this.context.blockNumber.toString(16),
+        address: this.context.address
+      };
+      return await this.view.callStatic.transfer(
+        dst,
+        wad,
+        {
+          blockTag: this.context.blockNumber,
+          ...overrides
+        },
+        this.context.preparedData,
+        ethCallContext
+      );
+    },
+    async deposit(overrides) {
+      const ethCallContext = {
+        chainId: this.context.chainId,
+        blockTag: this.context.blockNumber.toString(16),
+        address: this.context.address
+      };
+      return await this.view.callStatic.deposit(
+        {
+          blockTag: this.context.blockNumber,
+          ...overrides
+        },
+        this.context.preparedData,
+        ethCallContext
+      );
+    }
+  };
+  encodeCall = {
+    view: this.view,
+    context: this.context,
+    name(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.name({ chainId, address, blockTag });
+    },
+    approve(guy, wad, 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.approve(guy, wad, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    totalSupply(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.totalSupply({ chainId, address, blockTag });
+    },
+    transferFrom(src, dst, wad, 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.transferFrom(src, dst, wad, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    withdraw(wad, 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.withdraw(wad, { chainId, address, blockTag });
+    },
+    decimals(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.decimals({ chainId, address, blockTag });
+    },
+    balanceOf(arg0, 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(arg0, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    symbol(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.symbol({ chainId, address, blockTag });
+    },
+    transfer(dst, wad, 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.transfer(dst, wad, {
+        chainId,
+        address,
+        blockTag
+      });
+    },
+    deposit(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.deposit({ chainId, address, blockTag });
+    },
+    allowance(arg0, arg1, 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.allowance(arg0, arg1, {
+        chainId,
+        address,
+        blockTag
+      });
+    }
+  };
+};
+var _WETH9Processor = class extends BaseProcessor {
+  onEventApproval(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Approval(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+  onEventTransfer(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Transfer(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+  onEventDeposit(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Deposit(address,uint256)"](null, null);
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+  onEventWithdrawal(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Withdrawal(address,uint256)"](
+        null,
+        null
+      );
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+  onCallName(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x06fdde03",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallApprove(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x095ea7b3",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallTotalSupply(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x18160ddd",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallTransferFrom(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x23b872dd",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallWithdraw(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x2e1a7d4d",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallDecimals(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x313ce567",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallBalanceOf(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x70a08231",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallSymbol(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0x95d89b41",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallTransfer(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0xa9059cbb",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallDeposit(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0xd0e30db0",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  onCallAllowance(handler, fetchConfig, preprocessHandler) {
+    return super.onEthTrace(
+      "0xdd62ed3e",
+      handler,
+      fetchConfig,
+      preprocessHandler
+    );
+  }
+  CreateBoundContractView() {
+    const view = getWETH9Contract(this.config.network, this.config.address);
+    return new WETH9BoundContractView(this.config.address, view);
+  }
+  static bind(options) {
+    if (!options.name) {
+      options.name = "WETH9";
+    }
+    let processor = getProcessor(options);
+    if (!processor) {
+      processor = new _WETH9Processor(options);
+      addProcessor(options, processor);
+    }
+    return processor;
+  }
+};
+var WETH9Processor = _WETH9Processor;
+__publicField(WETH9Processor, "filters", {
+  Approval(src, guy, wad) {
+    return templateContract.filters["Approval(address,address,uint256)"](
+      src,
+      guy,
+      wad
+    );
+  },
+  Transfer(src, dst, wad) {
+    return templateContract.filters["Transfer(address,address,uint256)"](
+      src,
+      dst,
+      wad
+    );
+  },
+  Deposit(dst, wad) {
+    return templateContract.filters["Deposit(address,uint256)"](dst, wad);
+  },
+  Withdrawal(src, wad) {
+    return templateContract.filters["Withdrawal(address,uint256)"](src, wad);
+  }
+});
+var WETH9ProcessorTemplate = class extends BaseProcessorTemplate {
+  bindInternal(options) {
+    if (!options.name) {
+      options.name = "WETH9";
+    }
+    let processor = getProcessor(options);
+    if (!processor) {
+      processor = new WETH9Processor(options);
+      addProcessor(options, processor);
+    }
+    return processor;
+  }
+  onEventApproval(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Approval(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+  onEventTransfer(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Transfer(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+  onEventDeposit(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Deposit(address,uint256)"](null, null);
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+  onEventWithdrawal(handler, filter, fetchConfig, preprocessHandler) {
+    if (!filter) {
+      filter = templateContract.filters["Withdrawal(address,uint256)"](
+        null,
+        null
+      );
+    }
+    return super.onEthEvent(handler, filter, fetchConfig, preprocessHandler);
+  }
+};
+function getWETH9Contract(chainId, address) {
+  let contract = getContractByABI(
+    "WETH9",
+    address,
+    chainId
+  );
+  if (!contract) {
+    const rawContract = WETH9__factory.connect(address, getProvider(chainId));
+    contract = new WETH9ContractView(rawContract);
+    addContractByABI("WETH9", address, chainId, contract);
+  }
+  return contract;
+}
+function getWETH9ContractOnContext(context, address) {
+  const view = getWETH9Contract(context.getChainId(), address);
+  const boundView = new WETH9BoundContractView(address, view);
+  boundView.context = context;
+  if (boundView.callStatic) {
+    boundView.callStatic.context = context;
+  }
+  return boundView;
+}
+
+// src/eth/builtin/internal/weth9-test-utils.ts
+var mockField = {
+  blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  blockNumber: 0,
+  logIndex: 0,
+  removed: false,
+  transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  transactionIndex: 0
+};
+function mockApprovalLog(contractAddress, event) {
+  const contract = getWETH9Contract(import_chain.EthChainId.ETHEREUM, contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "Approval(address,address,uint256)",
+    [event.src, event.guy, event.wad]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics
+  };
+}
+function mockTransferLog(contractAddress, event) {
+  const contract = getWETH9Contract(import_chain.EthChainId.ETHEREUM, contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "Transfer(address,address,uint256)",
+    [event.src, event.dst, event.wad]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics
+  };
+}
+function mockDepositLog(contractAddress, event) {
+  const contract = getWETH9Contract(import_chain.EthChainId.ETHEREUM, contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "Deposit(address,uint256)",
+    [event.dst, event.wad]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics
+  };
+}
+function mockWithdrawalLog(contractAddress, event) {
+  const contract = getWETH9Contract(import_chain.EthChainId.ETHEREUM, contractAddress);
+  const encodedLog = contract.rawContract.interface.encodeEventLog(
+    "Withdrawal(address,uint256)",
+    [event.src, event.wad]
+  );
+  return {
+    ...mockField,
+    index: 0,
+    address: contractAddress,
+    data: encodedLog.data,
+    topics: encodedLog.topics
+  };
+}
+
+export {
+  WETH9ContractView,
+  WETH9BoundContractView,
+  WETH9Processor,
+  WETH9ProcessorTemplate,
+  getWETH9Contract,
+  getWETH9ContractOnContext,
+  mockApprovalLog,
+  mockTransferLog,
+  mockDepositLog,
+  mockWithdrawalLog,
+  weth9_exports
+};