@sentio/sdk 1.7.20 → 1.7.21

package/src/builtin/internal/erc20_processor.ts

@@ -20,17 +20,19 @@ import {
   getContractName,
 } from "@sentio/sdk";
 import { PromiseOrValue } from "./common";
-import { Erc20, Erc20__factory } from "./index";
+import { ERC20, ERC20__factory } from "./index";
 import {
   ApprovalEvent,
   ApprovalEventFilter,
+  OwnershipTransferredEvent,
+  OwnershipTransferredEventFilter,
   TransferEvent,
   TransferEventFilter,
-} from "./Erc20";
-const templateContract = Erc20__factory.connect("", DummyProvider);
+} from "./ERC20";
+const templateContract = ERC20__factory.connect("", DummyProvider);
 
-export class Erc20ContractView extends ContractView<Erc20> {
-  constructor(contract: Erc20) {
+export class ERC20ContractView extends ContractView<ERC20> {
+  constructor(contract: ERC20) {
     super(contract);
   }
 
@@ -74,6 +76,54 @@ export class Erc20ContractView extends ContractView<Erc20> {
     }
   }
 
+  async locker(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.locker(overrides);
+      } else {
+        return await this.contract.locker();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async name(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.name(overrides);
+      } else {
+        return await this.contract.name();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async owner(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.owner(overrides);
+      } else {
+        return await this.contract.owner();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async symbol(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.symbol(overrides);
+      } else {
+        return await this.contract.symbol();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
   async totalSupply(overrides?: CallOverrides) {
     try {
       if (overrides) {
@@ -87,11 +137,11 @@ export class Erc20ContractView extends ContractView<Erc20> {
   }
 }
 
-export class Erc20BoundContractView extends BoundContractView<
-  Erc20,
-  Erc20ContractView
+export class ERC20BoundContractView extends BoundContractView<
+  ERC20,
+  ERC20ContractView
 > {
-  // constructor (contract: Erc20) {
+  // constructor (contract: ERC20) {
   //   super(contract);
   // }
 
@@ -150,6 +200,74 @@ export class Erc20BoundContractView extends BoundContractView<
     }
   }
 
+  async locker(overrides?: CallOverrides) {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.locker(overrides);
+      } else {
+        return await this.view.locker();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async name(overrides?: CallOverrides) {
+    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 owner(overrides?: CallOverrides) {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.owner(overrides);
+      } else {
+        return await this.view.owner();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async symbol(overrides?: CallOverrides) {
+    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 totalSupply(overrides?: CallOverrides) {
     try {
       if (!overrides && this.context) {
@@ -168,34 +286,34 @@ export class Erc20BoundContractView extends BoundContractView<
   }
 }
 
-export type Erc20Context = Context<Erc20, Erc20BoundContractView>;
+export type ERC20Context = Context<ERC20, ERC20BoundContractView>;
 
-export class Erc20ProcessorTemplate extends BaseProcessorTemplate<
-  Erc20,
-  Erc20BoundContractView
+export class ERC20ProcessorTemplate extends BaseProcessorTemplate<
+  ERC20,
+  ERC20BoundContractView
 > {
   bindInternal(options: BindOptions) {
-    let processor = getProcessor("Erc20", options) as Erc20Processor;
+    let processor = getProcessor("ERC20", options) as ERC20Processor;
     if (!processor) {
       const finalOptions = Object.assign({}, options);
       finalOptions.name = getContractName(
-        "Erc20",
+        "ERC20",
         options.name,
         options.address,
         options.network
       );
-      processor = new Erc20Processor(finalOptions);
-      addProcessor("Erc20", options, processor);
+      processor = new ERC20Processor(finalOptions);
+      addProcessor("ERC20", options, processor);
     }
     return processor;
   }
 
   onApproval(
-    handler: (event: ApprovalEvent, ctx: Erc20Context) => void,
+    handler: (event: ApprovalEvent, ctx: ERC20Context) => void,
     filter?: ApprovalEventFilter | ApprovalEventFilter[]
   ) {
     if (!filter) {
-      filter = Erc20Processor.filters["Approval(address,address,uint256)"](
+      filter = ERC20Processor.filters["Approval(address,address,uint256)"](
         null,
         null,
         null
@@ -204,12 +322,25 @@ export class Erc20ProcessorTemplate extends BaseProcessorTemplate<
     return super.onEvent(handler, filter);
   }
 
+  onOwnershipTransferred(
+    handler: (event: OwnershipTransferredEvent, ctx: ERC20Context) => void,
+    filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[]
+  ) {
+    if (!filter) {
+      filter = ERC20Processor.filters["OwnershipTransferred(address,address)"](
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter);
+  }
+
   onTransfer(
-    handler: (event: TransferEvent, ctx: Erc20Context) => void,
+    handler: (event: TransferEvent, ctx: ERC20Context) => void,
     filter?: TransferEventFilter | TransferEventFilter[]
   ) {
     if (!filter) {
-      filter = Erc20Processor.filters["Transfer(address,address,uint256)"](
+      filter = ERC20Processor.filters["Transfer(address,address,uint256)"](
         null,
         null,
         null
@@ -219,16 +350,16 @@ export class Erc20ProcessorTemplate extends BaseProcessorTemplate<
   }
 }
 
-export class Erc20Processor extends BaseProcessor<
-  Erc20,
-  Erc20BoundContractView
+export class ERC20Processor extends BaseProcessor<
+  ERC20,
+  ERC20BoundContractView
 > {
   onApproval(
-    handler: (event: ApprovalEvent, ctx: Erc20Context) => void,
+    handler: (event: ApprovalEvent, ctx: ERC20Context) => void,
     filter?: ApprovalEventFilter | ApprovalEventFilter[]
   ) {
     if (!filter) {
-      filter = Erc20Processor.filters["Approval(address,address,uint256)"](
+      filter = ERC20Processor.filters["Approval(address,address,uint256)"](
         null,
         null,
         null
@@ -237,12 +368,25 @@ export class Erc20Processor extends BaseProcessor<
     return super.onEvent(handler, filter);
   }
 
+  onOwnershipTransferred(
+    handler: (event: OwnershipTransferredEvent, ctx: ERC20Context) => void,
+    filter?: OwnershipTransferredEventFilter | OwnershipTransferredEventFilter[]
+  ) {
+    if (!filter) {
+      filter = ERC20Processor.filters["OwnershipTransferred(address,address)"](
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter);
+  }
+
   onTransfer(
-    handler: (event: TransferEvent, ctx: Erc20Context) => void,
+    handler: (event: TransferEvent, ctx: ERC20Context) => void,
     filter?: TransferEventFilter | TransferEventFilter[]
   ) {
     if (!filter) {
-      filter = Erc20Processor.filters["Transfer(address,address,uint256)"](
+      filter = ERC20Processor.filters["Transfer(address,address,uint256)"](
         null,
         null,
         null
@@ -253,43 +397,43 @@ export class Erc20Processor extends BaseProcessor<
 
   public static filters = templateContract.filters;
 
-  protected CreateBoundContractView(): Erc20BoundContractView {
-    const view = getErc20Contract(this.config.address, this.config.network);
-    return new Erc20BoundContractView(view);
+  protected CreateBoundContractView(): ERC20BoundContractView {
+    const view = getERC20Contract(this.config.address, this.config.network);
+    return new ERC20BoundContractView(view);
   }
 
-  public static bind(options: BindOptions): Erc20Processor {
-    let processor = getProcessor("Erc20", options) as Erc20Processor;
+  public static bind(options: BindOptions): ERC20Processor {
+    let processor = getProcessor("ERC20", options) as ERC20Processor;
     if (!processor) {
-      // const wrapper = getErc20Contract(options.address, options.network)
+      // const wrapper = getERC20Contract(options.address, options.network)
 
       const finalOptions = Object.assign({}, options);
       finalOptions.name = getContractName(
-        "Erc20",
+        "ERC20",
         options.name,
         options.address,
         options.network
       );
-      processor = new Erc20Processor(finalOptions);
-      addProcessor("Erc20", options, processor);
+      processor = new ERC20Processor(finalOptions);
+      addProcessor("ERC20", options, processor);
     }
     return processor;
   }
 }
 
-export function getErc20Contract(
+export function getERC20Contract(
   address: string,
   network: Networkish = 1
-): Erc20ContractView {
+): ERC20ContractView {
   let contract = getContractByABI(
-    "Erc20",
+    "ERC20",
     address,
     network
-  ) as Erc20ContractView;
+  ) as ERC20ContractView;
   if (!contract) {
-    const rawContract = Erc20__factory.connect(address, getProvider(network));
-    contract = new Erc20ContractView(rawContract);
-    addContractByABI("Erc20", address, network, contract);
+    const rawContract = ERC20__factory.connect(address, getProvider(network));
+    contract = new ERC20ContractView(rawContract);
+    addContractByABI("ERC20", address, network, contract);
   }
   return contract;
 }

package/src/builtin/internal/erc20bytes_processor.ts

@@ -0,0 +1,362 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import { CallOverrides } from "ethers";
+import { Networkish } from "@ethersproject/providers";
+import {
+  addContractByABI,
+  getContractByABI,
+  addProcessor,
+  getProcessor,
+  getProvider,
+  transformEtherError,
+  BindOptions,
+  BaseProcessor,
+  BaseProcessorTemplate,
+  BoundContractView,
+  Context,
+  ContractView,
+  DummyProvider,
+  getContractName,
+} from "@sentio/sdk";
+import { PromiseOrValue } from "./common";
+import { ERC20Bytes, ERC20Bytes__factory } from "./index";
+import {
+  ApprovalEvent,
+  ApprovalEventFilter,
+  TransferEvent,
+  TransferEventFilter,
+} from "./ERC20Bytes";
+const templateContract = ERC20Bytes__factory.connect("", DummyProvider);
+
+export class ERC20BytesContractView extends ContractView<ERC20Bytes> {
+  constructor(contract: ERC20Bytes) {
+    super(contract);
+  }
+
+  async name(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.name(overrides);
+      } else {
+        return await this.contract.name();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async totalSupply(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.totalSupply(overrides);
+      } else {
+        return await this.contract.totalSupply();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async decimals(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.decimals(overrides);
+      } else {
+        return await this.contract.decimals();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async balanceOf(who: PromiseOrValue<string>, overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.balanceOf(who, overrides);
+      } else {
+        return await this.contract.balanceOf(who);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async symbol(overrides?: CallOverrides) {
+    try {
+      if (overrides) {
+        return await this.contract.symbol(overrides);
+      } else {
+        return await this.contract.symbol();
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+
+  async allowance(
+    owner: PromiseOrValue<string>,
+    spender: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ) {
+    try {
+      if (overrides) {
+        return await this.contract.allowance(owner, spender, overrides);
+      } else {
+        return await this.contract.allowance(owner, spender);
+      }
+    } catch (e) {
+      throw transformEtherError(e, undefined);
+    }
+  }
+}
+
+export class ERC20BytesBoundContractView extends BoundContractView<
+  ERC20Bytes,
+  ERC20BytesContractView
+> {
+  // constructor (contract: ERC20Bytes) {
+  //   super(contract);
+  // }
+
+  async name(overrides?: CallOverrides) {
+    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 totalSupply(overrides?: CallOverrides) {
+    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 decimals(overrides?: CallOverrides) {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.decimals(overrides);
+      } else {
+        return await this.view.decimals();
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async balanceOf(who: PromiseOrValue<string>, overrides?: CallOverrides) {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.balanceOf(who, overrides);
+      } else {
+        return await this.view.balanceOf(who);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+
+  async symbol(overrides?: CallOverrides) {
+    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 allowance(
+    owner: PromiseOrValue<string>,
+    spender: PromiseOrValue<string>,
+    overrides?: CallOverrides
+  ) {
+    try {
+      if (!overrides && this.context) {
+        overrides = {
+          blockTag: this.context.blockNumber.toNumber(),
+        };
+      }
+      if (overrides) {
+        return await this.view.allowance(owner, spender, overrides);
+      } else {
+        return await this.view.allowance(owner, spender);
+      }
+    } catch (e) {
+      throw transformEtherError(e, this.context);
+    }
+  }
+}
+
+export type ERC20BytesContext = Context<
+  ERC20Bytes,
+  ERC20BytesBoundContractView
+>;
+
+export class ERC20BytesProcessorTemplate extends BaseProcessorTemplate<
+  ERC20Bytes,
+  ERC20BytesBoundContractView
+> {
+  bindInternal(options: BindOptions) {
+    let processor = getProcessor("ERC20Bytes", options) as ERC20BytesProcessor;
+    if (!processor) {
+      const finalOptions = Object.assign({}, options);
+      finalOptions.name = getContractName(
+        "ERC20Bytes",
+        options.name,
+        options.address,
+        options.network
+      );
+      processor = new ERC20BytesProcessor(finalOptions);
+      addProcessor("ERC20Bytes", options, processor);
+    }
+    return processor;
+  }
+
+  onApproval(
+    handler: (event: ApprovalEvent, ctx: ERC20BytesContext) => void,
+    filter?: ApprovalEventFilter | ApprovalEventFilter[]
+  ) {
+    if (!filter) {
+      filter = ERC20BytesProcessor.filters["Approval(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter);
+  }
+
+  onTransfer(
+    handler: (event: TransferEvent, ctx: ERC20BytesContext) => void,
+    filter?: TransferEventFilter | TransferEventFilter[]
+  ) {
+    if (!filter) {
+      filter = ERC20BytesProcessor.filters["Transfer(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter);
+  }
+}
+
+export class ERC20BytesProcessor extends BaseProcessor<
+  ERC20Bytes,
+  ERC20BytesBoundContractView
+> {
+  onApproval(
+    handler: (event: ApprovalEvent, ctx: ERC20BytesContext) => void,
+    filter?: ApprovalEventFilter | ApprovalEventFilter[]
+  ) {
+    if (!filter) {
+      filter = ERC20BytesProcessor.filters["Approval(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter);
+  }
+
+  onTransfer(
+    handler: (event: TransferEvent, ctx: ERC20BytesContext) => void,
+    filter?: TransferEventFilter | TransferEventFilter[]
+  ) {
+    if (!filter) {
+      filter = ERC20BytesProcessor.filters["Transfer(address,address,uint256)"](
+        null,
+        null,
+        null
+      );
+    }
+    return super.onEvent(handler, filter);
+  }
+
+  public static filters = templateContract.filters;
+
+  protected CreateBoundContractView(): ERC20BytesBoundContractView {
+    const view = getERC20BytesContract(
+      this.config.address,
+      this.config.network
+    );
+    return new ERC20BytesBoundContractView(view);
+  }
+
+  public static bind(options: BindOptions): ERC20BytesProcessor {
+    let processor = getProcessor("ERC20Bytes", options) as ERC20BytesProcessor;
+    if (!processor) {
+      // const wrapper = getERC20BytesContract(options.address, options.network)
+
+      const finalOptions = Object.assign({}, options);
+      finalOptions.name = getContractName(
+        "ERC20Bytes",
+        options.name,
+        options.address,
+        options.network
+      );
+      processor = new ERC20BytesProcessor(finalOptions);
+      addProcessor("ERC20Bytes", options, processor);
+    }
+    return processor;
+  }
+}
+
+export function getERC20BytesContract(
+  address: string,
+  network: Networkish = 1
+): ERC20BytesContractView {
+  let contract = getContractByABI(
+    "ERC20Bytes",
+    address,
+    network
+  ) as ERC20BytesContractView;
+  if (!contract) {
+    const rawContract = ERC20Bytes__factory.connect(
+      address,
+      getProvider(network)
+    );
+    contract = new ERC20BytesContractView(rawContract);
+    addContractByABI("ERC20Bytes", address, network, contract);
+  }
+  return contract;
+}