@sentio/sdk 1.40.5 → 1.41.0-rc.1

package/src/builtin/internal/erc20_processor.ts

@@ -1,8 +1,8 @@
 /* Autogenerated file. Do not edit manually. */
 /* tslint:disable */
 /* eslint-disable */
-import { BigNumber, CallOverrides } from "ethers";
-import { Networkish } from "@ethersproject/providers";
+import { Overrides } 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 { ERC20, ERC20__factory } from "./index";
 import {
   ApprovalEvent,
@@ -40,117 +41,128 @@ export interface AllowanceCallObject {
 export type AllowanceCallTrace = TypedCallTrace<
   [string, string],
   AllowanceCallObject
->;
+> &
+  Trace;
 
 export interface ApproveCallObject {
   spender: string;
-  amount: BigNumber;
+  amount: bigint;
 }
 
 export type ApproveCallTrace = TypedCallTrace<
-  [string, BigNumber],
+  [string, bigint],
   ApproveCallObject
->;
+> &
+  Trace;
 
 export interface BalanceOfCallObject {
   account: string;
 }
 
-export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject>;
+export type BalanceOfCallTrace = TypedCallTrace<[string], BalanceOfCallObject> &
+  Trace;
 
 export interface BurnCallObject {
-  amount: BigNumber;
+  amount: bigint;
 }
 
-export type BurnCallTrace = TypedCallTrace<[BigNumber], BurnCallObject>;
+export type BurnCallTrace = TypedCallTrace<[bigint], BurnCallObject> & Trace;
 
 export interface BurnFromCallObject {
   account: string;
-  amount: BigNumber;
+  amount: bigint;
 }
 
 export type BurnFromCallTrace = TypedCallTrace<
-  [string, BigNumber],
+  [string, bigint],
   BurnFromCallObject
->;
+> &
+  Trace;
 
 export interface DecimalsCallObject {}
 
-export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject>;
+export type DecimalsCallTrace = TypedCallTrace<[], DecimalsCallObject> & Trace;
 
 export interface DecreaseAllowanceCallObject {
   spender: string;
-  subtractedValue: BigNumber;
+  subtractedValue: bigint;
 }
 
 export type DecreaseAllowanceCallTrace = TypedCallTrace<
-  [string, BigNumber],
+  [string, bigint],
   DecreaseAllowanceCallObject
->;
+> &
+  Trace;
 
 export interface IncreaseAllowanceCallObject {
   spender: string;
-  addedValue: BigNumber;
+  addedValue: bigint;
 }
 
 export type IncreaseAllowanceCallTrace = TypedCallTrace<
-  [string, BigNumber],
+  [string, bigint],
   IncreaseAllowanceCallObject
->;
+> &
+  Trace;
 
 export interface LockerCallObject {}
 
-export type LockerCallTrace = TypedCallTrace<[], LockerCallObject>;
+export type LockerCallTrace = TypedCallTrace<[], LockerCallObject> & Trace;
 
 export interface NameCallObject {}
 
-export type NameCallTrace = TypedCallTrace<[], NameCallObject>;
+export type NameCallTrace = TypedCallTrace<[], NameCallObject> & Trace;
 
 export interface OwnerCallObject {}
 
-export type OwnerCallTrace = TypedCallTrace<[], OwnerCallObject>;
+export type OwnerCallTrace = TypedCallTrace<[], OwnerCallObject> & Trace;
 
 export interface RenounceOwnershipCallObject {}
 
 export type RenounceOwnershipCallTrace = TypedCallTrace<
   [],
   RenounceOwnershipCallObject
->;
+> &
+  Trace;
 
 export interface SetLockerCallObject {
   _locker: string;
 }
 
-export type SetLockerCallTrace = TypedCallTrace<[string], SetLockerCallObject>;
+export type SetLockerCallTrace = TypedCallTrace<[string], SetLockerCallObject> &
+  Trace;
 
 export interface SymbolCallObject {}
 
-export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject>;
+export type SymbolCallTrace = TypedCallTrace<[], SymbolCallObject> & Trace;
 
 export interface TotalSupplyCallObject {}
 
-export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject>;
+export type TotalSupplyCallTrace = TypedCallTrace<[], TotalSupplyCallObject> &
+  Trace;
 
 export interface TransferCallObject {
   recipient: string;
-  amount: BigNumber;
+  amount: bigint;
 }
 
 export type TransferCallTrace = TypedCallTrace<
-  [string, BigNumber],
+  [string, bigint],
   TransferCallObject
->;
+> &
+  Trace;
 
 export interface TransferFromCallObject {
   sender: string;
   recipient: string;
-  amount: BigNumber;
+  amount: bigint;
 }
 
 export type TransferFromCallTrace = TypedCallTrace<
-  [string, string, BigNumber],
+  [string, string, bigint],
   TransferFromCallObject
->;
+> &
+  Trace;
 
 export interface TransferOwnershipCallObject {
   newOwner: string;
@@ -159,9 +171,10 @@ export interface TransferOwnershipCallObject {
 export type TransferOwnershipCallTrace = TypedCallTrace<
   [string],
   TransferOwnershipCallObject
->;
+> &
+  Trace;
 
-const templateContract = ERC20__factory.connect("", DummyProvider);
+const templateContract = ERC20__factory.connect("0x0", DummyProvider);
 
 export class ERC20ContractView extends ContractView<ERC20> {
   constructor(contract: ERC20) {
@@ -169,103 +182,75 @@ export class ERC20ContractView extends ContractView<ERC20> {
   }
 
   async allowance(
-    owner: PromiseOrValue<string>,
-    spender: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+    owner: string,
+    spender: string,
+    overrides?: Overrides
+  ): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.allowance(owner, spender, overrides);
-      } else {
-        return await this.contract.allowance(owner, spender);
-      }
+      return await this.contract.getFunction("allowance(address,address)")(
+        owner,
+        spender,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async balanceOf(
-    account: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+  async balanceOf(account: string, overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.balanceOf(account, overrides);
-      } else {
-        return await this.contract.balanceOf(account);
-      }
+      return await this.contract.getFunction("balanceOf(address)")(
+        account,
+        overrides || {}
+      );
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async decimals(overrides?: CallOverrides): Promise<number> {
+  async decimals(overrides?: Overrides): Promise<bigint> {
     try {
-      if (overrides) {
-        return await this.contract.decimals(overrides);
-      } else {
-        return await this.contract.decimals();
-      }
+      return await this.contract.getFunction("decimals()")(overrides || {});
     } catch (e) {
       throw transformEtherError(e, undefined);
     }
   }
 
-  async locker(overrides?: CallOverrides): Promise<string> {
+  async locker(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.locker(overrides);
-      } else {
-        return await this.contract.locker();
-      }
+      return await this.contract.getFunction("locker()")(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 owner(overrides?: CallOverrides): Promise<string> {
+  async owner(overrides?: Overrides): Promise<string> {
     try {
-      if (overrides) {
-        return await this.contract.owner(overrides);
-      } else {
-        return await this.contract.owner();
-      }
+      return await this.contract.getFunction("owner()")(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 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);
     }
@@ -276,148 +261,109 @@ export class ERC20BoundContractView extends BoundContractView<
   ERC20,
   ERC20ContractView
 > {
-  // constructor (contract: ERC20) {
-  //   super(contract);
-  // }
-
   async allowance(
-    owner: PromiseOrValue<string>,
-    spender: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+    owner: string,
+    spender: string,
+    overrides?: Overrides
+  ): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.allowance(owner, spender, overrides);
-      } else {
-        return await this.view.allowance(owner, spender);
-      }
+      return await this.view.allowance(owner, spender, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async balanceOf(
-    account: PromiseOrValue<string>,
-    overrides?: CallOverrides
-  ): Promise<BigNumber> {
+  async balanceOf(account: string, overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.balanceOf(account, overrides);
-      } else {
-        return await this.view.balanceOf(account);
-      }
+      return await this.view.balanceOf(account, overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async decimals(overrides?: CallOverrides): Promise<number> {
+  async decimals(overrides?: Overrides): Promise<bigint> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.decimals(overrides);
-      } else {
-        return await this.view.decimals();
-      }
+      return await this.view.decimals(overrides || {});
     } catch (e) {
       throw transformEtherError(e, this.context);
     }
   }
 
-  async locker(overrides?: CallOverrides): Promise<string> {
+  async locker(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.locker(overrides);
-      } else {
-        return await this.view.locker();
-      }
+      return await this.view.locker(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 owner(overrides?: CallOverrides): Promise<string> {
+  async owner(overrides?: Overrides): Promise<string> {
     try {
       if (!overrides && this.context) {
         overrides = {
           blockTag: toBlockTag(this.context.blockNumber),
         };
       }
-      if (overrides) {
-        return await this.view.owner(overrides);
-      } else {
-        return await this.view.owner();
-      }
+      return await this.view.owner(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 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);
     }
@@ -426,70 +372,6 @@ export class ERC20BoundContractView extends BoundContractView<
 
 export type ERC20Context = ContractContext<ERC20, ERC20BoundContractView>;
 
-export class ERC20ProcessorTemplate extends BaseProcessorTemplate<
-  ERC20,
-  ERC20BoundContractView
-> {
-  bindInternal(options: BindOptions) {
-    if (!options.name) {
-      options.name = "ERC20";
-    }
-    let processor = getProcessor(options) as ERC20Processor;
-    if (!processor) {
-      processor = new ERC20Processor(options);
-      addProcessor(options, processor);
-    }
-    return processor;
-  }
-
-  onEventApproval(
-    handler: (event: ApprovalEvent, ctx: ERC20Context) => void,
-    filter?: ApprovalEventFilter | ApprovalEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = ERC20Processor.filters[
-        // @ts-ignore
-        "Approval(address,address,uint256)"
-      ](null, null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-
-  onEventOwnershipTransferred(
-    handler: (event: OwnershipTransferredEvent, ctx: ERC20Context) => void,
-    filter?:
-      | OwnershipTransferredEventFilter
-      | OwnershipTransferredEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = ERC20Processor.filters[
-        // @ts-ignore
-        "OwnershipTransferred(address,address)"
-      ](null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-
-  onEventTransfer(
-    handler: (event: TransferEvent, ctx: ERC20Context) => void,
-    filter?: TransferEventFilter | TransferEventFilter[],
-    fetchConfig?: EthFetchConfig
-  ) {
-    if (!filter) {
-      // @ts-ignore
-      filter = ERC20Processor.filters[
-        // @ts-ignore
-        "Transfer(address,address,uint256)"
-      ](null, null, null);
-    }
-    return super.onEvent(handler, filter!, fetchConfig);
-  }
-}
-
 export class ERC20Processor extends BaseProcessor<
   ERC20,
   ERC20BoundContractView
@@ -500,11 +382,11 @@ export class ERC20Processor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = ERC20Processor.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);
   }
@@ -517,9 +399,7 @@ export class ERC20Processor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = ERC20Processor.filters[
-        // @ts-ignore
+      filter = templateContract.filters[
         "OwnershipTransferred(address,address)"
       ](null, null);
     }
@@ -532,11 +412,11 @@ export class ERC20Processor extends BaseProcessor<
     fetchConfig?: EthFetchConfig
   ) {
     if (!filter) {
-      // @ts-ignore
-      filter = ERC20Processor.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);
   }
@@ -667,7 +547,31 @@ export class ERC20Processor extends BaseProcessor<
     return super.onTrace("0xf2fde38b", handler, fetchConfig);
   }
 
-  public static filters = templateContract.filters;
+  public static filters = {
+    Approval(owner?: string | null, spender?: string | null, value?: null) {
+      return templateContract.filters["Approval(address,address,uint256)"](
+        owner,
+        spender,
+        value
+      );
+    },
+    OwnershipTransferred(
+      previousOwner?: string | null,
+      newOwner?: string | null
+    ) {
+      return templateContract.filters["OwnershipTransferred(address,address)"](
+        previousOwner,
+        newOwner
+      );
+    },
+    Transfer(from?: string | null, to?: string | null, value?: null) {
+      return templateContract.filters["Transfer(address,address,uint256)"](
+        from,
+        to,
+        value
+      );
+    },
+  };
 
   protected CreateBoundContractView(): ERC20BoundContractView {
     const view = getERC20Contract(this.config.address, this.config.network);
@@ -687,6 +591,68 @@ export class ERC20Processor extends BaseProcessor<
   }
 }
 
+export class ERC20ProcessorTemplate extends BaseProcessorTemplate<
+  ERC20,
+  ERC20BoundContractView
+> {
+  bindInternal(options: BindOptions) {
+    if (!options.name) {
+      options.name = "ERC20";
+    }
+    let processor = getProcessor(options) as ERC20Processor;
+    if (!processor) {
+      processor = new ERC20Processor(options);
+      addProcessor(options, processor);
+    }
+    return processor;
+  }
+
+  onEventApproval(
+    handler: (event: ApprovalEvent, ctx: ERC20Context) => void,
+    filter?: ApprovalEventFilter | ApprovalEventFilter[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters["Approval(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+
+  onEventOwnershipTransferred(
+    handler: (event: OwnershipTransferredEvent, ctx: ERC20Context) => void,
+    filter?:
+      | OwnershipTransferredEventFilter
+      | OwnershipTransferredEventFilter[],
+    fetchConfig?: EthFetchConfig
+  ) {
+    if (!filter) {
+      filter = templateContract.filters[
+        "OwnershipTransferred(address,address)"
+      ](null, null);
+    }
+    return super.onEvent(handler, filter!, fetchConfig);
+  }
+
+  onEventTransfer(
+    handler: (event: TransferEvent, ctx: ERC20Context) => 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 getERC20Contract(
   address: string,
   network: Networkish = 1