@sentio/sdk 1.0.0-development → 1.0.0-rc.2

package/src/builtin/internal/erc1155_processor.ts

@@ -0,0 +1,534 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { BigNumber, BigNumberish, CallOverrides, BytesLike } from "ethers";
+import { Networkish } from "@ethersproject/providers";
+import {
+  addContractByABI,
+  getContractByABI,
+  addProcessor,
+  getProcessor,
+  getProvider,
+  transformEtherError,
+  BindOptions,
+  BaseProcessor,
+  BaseProcessorTemplate,
+  BoundContractView,
+  ContractContext,
+  ContractView,
+  DummyProvider,
+  TypedCallTrace,
+} from "@sentio/sdk";
+import { PromiseOrValue } from "./common";
+import { ERC1155, ERC1155__factory } from "./index";
+import {
+  ApprovalForAllEvent,
+  ApprovalForAllEventFilter,
+  TransferBatchEvent,
+  TransferBatchEventFilter,
+  TransferSingleEvent,
+  TransferSingleEventFilter,
+  URIEvent,
+  URIEventFilter,
+} from "./ERC1155";
+
+export interface BalanceOfCallObject {
+  account: string;
+  id: BigNumber;
+}
+
+export type BalanceOfCallTrace = TypedCallTrace<
+  [string, BigNumber],
+  BalanceOfCallObject
+>;
+
+export interface BalanceOfBatchCallObject {
+  accounts: string[];
+  ids: BigNumber[];
+}
+
+export type BalanceOfBatchCallTrace = TypedCallTrace<
+  [string[], BigNumber[]],
+  BalanceOfBatchCallObject
+>;
+
+export interface IsApprovedForAllCallObject {
+  account: string;
+  operator: string;
+}
+
+export type IsApprovedForAllCallTrace = TypedCallTrace<
+  [string, string],
+  IsApprovedForAllCallObject
+>;
+
+export interface SafeBatchTransferFromCallObject {
+  from: string;
+  to: string;
+  ids: BigNumber[];
+  amounts: BigNumber[];
+  data: string;
+}
+
+export type SafeBatchTransferFromCallTrace = TypedCallTrace<
+  [string, string, BigNumber[], BigNumber[], string],
+  SafeBatchTransferFromCallObject
+>;
+
+export interface SafeTransferFromCallObject {
+  from: string;
+  to: string;
+  id: BigNumber;
+  amount: BigNumber;
+  data: string;
+}
+
+export type SafeTransferFromCallTrace = TypedCallTrace<
+  [string, string, BigNumber, BigNumber, string],
+  SafeTransferFromCallObject
+>;
+
+export interface SetApprovalForAllCallObject {
+  operator: string;
+  approved: boolean;
+}
+
+export type SetApprovalForAllCallTrace = TypedCallTrace<
+  [string, boolean],
+  SetApprovalForAllCallObject
+>;
+
+export interface SupportsInterfaceCallObject {
+  interfaceId: string;
+}
+
+export type SupportsInterfaceCallTrace = TypedCallTrace<
+  [string],
+  SupportsInterfaceCallObject
+>;
+
+export interface UriCallObject {
+  id: BigNumber;
+}
+
+export type UriCallTrace = TypedCallTrace<[BigNumber], UriCallObject>;
+
+const templateContract = ERC1155__factory.connect("", DummyProvider);
+
+export class ERC1155ContractView extends ContractView<ERC1155> {
+  constructor(contract: ERC1155) {
+    super(contract);
+  }
+
+  async balanceOf(
+    account: PromiseOrValue<string>,
+    id: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.balanceOf(account, id, overrides);
+      } else {
+        return await this.contract.balanceOf(account, id);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async balanceOfBatch(
+    accounts: PromiseOrValue<string>[],
+    ids: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<BigNumber[]> {
+    try {
+      if (overrides) {
+        return await this.contract.balanceOfBatch(accounts, ids, overrides);
+      } else {
+        return await this.contract.balanceOfBatch(accounts, ids);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async isApprovedForAll(
+    account: PromiseOrValue<string>,
+    operator: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean> {
+    try {
+      if (overrides) {
+        return await this.contract.isApprovedForAll(
+          account,
+          operator,
+          overrides
+        );
+      } else {
+        return await this.contract.isApprovedForAll(account, operator);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async supportsInterface(
+    interfaceId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<boolean> {
+    try {
+      if (overrides) {
+        return await this.contract.supportsInterface(interfaceId, overrides);
+      } else {
+        return await this.contract.supportsInterface(interfaceId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async uri(
+    id: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.uri(id, overrides);
+      } else {
+        return await this.contract.uri(id);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+}
+
+export class ERC1155BoundContractView extends BoundContractView<
+  ERC1155,
+  ERC1155ContractView
+> {
+  // constructor (contract: ERC1155) {
+  //   super(contract);
+  // }
+
+  async balanceOf(
+    account: PromiseOrValue<string>,
+    id: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.balanceOf(account, id, overrides);
+      } else {
+        return await this.view.balanceOf(account, id);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async balanceOfBatch(
+    accounts: PromiseOrValue<string>[],
+    ids: PromiseOrValue<BigNumberish>[],
+    overrides?: CallOverrides
+  ): Promise<BigNumber[]> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.balanceOfBatch(accounts, ids, overrides);
+      } else {
+        return await this.view.balanceOfBatch(accounts, ids);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async isApprovedForAll(
+    account: PromiseOrValue<string>,
+    operator: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.isApprovedForAll(account, operator, overrides);
+      } else {
+        return await this.view.isApprovedForAll(account, operator);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async supportsInterface(
+    interfaceId: PromiseOrValue<BytesLike>,
+    overrides?: CallOverrides
+  ): Promise<boolean> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.supportsInterface(interfaceId, overrides);
+      } else {
+        return await this.view.supportsInterface(interfaceId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async uri(
+    id: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.uri(id, overrides);
+      } else {
+        return await this.view.uri(id);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+}
+
+export type ERC1155Context = ContractContext<ERC1155, ERC1155BoundContractView>;
+
+export class ERC1155ProcessorTemplate extends BaseProcessorTemplate<
+  ERC1155,
+  ERC1155BoundContractView
+> {
+  bindInternal(options: BindOptions) {
+    if (!options.name) {
+      options.name = "ERC1155";
+    }
+    let processor = getProcessor(options) as ERC1155Processor;
+    if (!processor) {
+      processor = new ERC1155Processor(options);
+      addProcessor(options, processor);
+    }
+    return processor;
+  }
+
+  onEventApprovalForAll(
+    handler: (event: ApprovalForAllEvent, ctx: ERC1155Context) => void,
+    filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "ApprovalForAll(address,address,bool)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventTransferBatch(
+    handler: (event: TransferBatchEvent, ctx: ERC1155Context) => void,
+    filter?: TransferBatchEventFilter | TransferBatchEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "TransferBatch(address,address,address,uint256[],uint256[])"
+      ](null, null, null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventTransferSingle(
+    handler: (event: TransferSingleEvent, ctx: ERC1155Context) => void,
+    filter?: TransferSingleEventFilter | TransferSingleEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "TransferSingle(address,address,address,uint256,uint256)"
+      ](null, null, null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventURI(
+    handler: (event: URIEvent, ctx: ERC1155Context) => void,
+    filter?: URIEventFilter | URIEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "URI(string,uint256)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+}
+
+export class ERC1155Processor extends BaseProcessor<
+  ERC1155,
+  ERC1155BoundContractView
+> {
+  onEventApprovalForAll(
+    handler: (event: ApprovalForAllEvent, ctx: ERC1155Context) => void,
+    filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "ApprovalForAll(address,address,bool)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventTransferBatch(
+    handler: (event: TransferBatchEvent, ctx: ERC1155Context) => void,
+    filter?: TransferBatchEventFilter | TransferBatchEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "TransferBatch(address,address,address,uint256[],uint256[])"
+      ](null, null, null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventTransferSingle(
+    handler: (event: TransferSingleEvent, ctx: ERC1155Context) => void,
+    filter?: TransferSingleEventFilter | TransferSingleEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "TransferSingle(address,address,address,uint256,uint256)"
+      ](null, null, null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventURI(
+    handler: (event: URIEvent, ctx: ERC1155Context) => void,
+    filter?: URIEventFilter | URIEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC1155Processor.filters[
+        // @ts-ignore
+        "URI(string,uint256)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onCallBalanceOf(
+    handler: (call: BalanceOfCallTrace, ctx: ERC1155Context) => void
+  ) {
+    return super.onTrace("0x00fdd58e", handler);
+  }
+
+  onCallBalanceOfBatch(
+    handler: (call: BalanceOfBatchCallTrace, ctx: ERC1155Context) => void
+  ) {
+    return super.onTrace("0x4e1273f4", handler);
+  }
+
+  onCallIsApprovedForAll(
+    handler: (call: IsApprovedForAllCallTrace, ctx: ERC1155Context) => void
+  ) {
+    return super.onTrace("0xe985e9c5", handler);
+  }
+
+  onCallSafeBatchTransferFrom(
+    handler: (call: SafeBatchTransferFromCallTrace, ctx: ERC1155Context) => void
+  ) {
+    return super.onTrace("0x2eb2c2d6", handler);
+  }
+
+  onCallSafeTransferFrom(
+    handler: (call: SafeTransferFromCallTrace, ctx: ERC1155Context) => void
+  ) {
+    return super.onTrace("0xf242432a", handler);
+  }
+
+  onCallSetApprovalForAll(
+    handler: (call: SetApprovalForAllCallTrace, ctx: ERC1155Context) => void
+  ) {
+    return super.onTrace("0xa22cb465", handler);
+  }
+
+  onCallSupportsInterface(
+    handler: (call: SupportsInterfaceCallTrace, ctx: ERC1155Context) => void
+  ) {
+    return super.onTrace("0x01ffc9a7", handler);
+  }
+
+  onCallUri(handler: (call: UriCallTrace, ctx: ERC1155Context) => void) {
+    return super.onTrace("0x0e89341c", handler);
+  }
+
+  public static filters = templateContract.filters;
+
+  protected CreateBoundContractView(): ERC1155BoundContractView {
+    const view = getERC1155Contract(this.config.address, this.config.network);
+    return new ERC1155BoundContractView(view);
+  }
+
+  public static bind(options: BindOptions): ERC1155Processor {
+    if (!options.name) {
+      options.name = "ERC1155";
+    }
+    let processor = getProcessor(options) as ERC1155Processor;
+    if (!processor) {
+      processor = new ERC1155Processor(options);
+      addProcessor(options, processor);
+    }
+    return processor;
+  }
+}
+
+export function getERC1155Contract(
+  address: string,
+  network: Networkish = 1
+): ERC1155ContractView {
+  let contract = getContractByABI(
+    "ERC1155",
+    address,
+    network
+  ) as ERC1155ContractView;
+  if (!contract) {
+    const rawContract = ERC1155__factory.connect(address, getProvider(network));
+    contract = new ERC1155ContractView(rawContract);
+    addContractByABI("ERC1155", address, network, contract);
+  }
+  return contract;
+}