@sentio/sdk 1.40.5 → 2.0.0-rc.1

package/src/builtin/internal/erc721_processor.ts

@@ -1,8 +1,8 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import { BigNumber, BigNumberish, CallOverrides, BytesLike } from "ethers";
-import { Networkish } from "@ethersproject/providers";
+import { BigNumberish, Overrides, BytesLike } from "ethers";
+import { Networkish } from "ethers/providers";
 import {
   addContractByABI,
   getContractByABI,
@@ -10,6 +10,7 @@ import {
   getProcessor,
   getProvider,
   transformEtherError,
+  Trace,
   BindOptions,
   BaseProcessor,
   BaseProcessorTemplate,
@@ -21,7 +22,7 @@ import {
   toBlockTag,
 } from "@sentio/sdk";
 import { EthFetchConfig } from "@sentio/protos";
-import { PromiseOrValue } from "./common";
+
 import { ERC721, ERC721__factory } from "./index";
 import {
   ApprovalEvent,
@@ -34,32 +35,36 @@ import {
 
 export interface ApproveCallObject {
   to: string;
-  tokenId: BigNumber;
+  tokenId: bigint;
 }
 
 export type ApproveCallTrace = TypedCallTrace<
-  [string, BigNumber],
+  [string, bigint],
   ApproveCallObject
->;
+> &
+  Trace;
 
 export interface TotalSupplyCallObject {}
 
-export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject>;
+export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject> &
+  Trace;
 
 export interface BalanceOfCallObject {
   owner: string;
 }
 
-export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject>;
+export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject> &
+  Trace;
 
 export interface GetApprovedCallObject {
-  tokenId: BigNumber;
+  tokenId: bigint;
 }
 
 export type GetApprovedCallTrace = TypedCallTrace<
-  [BigNumber],
+  [bigint],
   GetApprovedCallObject
->;
+> &
+  Trace;
 
 export interface IsApprovedForAllCallObject {
   owner: string;
@@ -69,41 +74,45 @@ export interface IsApprovedForAllCallObject {
 export type IsApprovedForAllCallTrace = TypedCallTrace<
   [string, string],
   IsApprovedForAllCallObject
->;
+> &
+  Trace;
 
 export interface NameCallObject {}
 
-export type NameCallTrace = TypedCallTrace<[], NameCallObject>;
+export type NameCallTrace = TypedCallTrace<[], NameCallObject> & Trace;
 
 export interface OwnerOfCallObject {
-  tokenId: BigNumber;
+  tokenId: bigint;
 }
 
-export type OwnerOfCallTrace = TypedCallTrace<[BigNumber], OwnerOfCallObject>;
+export type OwnerOfCallTrace = TypedCallTrace<[bigint], OwnerOfCallObject> &
+  Trace;
 
 export interface SafeTransferFrom_address_address_uint256CallObject {
   from: string;
   to: string;
-  tokenId: BigNumber;
+  tokenId: bigint;
 }
 
 export type SafeTransferFrom_address_address_uint256CallTrace = TypedCallTrace<
-  [string, string, BigNumber],
+  [string, string, bigint],
   SafeTransferFrom_address_address_uint256CallObject
->;
+> &
+  Trace;
 
 export interface SafeTransferFrom_address_address_uint256_bytesCallObject {
   from: string;
   to: string;
-  tokenId: BigNumber;
+  tokenId: bigint;
   data: string;
 }
 
 export type SafeTransferFrom_address_address_uint256_bytesCallTrace =
   TypedCallTrace<
-    [string, string, BigNumber, string],
+    [string, string, bigint, string],
     SafeTransferFrom_address_address_uint256_bytesCallObject
-  >;
+  > &
+    Trace;
 
 export interface SetApprovalForAllCallObject {
   operator: string;
@@ -113,7 +122,8 @@ export interface SetApprovalForAllCallObject {
 export type SetApprovalForAllCallTrace = TypedCallTrace<
   [string, boolean],
   SetApprovalForAllCallObject
->;
+> &
+  Trace;
 
 export interface SupportsInterfaceCallObject {
   interfaceId: string;
@@ -122,158 +132,136 @@ export interface SupportsInterfaceCallObject {
 export type SupportsInterfaceCallTrace = TypedCallTrace<
   [string],
   SupportsInterfaceCallObject
->;
+> &
+  Trace;
 
 export interface SymbolCallObject {}
 
-export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject>;
+export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject> & Trace;
 
 export interface TokenURICallObject {
-  tokenId: BigNumber;
+  tokenId: bigint;
 }
 
-export type TokenURICallTrace = TypedCallTrace<[BigNumber], TokenURICallObject>;
+export type TokenURICallTrace = TypedCallTrace<[bigint], TokenURICallObject> &
+  Trace;
 
 export interface TransferFromCallObject {
   from: string;
   to: string;
-  tokenId: BigNumber;
+  tokenId: bigint;
 }
 
 export type TransferFromCallTrace = TypedCallTrace<
-  [string, string, BigNumber],
+  [string, string, bigint],
   TransferFromCallObject
->;
+> &
+  Trace;
 
-const templateContract = ERC721__factory.connect("", DummyProvider);
+const templateContract = ERC721__factory.connect("0x0", DummyProvider);
 
 export class ERC721ContractView extends ContractView<ERC721> {
   constructor(contract: ERC721) {
     super(contract);
   }
 
-  async totalSupply(overrides?: CallOverrides): Promise<BigNumber> {
+  async totalSupply(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.totalSupply(overrides);
-      } else {
-        return await this.contract.totalSupply();
-      }
+      return await this.contract.getFunction("totalSupply()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async balanceOf(
-    owner: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+  async balanceOf(owner: string, overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.balanceOf(owner, overrides);
-      } else {
-        return await this.contract.balanceOf(owner);
-      }
+      return await this.contract.getFunction("balanceOf(address)")(
+        owner,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async getApproved(
-    tokenId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    tokenId: BigNumberish,
+    overrides?: Overrides
   ): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.getApproved(tokenId, overrides);
-      } else {
-        return await this.contract.getApproved(tokenId);
-      }
+      return await this.contract.getFunction("getApproved(uint256)")(
+        tokenId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async isApprovedForAll(
-    owner: PromiseOrValue<string>,
-    operator: PromiseOrValue<string>,
-    overrides?: CallOverrides
+    owner: string,
+    operator: string,
+    overrides?: Overrides
   ): Promise<boolean> {
     try {
-      if (overrides) {
-        return await this.contract.isApprovedForAll(owner, operator, overrides);
-      } else {
-        return await this.contract.isApprovedForAll(owner, operator);
-      }
+      return await this.contract.getFunction(
+        "isApprovedForAll(address,address)"
+      )(owner, operator, overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async name(overrides?: CallOverrides): Promise<string> {
+  async name(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.name(overrides);
-      } else {
-        return await this.contract.name();
-      }
+      return await this.contract.getFunction("name()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async ownerOf(
-    tokenId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
-  ): Promise<string> {
+  async ownerOf(tokenId: BigNumberish, overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.ownerOf(tokenId, overrides);
-      } else {
-        return await this.contract.ownerOf(tokenId);
-      }
+      return await this.contract.getFunction("ownerOf(uint256)")(
+        tokenId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async supportsInterface(
-    interfaceId: PromiseOrValue<BytesLike>,
-    overrides?: CallOverrides
+    interfaceId: BytesLike,
+    overrides?: Overrides
   ): Promise<boolean> {
     try {
-      if (overrides) {
-        return await this.contract.supportsInterface(interfaceId, overrides);
-      } else {
-        return await this.contract.supportsInterface(interfaceId);
-      }
+      return await this.contract.getFunction("supportsInterface(bytes4)")(
+        interfaceId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async symbol(overrides?: CallOverrides): Promise<string> {
+  async symbol(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.symbol(overrides);
-      } else {
-        return await this.contract.symbol();
-      }
+      return await this.contract.getFunction("symbol()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
   async tokenURI(
-    tokenId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    tokenId: BigNumberish,
+    overrides?: Overrides
   ): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.tokenURI(tokenId, overrides);
-      } else {
-        return await this.contract.tokenURI(tokenId);
-      }
+      return await this.contract.getFunction("tokenURI(uint256)")(
+        tokenId,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
@@ -284,50 +272,35 @@ export class ERC721BoundContractView extends BoundContractView<
   ERC721,
   ERC721ContractView
 > {
-  // constructor (contract: ERC721) {
-  //   super(contract);
-  // }
-
-  async totalSupply(overrides?: CallOverrides): Promise<BigNumber> {
+  async totalSupply(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.totalSupply(overrides);
-      } else {
-        return await this.view.totalSupply();
-      }
+      return await this.view.totalSupply(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async balanceOf(
-    owner: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+  async balanceOf(owner: string, overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.balanceOf(owner, overrides);
-      } else {
-        return await this.view.balanceOf(owner);
-      }
+      return await this.view.balanceOf(owner, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async getApproved(
-    tokenId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    tokenId: BigNumberish,
+    overrides?: Overrides
   ): Promise<string> {
     try {
       if (!overrides && this.context) {
@@ -335,20 +308,16 @@ export class ERC721BoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.getApproved(tokenId, overrides);
-      } else {
-        return await this.view.getApproved(tokenId);
-      }
+      return await this.view.getApproved(tokenId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async isApprovedForAll(
-    owner: PromiseOrValue<string>,
-    operator: PromiseOrValue<string>,
-    overrides?: CallOverrides
+    owner: string,
+    operator: string,
+    overrides?: Overrides
   ): Promise<boolean> {
     try {
       if (!overrides && this.context) {
@@ -356,56 +325,41 @@ export class ERC721BoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.isApprovedForAll(owner, operator, overrides);
-      } else {
-        return await this.view.isApprovedForAll(owner, operator);
-      }
+      return await this.view.isApprovedForAll(owner, operator, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async name(overrides?: CallOverrides): Promise<string> {
+  async name(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.name(overrides);
-      } else {
-        return await this.view.name();
-      }
+      return await this.view.name(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async ownerOf(
-    tokenId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
-  ): Promise<string> {
+  async ownerOf(tokenId: BigNumberish, overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.ownerOf(tokenId, overrides);
-      } else {
-        return await this.view.ownerOf(tokenId);
-      }
+      return await this.view.ownerOf(tokenId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async supportsInterface(
-    interfaceId: PromiseOrValue<BytesLike>,
-    overrides?: CallOverrides
+    interfaceId: BytesLike,
+    overrides?: Overrides
   ): Promise<boolean> {
     try {
       if (!overrides && this.context) {
@@ -413,36 +367,28 @@ export class ERC721BoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.supportsInterface(interfaceId, overrides);
-      } else {
-        return await this.view.supportsInterface(interfaceId);
-      }
+      return await this.view.supportsInterface(interfaceId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async symbol(overrides?: CallOverrides): Promise<string> {
+  async symbol(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.symbol(overrides);
-      } else {
-        return await this.view.symbol();
-      }
+      return await this.view.symbol(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
   async tokenURI(
-    tokenId: PromiseOrValue<BigNumberish>,
-    overrides?: CallOverrides
+    tokenId: BigNumberish,
+    overrides?: Overrides
   ): Promise<string> {
     try {
       if (!overrides && this.context) {
@@ -450,11 +396,7 @@ export class ERC721BoundContractView extends BoundContractView<
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.tokenURI(tokenId, overrides);
-      } else {
-        return await this.view.tokenURI(tokenId);
-      }
+      return await this.view.tokenURI(tokenId, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
@@ -463,68 +405,6 @@ export class ERC721BoundContractView extends BoundContractView<
 
 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[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = ERC721Processor.filters[
-        // @ts-ignore
-        "Approval(address,address,uint256)"
-      ](null, null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-
-  onEventApprovalForAll(
-    handler: (event: ApprovalForAllEvent, ctx: ERC721Context) => void,
-    filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = ERC721Processor.filters[
-        // @ts-ignore
-        "ApprovalForAll(address,address,bool)"
-      ](null, null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-
-  onEventTransfer(
-    handler: (event: TransferEvent, ctx: ERC721Context) => void,
-    filter?: TransferEventFilter | TransferEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = ERC721Processor.filters[
-        // @ts-ignore
-        "Transfer(address,address,uint256)"
-      ](null, null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-}
-
 export class ERC721Processor extends BaseProcessor<
   ERC721,
   ERC721BoundContractView
@@ -535,11 +415,11 @@ export class ERC721Processor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = ERC721Processor.filters[
-        // @ts-ignore
-        "Approval(address,address,uint256)"
-      ](null, null, null);
+      filter = templateContract.filters["Approval(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
     }
     return super.onEvent(handler, filter!, fetchConfig);
   }
@@ -550,11 +430,11 @@ export class ERC721Processor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = ERC721Processor.filters[
-        // @ts-ignore
-        "ApprovalForAll(address,address,bool)"
-      ](null, null, null);
+      filter = templateContract.filters["ApprovalForAll(address,address,bool)"](
+        null,
+        null,
+        null
+      );
     }
     return super.onEvent(handler, filter!, fetchConfig);
   }
@@ -565,11 +445,11 @@ export class ERC721Processor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = ERC721Processor.filters[
-        // @ts-ignore
-        "Transfer(address,address,uint256)"
-      ](null, null, null);
+      filter = templateContract.filters["Transfer(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
     }
     return super.onEvent(handler, filter!, fetchConfig);
   }
@@ -678,7 +558,41 @@ export class ERC721Processor extends BaseProcessor<
     return super.onTrace("0x23b872dd", handler, fetchConfig);
   }
 
-  public static filters = templateContract.filters;
+  public static filters = {
+    Approval(
+      owner?: string | null,
+      approved?: string | null,
+      tokenId?: BigNumberish | null
+    ) {
+      return templateContract.filters["Approval(address,address,uint256)"](
+        owner,
+        approved,
+        tokenId
+      );
+    },
+    ApprovalForAll(
+      owner?: string | null,
+      operator?: string | null,
+      approved?: null
+    ) {
+      return templateContract.filters["ApprovalForAll(address,address,bool)"](
+        owner,
+        operator,
+        approved
+      );
+    },
+    Transfer(
+      from?: string | null,
+      to?: string | null,
+      tokenId?: BigNumberish | null
+    ) {
+      return templateContract.filters["Transfer(address,address,uint256)"](
+        from,
+        to,
+        tokenId
+      );
+    },
+  };
 
   protected CreateBoundContractView(): ERC721BoundContractView {
     const view = getERC721Contract(this.config.address, this.config.network);
@@ -698,6 +612,68 @@ export class ERC721Processor extends BaseProcessor<
   }
 }
 
+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[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters["Approval(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+
+  onEventApprovalForAll(
+    handler: (event: ApprovalForAllEvent, ctx: ERC721Context) => void,
+    filter?: ApprovalForAllEventFilter | ApprovalForAllEventFilter[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters["ApprovalForAll(address,address,bool)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+
+  onEventTransfer(
+    handler: (event: TransferEvent, ctx: ERC721Context) => void,
+    filter?: TransferEventFilter | TransferEventFilter[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters["Transfer(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+}
+
 export function getERC721Contract(
   address: string,
   network: Networkish = 1