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

package/lib/chunk-S36AAZOU.js

@@ -1,417 +0,0 @@
-import { createRequire as createRequireSdkShim } from 'module'; const require = createRequireSdkShim(import.meta.url);
-import {
-  BaseProcessor,
-  BaseProcessorTemplate,
-  BoundContractView,
-  ContractView,
-  DummyProvider,
-  ERC20Bytes__factory,
-  addContractByABI,
-  addProcessor,
-  getContractByABI,
-  getProcessor,
-  getProvider,
-  import_chain,
-  transformEtherError
-} from "./chunk-OAIP7J4S.js";
-import {
-  __export,
-  __publicField
-} from "./chunk-AXRHIURD.js";
-
-// src/eth/builtin/internal/erc20bytes-processor.ts
-var templateContract = ERC20Bytes__factory.connect("0x0", DummyProvider);
-var ERC20BytesContractView = class extends ContractView {
-  constructor(contract) {
-    super(contract);
-    this.callStatic.contract = contract;
-  }
-  async name(overrides) {
-    try {
-      return await this.contract.getFunction("name()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async totalSupply(overrides) {
-    try {
-      return await this.contract.getFunction("totalSupply()")(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 balanceOf(who, overrides) {
-    try {
-      return await this.contract.getFunction("balanceOf(address)")(
-        who,
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async symbol(overrides) {
-    try {
-      return await this.contract.getFunction("symbol()")(overrides || {});
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  async allowance(owner, spender, overrides) {
-    try {
-      return await this.contract.getFunction("allowance(address,address)")(
-        owner,
-        spender,
-        overrides || {}
-      );
-    } catch (e) {
-      const stack = new Error().stack;
-      throw transformEtherError(e, void 0, stack);
-    }
-  }
-  callStatic = {
-    contract: this.contract,
-    async approve(spender, value, overrides) {
-      try {
-        return await this.contract.getFunction("approve(address,uint256)").staticCall(spender, value, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async transferFrom(from, to, value, overrides) {
-      try {
-        return await this.contract.getFunction("transferFrom(address,address,uint256)").staticCall(from, to, value, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    },
-    async transfer(to, value, overrides) {
-      try {
-        return await this.contract.getFunction("transfer(address,uint256)").staticCall(to, value, overrides || {});
-      } catch (e) {
-        const stack = new Error().stack;
-        throw transformEtherError(e, void 0, stack);
-      }
-    }
-  };
-};
-var ERC20BytesBoundContractView = class extends BoundContractView {
-  async name(overrides) {
-    return await this.view.name({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async totalSupply(overrides) {
-    return await this.view.totalSupply({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async decimals(overrides) {
-    return await this.view.decimals({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async balanceOf(who, overrides) {
-    return await this.view.balanceOf(who, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async symbol(overrides) {
-    return await this.view.symbol({
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  async allowance(owner, spender, overrides) {
-    return await this.view.allowance(owner, spender, {
-      blockTag: this.context.blockNumber,
-      ...overrides
-    });
-  }
-  callStatic = {
-    view: this.view,
-    context: this.context,
-    async approve(spender, value, overrides) {
-      return await this.view.callStatic.approve(spender, value, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    },
-    async transferFrom(from, to, value, overrides) {
-      return await this.view.callStatic.transferFrom(from, to, value, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    },
-    async transfer(to, value, overrides) {
-      return await this.view.callStatic.transfer(to, value, {
-        blockTag: this.context.blockNumber,
-        ...overrides
-      });
-    }
-  };
-};
-var _ERC20BytesProcessor = 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);
-  }
-  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
-    );
-  }
-  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
-    );
-  }
-  onCallAllowance(handler, fetchConfig, preprocessHandler) {
-    return super.onEthTrace(
-      "0xdd62ed3e",
-      handler,
-      fetchConfig,
-      preprocessHandler
-    );
-  }
-  CreateBoundContractView() {
-    const view = getERC20BytesContract(
-      this.config.network,
-      this.config.address
-    );
-    return new ERC20BytesBoundContractView(this.config.address, view);
-  }
-  static bind(options) {
-    if (!options.name) {
-      options.name = "ERC20Bytes";
-    }
-    let processor = getProcessor(options);
-    if (!processor) {
-      processor = new _ERC20BytesProcessor(options);
-      addProcessor(options, processor);
-    }
-    return processor;
-  }
-};
-var ERC20BytesProcessor = _ERC20BytesProcessor;
-__publicField(ERC20BytesProcessor, "filters", {
-  Approval(owner, spender, value) {
-    return templateContract.filters["Approval(address,address,uint256)"](
-      owner,
-      spender,
-      value
-    );
-  },
-  Transfer(from, to, value) {
-    return templateContract.filters["Transfer(address,address,uint256)"](
-      from,
-      to,
-      value
-    );
-  }
-});
-var ERC20BytesProcessorTemplate = class extends BaseProcessorTemplate {
-  bindInternal(options) {
-    if (!options.name) {
-      options.name = "ERC20Bytes";
-    }
-    let processor = getProcessor(options);
-    if (!processor) {
-      processor = new ERC20BytesProcessor(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);
-  }
-};
-function getERC20BytesContract(chainId, address) {
-  let contract = getContractByABI(
-    "ERC20Bytes",
-    address,
-    chainId
-  );
-  if (!contract) {
-    const rawContract = ERC20Bytes__factory.connect(
-      address,
-      getProvider(chainId)
-    );
-    contract = new ERC20BytesContractView(rawContract);
-    addContractByABI("ERC20Bytes", address, chainId, contract);
-  }
-  return contract;
-}
-function getERC20BytesContractOnContext(context, address) {
-  const view = getERC20BytesContract(context.getChainId(), address);
-  const boundView = new ERC20BytesBoundContractView(address, view);
-  boundView.context = context;
-  if (boundView.callStatic) {
-    boundView.callStatic.context = context;
-  }
-  return boundView;
-}
-
-// src/eth/builtin/erc20bytes.ts
-var erc20bytes_exports = {};
-__export(erc20bytes_exports, {
-  ERC20BytesBoundContractView: () => ERC20BytesBoundContractView,
-  ERC20BytesContractView: () => ERC20BytesContractView,
-  ERC20BytesProcessor: () => ERC20BytesProcessor,
-  ERC20BytesProcessorTemplate: () => ERC20BytesProcessorTemplate,
-  ERC20Bytes__factory: () => ERC20Bytes__factory,
-  getERC20BytesContract: () => getERC20BytesContract,
-  getERC20BytesContractOnContext: () => getERC20BytesContractOnContext,
-  mockApprovalLog: () => mockApprovalLog,
-  mockTransferLog: () => mockTransferLog
-});
-
-// src/eth/builtin/internal/erc20bytes-test-utils.ts
-var mockField = {
-  blockHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  blockNumber: 0,
-  logIndex: 0,
-  removed: false,
-  transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  transactionIndex: 0
-};
-function mockApprovalLog(contractAddress, event) {
-  const contract = getERC20BytesContract(import_chain.EthChainId.ETHEREUM, contractAddress);
-  const encodedLog = contract.rawContract.interface.encodeEventLog(
-    "Approval(address,address,uint256)",
-    [event.owner, event.spender, event.value]
-  );
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-function mockTransferLog(contractAddress, event) {
-  const contract = getERC20BytesContract(import_chain.EthChainId.ETHEREUM, contractAddress);
-  const encodedLog = contract.rawContract.interface.encodeEventLog(
-    "Transfer(address,address,uint256)",
-    [event.from, event.to, event.value]
-  );
-  return {
-    ...mockField,
-    index: 0,
-    address: contractAddress,
-    data: encodedLog.data,
-    topics: encodedLog.topics
-  };
-}
-
-export {
-  ERC20BytesProcessor,
-  ERC20BytesProcessorTemplate,
-  getERC20BytesContract,
-  erc20bytes_exports
-};