@sentio/sdk 0.6.5 → 1.0.0-rc.2

package/src/builtin/internal/erc721_processor.ts

@@ -0,0 +1,686 @@
+/* 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 { ERC721, ERC721__factory } from "./index";
+import {
+  ApprovalEvent,
+  ApprovalEventFilter,
+  ApprovalForAllEvent,
+  ApprovalForAllEventFilter,
+  TransferEvent,
+  TransferEventFilter,
+} from "./ERC721";
+
+export interface ApproveCallObject {
+  to: string;
+  tokenId: BigNumber;
+}
+
+export type ApproveCallTrace = TypedCallTrace<
+  [string, BigNumber],
+  ApproveCallObject
+>;
+
+export interface TotalSupplyCallObject {}
+
+export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject>;
+
+export interface BalanceOfCallObject {
+  owner: string;
+}
+
+export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject>;
+
+export interface GetApprovedCallObject {
+  tokenId: BigNumber;
+}
+
+export type GetApprovedCallTrace = TypedCallTrace<
+  [BigNumber],
+  GetApprovedCallObject
+>;
+
+export interface IsApprovedForAllCallObject {
+  owner: string;
+  operator: string;
+}
+
+export type IsApprovedForAllCallTrace = TypedCallTrace<
+  [string, string],
+  IsApprovedForAllCallObject
+>;
+
+export interface NameCallObject {}
+
+export type NameCallTrace = TypedCallTrace<[], NameCallObject>;
+
+export interface OwnerOfCallObject {
+  tokenId: BigNumber;
+}
+
+export type OwnerOfCallTrace = TypedCallTrace<[BigNumber], OwnerOfCallObject>;
+
+export interface SafeTransferFrom_address_address_uint256CallObject {
+  from: string;
+  to: string;
+  tokenId: BigNumber;
+}
+
+export type SafeTransferFrom_address_address_uint256CallTrace = TypedCallTrace<
+  [string, string, BigNumber],
+  SafeTransferFrom_address_address_uint256CallObject
+>;
+
+export interface SafeTransferFrom_address_address_uint256_bytesCallObject {
+  from: string;
+  to: string;
+  tokenId: BigNumber;
+  data: string;
+}
+
+export type SafeTransferFrom_address_address_uint256_bytesCallTrace =
+  TypedCallTrace<
+    [string, string, BigNumber, string],
+    SafeTransferFrom_address_address_uint256_bytesCallObject
+  >;
+
+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 SymbolCallObject {}
+
+export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject>;
+
+export interface TokenURICallObject {
+  tokenId: BigNumber;
+}
+
+export type TokenURICallTrace = TypedCallTrace<[BigNumber], TokenURICallObject>;
+
+export interface TransferFromCallObject {
+  from: string;
+  to: string;
+  tokenId: BigNumber;
+}
+
+export type TransferFromCallTrace = TypedCallTrace<
+  [string, string, BigNumber],
+  TransferFromCallObject
+>;
+
+const templateContract = ERC721__factory.connect("", DummyProvider);
+
+export class ERC721ContractView extends ContractView<ERC721> {
+  constructor(contract: ERC721) {
+    super(contract);
+  }
+
+  async totalSupply(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.totalSupply(overrides);
+      } else {
+        return await this.contract.totalSupply();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async balanceOf(
+    owner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (overrides) {
+        return await this.contract.balanceOf(owner, overrides);
+      } else {
+        return await this.contract.balanceOf(owner);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async getApproved(
+    tokenId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.getApproved(tokenId, overrides);
+      } else {
+        return await this.contract.getApproved(tokenId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async isApprovedForAll(
+    owner: PromiseOrValue<string>,
+    operator: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<boolean> {
+    try {
+      if (overrides) {
+        return await this.contract.isApprovedForAll(owner, operator, overrides);
+      } else {
+        return await this.contract.isApprovedForAll(owner, operator);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async name(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.name(overrides);
+      } else {
+        return await this.contract.name();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async ownerOf(
+    tokenId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.ownerOf(tokenId, overrides);
+      } else {
+        return await this.contract.ownerOf(tokenId);
+      }
+    } 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 symbol(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.symbol(overrides);
+      } else {
+        return await this.contract.symbol();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async tokenURI(
+    tokenId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (overrides) {
+        return await this.contract.tokenURI(tokenId, overrides);
+      } else {
+        return await this.contract.tokenURI(tokenId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+}
+
+export class ERC721BoundContractView extends BoundContractView<
+  ERC721,
+  ERC721ContractView
+> {
+  // constructor (contract: ERC721) {
+  //   super(contract);
+  // }
+
+  async totalSupply(overrides?: CallOverrides): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.totalSupply(overrides);
+      } else {
+        return await this.view.totalSupply();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async balanceOf(
+    owner: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ): Promise<BigNumber> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.balanceOf(owner, overrides);
+      } else {
+        return await this.view.balanceOf(owner);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async getApproved(
+    tokenId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.getApproved(tokenId, overrides);
+      } else {
+        return await this.view.getApproved(tokenId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async isApprovedForAll(
+    owner: 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(owner, operator, overrides);
+      } else {
+        return await this.view.isApprovedForAll(owner, operator);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async name(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.name(overrides);
+      } else {
+        return await this.view.name();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async ownerOf(
+    tokenId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.ownerOf(tokenId, overrides);
+      } else {
+        return await this.view.ownerOf(tokenId);
+      }
+    } 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 symbol(overrides?: CallOverrides): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.symbol(overrides);
+      } else {
+        return await this.view.symbol();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async tokenURI(
+    tokenId: PromiseOrValue<BigNumberish>,
+    overrides?: CallOverrides
+  ): Promise<string> {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.tokenURI(tokenId, overrides);
+      } else {
+        return await this.view.tokenURI(tokenId);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+}
+
+export type ERC721Context = ContractContext<ERC721, ERC721BoundContractView>;
+
+export class ERC721ProcessorTemplate extends BaseProcessorTemplate<
+  ERC721,
+  ERC721BoundContractView
+> {
+  bindInternal(options: BindOptions) {
+    if (!options.name) {
+      options.name = "ERC721";
+    }
+    let processor = getProcessor(options) as ERC721Processor;
+    if (!processor) {
+      processor = new ERC721Processor(options);
+      addProcessor(options, processor);
+    }
+    return processor;
+  }
+
+  onEventApproval(
+    handler: (event: ApprovalEvent, ctx: ERC721Context) => void,
+    filter?: ApprovalEventFilter | ApprovalEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC721Processor.filters[
+        // @ts-ignore
+        "Approval(address,address,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventApprovalForAll(
+    handler: (event: ApprovalForAllEvent, ctx: ERC721Context) => void,
+    filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC721Processor.filters[
+        // @ts-ignore
+        "ApprovalForAll(address,address,bool)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventTransfer(
+    handler: (event: TransferEvent, ctx: ERC721Context) => void,
+    filter?: TransferEventFilter | TransferEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC721Processor.filters[
+        // @ts-ignore
+        "Transfer(address,address,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+}
+
+export class ERC721Processor extends BaseProcessor<
+  ERC721,
+  ERC721BoundContractView
+> {
+  onEventApproval(
+    handler: (event: ApprovalEvent, ctx: ERC721Context) => void,
+    filter?: ApprovalEventFilter | ApprovalEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC721Processor.filters[
+        // @ts-ignore
+        "Approval(address,address,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventApprovalForAll(
+    handler: (event: ApprovalForAllEvent, ctx: ERC721Context) => void,
+    filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC721Processor.filters[
+        // @ts-ignore
+        "ApprovalForAll(address,address,bool)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onEventTransfer(
+    handler: (event: TransferEvent, ctx: ERC721Context) => void,
+    filter?: TransferEventFilter | TransferEventFilter[]
+  ) {
+    if (!filter) {
+      // @ts-ignore
+      filter = ERC721Processor.filters[
+        // @ts-ignore
+        "Transfer(address,address,uint256)"
+      ](null, null, null);
+    }
+    return super.onEvent(handler, filter!);
+  }
+
+  onCallApprove(handler: (call: ApproveCallTrace, ctx: ERC721Context) => void) {
+    return super.onTrace("0x095ea7b3", handler);
+  }
+
+  onCallTotalSupply(
+    handler: (call: TotalSupplyCallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0x18160ddd", handler);
+  }
+
+  onCallBalanceOf(
+    handler: (call: BalanceOfCallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0x70a08231", handler);
+  }
+
+  onCallGetApproved(
+    handler: (call: GetApprovedCallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0x081812fc", handler);
+  }
+
+  onCallIsApprovedForAll(
+    handler: (call: IsApprovedForAllCallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0xe985e9c5", handler);
+  }
+
+  onCallName(handler: (call: NameCallTrace, ctx: ERC721Context) => void) {
+    return super.onTrace("0x06fdde03", handler);
+  }
+
+  onCallOwnerOf(handler: (call: OwnerOfCallTrace, ctx: ERC721Context) => void) {
+    return super.onTrace("0x6352211e", handler);
+  }
+
+  onCallSafeTransferFrom_address_address_uint256(
+    handler: (
+      call: SafeTransferFrom_address_address_uint256CallTrace,
+      ctx: ERC721Context
+    ) => void
+  ) {
+    return super.onTrace("0x42842e0e", handler);
+  }
+
+  onCallSafeTransferFrom_address_address_uint256_bytes(
+    handler: (
+      call: SafeTransferFrom_address_address_uint256_bytesCallTrace,
+      ctx: ERC721Context
+    ) => void
+  ) {
+    return super.onTrace("0xb88d4fde", handler);
+  }
+
+  onCallSetApprovalForAll(
+    handler: (call: SetApprovalForAllCallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0xa22cb465", handler);
+  }
+
+  onCallSupportsInterface(
+    handler: (call: SupportsInterfaceCallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0x01ffc9a7", handler);
+  }
+
+  onCallSymbol(handler: (call: SymbolCallTrace, ctx: ERC721Context) => void) {
+    return super.onTrace("0x95d89b41", handler);
+  }
+
+  onCallTokenURI(
+    handler: (call: TokenURICallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0xc87b56dd", handler);
+  }
+
+  onCallTransferFrom(
+    handler: (call: TransferFromCallTrace, ctx: ERC721Context) => void
+  ) {
+    return super.onTrace("0x23b872dd", handler);
+  }
+
+  public static filters = templateContract.filters;
+
+  protected CreateBoundContractView(): ERC721BoundContractView {
+    const view = getERC721Contract(this.config.address, this.config.network);
+    return new ERC721BoundContractView(view);
+  }
+
+  public static bind(options: BindOptions): ERC721Processor {
+    if (!options.name) {
+      options.name = "ERC721";
+    }
+    let processor = getProcessor(options) as ERC721Processor;
+    if (!processor) {
+      processor = new ERC721Processor(options);
+      addProcessor(options, processor);
+    }
+    return processor;
+  }
+}
+
+export function getERC721Contract(
+  address: string,
+  network: Networkish = 1
+): ERC721ContractView {
+  let contract = getContractByABI(
+    "ERC721",
+    address,
+    network
+  ) as ERC721ContractView;
+  if (!contract) {
+    const rawContract = ERC721__factory.connect(address, getProvider(network));
+    contract = new ERC721ContractView(rawContract);
+    addContractByABI("ERC721", address, network, contract);
+  }
+  return contract;
+}