@defisaver/automation-sdk 1.0.1

package/src/services/subDataService.ts

@@ -0,0 +1,212 @@
+import Dec from 'decimal.js';
+import { getAssetInfo } from '@defisaver/tokens';
+import { otherAddresses } from '@defisaver/sdk';
+
+import type { EthereumAddress, SubData } from '../types';
+import { ChainId } from '../types/enums';
+
+import { ZERO_ADDRESS } from '../constants';
+
+import { compareAddresses, ratioPercentageToWei, weiToRatioPercentage } from './utils';
+
+const { mockedWeb3 } = process;
+
+export const makerRepayFromSavingsSubData = {
+  encode(
+    vaultId: number,
+    targetRatioPercentage: number,
+    chainId: ChainId,
+    daiAddr?: EthereumAddress,
+    mcdCdpManagerAddr?: EthereumAddress,
+  ): SubData {
+    const _daiAddr = daiAddr || getAssetInfo('DAI', chainId).address;
+    // @ts-ignore // TODO - this requires change in @defisaver/tokens
+    const _mcdCdpManagerAddr = mcdCdpManagerAddr || otherAddresses(chainId).McdCdpManager;
+
+    const vaultIdEncoded = mockedWeb3.eth.abi.encodeParameter('uint256', vaultId.toString());
+    const targetRatioWei = ratioPercentageToWei(targetRatioPercentage);
+    const targetRatioEncoded = mockedWeb3.eth.abi.encodeParameter('uint256', targetRatioWei);
+    const daiAddrEncoded = mockedWeb3.eth.abi.encodeParameter('address', _daiAddr);
+    const mcdManagerAddrEncoded = mockedWeb3.eth.abi.encodeParameter('address', _mcdCdpManagerAddr);
+
+    return [vaultIdEncoded, targetRatioEncoded, daiAddrEncoded, mcdManagerAddrEncoded];
+  },
+  decode(subData: SubData): { vaultId: number, daiAddr: string, mcdManagerAddr: string, targetRatio: number } {
+    const vaultId = +mockedWeb3.eth.abi.decodeParameter('uint256', subData[0]).toString();
+
+    const weiRatio = mockedWeb3.eth.abi.decodeParameter('uint256', subData[1]) as any as string;
+    const targetRatio = weiToRatioPercentage(weiRatio);
+
+    const daiAddr = mockedWeb3.eth.abi.decodeParameter('address', subData[2]).toString();
+    const mcdManagerAddr = mockedWeb3.eth.abi.decodeParameter('address', subData[3]).toString();
+
+    return {
+      vaultId, targetRatio, daiAddr, mcdManagerAddr,
+    };
+  },
+};
+
+export const makerCloseSubData = {
+  encode(
+    vaultId: number,
+    closeToAssetAddr: EthereumAddress,
+    chainId: ChainId,
+    daiAddr?: EthereumAddress,
+    mcdCdpManagerAddr?: EthereumAddress,
+  ): SubData {
+    const _daiAddr = daiAddr || getAssetInfo('DAI', chainId).address;
+    // @ts-ignore // TODO - this requires change in @defisaver/tokens
+    const _mcdCdpManagerAddr = mcdCdpManagerAddr || otherAddresses(chainId).McdCdpManager;
+
+    const vaultIdEncoded = mockedWeb3.eth.abi.encodeParameter('uint256', vaultId.toString());
+    const daiAddrEncoded = mockedWeb3.eth.abi.encodeParameter('address', _daiAddr);
+    const mcdManagerAddrEncoded = mockedWeb3.eth.abi.encodeParameter('address', _mcdCdpManagerAddr);
+
+    if (compareAddresses(closeToAssetAddr, _daiAddr)) {
+      // Close to DAI strategy
+      return [vaultIdEncoded, daiAddrEncoded, mcdManagerAddrEncoded];
+    }
+    // Close to collateral strategy
+    const collAddrEncoded = mockedWeb3.eth.abi.encodeParameter('address', closeToAssetAddr);
+    return [vaultIdEncoded, collAddrEncoded, daiAddrEncoded, mcdManagerAddrEncoded];
+  },
+  decode(subData: SubData): { vaultId: number, closeToAssetAddr: EthereumAddress } {
+    const vaultId = +mockedWeb3.eth.abi.decodeParameter('uint256', subData[0]);
+    // if closing to collateral, asset addr will be 2nd param out of 4
+    // if closing to DAI, will return 2nd param out of 3, which will be DAI addr
+    const closeToAssetAddr = mockedWeb3.eth.abi.decodeParameter('address', subData[1]).toString().toLowerCase();
+
+    return {
+      vaultId, closeToAssetAddr,
+    };
+  },
+};
+
+export const liquityCloseSubData = {
+  encode(
+    closeToAssetAddr: EthereumAddress,
+    chainId: ChainId = ChainId.Ethereum,
+    collAddr?: EthereumAddress,
+    debtAddr?: EthereumAddress,
+  ): SubData {
+    const _collAddr = collAddr || getAssetInfo('WETH', chainId).address;
+    const _debtAddr = debtAddr || getAssetInfo('LUSD', chainId).address;
+
+    const collAddrEncoded = mockedWeb3.eth.abi.encodeParameter('address', _collAddr);
+    const debtAddrEncoded = mockedWeb3.eth.abi.encodeParameter('address', _debtAddr);
+    // if (compareAddresses(closeToAssetAddr, daiAddr)) { // TODO - Uhm, wth?
+    //   // close to LUSD strategy
+    //   return [daiAddrEncoded, mcdManagerAddrEncoded];
+    // }
+    // close to collateral strategy
+    return [collAddrEncoded, debtAddrEncoded];
+  },
+  decode(subData: SubData): { closeToAssetAddr: EthereumAddress, debtAddr: string } {
+    const closeToAssetAddr = mockedWeb3.eth.abi.decodeParameter('address', subData[0]).toString().toLowerCase();
+    const debtAddr = mockedWeb3.eth.abi.decodeParameter('address', subData[1]).toString().toLowerCase();
+
+    return { closeToAssetAddr, debtAddr };
+  },
+};
+
+export const aaveLeverageManagementSubData = { // TODO encode?
+  decode(subData: SubData): { targetRatio: number } {
+    const ratioWei = mockedWeb3.eth.abi.decodeParameter('uint256', subData[0]) as any as string;
+    const targetRatio = weiToRatioPercentage(ratioWei);
+
+    return { targetRatio };
+  },
+};
+
+export const aaveV3QuotePriceSubData = {
+  encode(
+    collAsset: EthereumAddress,
+    collAssetId: number,
+    debtAsset: EthereumAddress,
+    debtAssetId: number,
+    nullAddress: EthereumAddress = ZERO_ADDRESS,
+  ): SubData {
+    const encodedColl = mockedWeb3.eth.abi.encodeParameter('address', collAsset);
+    const encodedCollId = mockedWeb3.eth.abi.encodeParameter('uint8', collAssetId);
+
+    const encodedDebt = mockedWeb3.eth.abi.encodeParameter('address', debtAsset);
+    const encodedDebtId = mockedWeb3.eth.abi.encodeParameter('uint8', debtAssetId);
+
+    const encodedNullAddress = mockedWeb3.eth.abi.encodeParameter('address', nullAddress);
+
+    return [encodedColl, encodedCollId, encodedDebt, encodedDebtId, encodedNullAddress];
+  },
+  decode(subData: SubData): { collAsset: EthereumAddress, collAssetId: number, debtAsset: EthereumAddress, debtAssetId: number } {
+    const collAsset = mockedWeb3.eth.abi.decodeParameter('address', subData[0]) as unknown as EthereumAddress;
+    const collAssetId = Number(mockedWeb3.eth.abi.decodeParameter('uint8', subData[1]));
+
+    const debtAsset = mockedWeb3.eth.abi.decodeParameter('address', subData[2]) as unknown as EthereumAddress;
+    const debtAssetId = Number(mockedWeb3.eth.abi.decodeParameter('uint8', subData[3]));
+
+    return {
+      collAsset, collAssetId, debtAsset, debtAssetId,
+    };
+  },
+};
+
+export const compoundV3LeverageManagementSubData = {
+  encode(
+    market: EthereumAddress,
+    baseToken: EthereumAddress,
+    repayFrom: number,
+    boostFrom: number,
+    boostTo: number,
+    repayTo: number,
+    boostEnabled: boolean,
+    isEOA: boolean,
+  ): SubData {
+    return [
+      market,
+      baseToken,
+      new Dec(repayFrom).mul(1e16).toString(),
+      new Dec(boostFrom).mul(1e16).toString(),
+      new Dec(boostTo).mul(1e16).toString(),
+      new Dec(repayTo).mul(1e16).toString(),
+      // @ts-ignore // TODO
+      boostEnabled, isEOA,
+    ];
+  },
+  decode(subData: SubData): { targetRatio: number } {
+    const weiRatio = mockedWeb3.eth.abi.decodeParameter('uint256', subData[3]) as any as string;
+    const targetRatio = weiToRatioPercentage(weiRatio);
+
+    return { targetRatio };
+  },
+};
+
+export const cBondsRebondSubData = {
+  encode(bondId: number | string): SubData {
+    const bondIdEncoded = mockedWeb3.eth.abi.encodeParameter('uint256', bondId);
+    return [bondIdEncoded];
+  },
+  decode(subData: SubData): { bondId: string } {
+    const bondId = mockedWeb3.eth.abi.decodeParameter('uint256', subData[1]).toString();
+    return { bondId };
+  },
+};
+
+export const liquityPaybackUsingChickenBondSubData = {
+  /**
+   * @param sourceId bondId or subId
+   * @param sourceType 0 for bond, 1 for subId
+   */
+  encode: (sourceId: string, sourceType: number): SubData => {
+    const sourceIdEncoded = mockedWeb3.eth.abi.encodeParameter('uint256', sourceId);
+    const sourceTypeEncoded = mockedWeb3.eth.abi.encodeParameter('uint256', sourceType);
+    const lusdAddressEncoded = mockedWeb3.eth.abi.encodeParameter('address', getAssetInfo('LUSD').address);
+    const bLusdAddressEncoded = mockedWeb3.eth.abi.encodeParameter('address', getAssetInfo('bLUSD').address);
+
+    return [sourceIdEncoded, sourceTypeEncoded, lusdAddressEncoded, bLusdAddressEncoded];
+  },
+  decode: (subData: SubData) => {
+    const sourceId = mockedWeb3.eth.abi.decodeParameter('uint256', subData[0]).toString();
+    const sourceType = mockedWeb3.eth.abi.decodeParameter('uint256', subData[1]).toString();
+
+    return { sourceId, sourceType };
+  },
+};

package/src/services/triggerService.ts

@@ -0,0 +1,173 @@
+import Dec from 'decimal.js';
+
+import type {
+  EthereumAddress, TriggerData,
+} from '../types';
+import type { RatioState } from '../types/enums';
+
+import { ratioPercentageToWei } from './utils';
+
+const { mockedWeb3 } = process;
+
+export const chainlinkPriceTrigger = {
+  encode(tokenAddr: EthereumAddress, price: string, state: RatioState) {
+    const _price = new Dec(price).mul(1e8).floor().toString();
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'uint256', 'uint8'], [tokenAddr, _price, state])];
+  },
+  decode(triggerData: TriggerData): { price: string, state: RatioState, tokenAddr: EthereumAddress } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'uint256', 'uint8'], triggerData[0]);
+    return { tokenAddr: decodedData[0], price: new Dec(decodedData[1]).div(1e8).toString(), state: +decodedData[2] };
+  },
+};
+
+export const trailingStopTrigger = {
+  encode(tokenAddr: EthereumAddress, percentage: number, roundId: number) {
+    const _percentage = new Dec(percentage).mul(1e8).toString();
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'uint256', 'uint80'], [tokenAddr, _percentage, roundId])];
+  },
+  decode(triggerData: TriggerData):{ triggerPercentage: number, tokenAddr: EthereumAddress, roundId: string } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'uint256', 'uint80'], triggerData[0]);
+    const triggerPercentage = new Dec(decodedData[1]).div(1e8).toNumber();
+    return { tokenAddr: decodedData[0], triggerPercentage, roundId: decodedData[2] };
+  },
+};
+
+export const makerRatioTrigger = {
+  encode(vaultId: number, ratioPercentage: number, ratioState: RatioState) {
+    const ratioWei = ratioPercentageToWei(ratioPercentage);
+    return [mockedWeb3.eth.abi.encodeParameters(['uint256', 'uint256', 'uint8'], [vaultId, ratioWei, ratioState])];
+  },
+  decode(triggerData: TriggerData): { vaultId: number, ratioState: number, ratio: number } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['uint256', 'uint256', 'uint8'], triggerData[0]);
+    return { vaultId: +decodedData[0], ratio: new Dec(mockedWeb3.utils.fromWei(decodedData[1])).mul(100).toNumber(), ratioState: +decodedData[2] };
+  },
+};
+
+export const aaveV3RatioTrigger = {
+  decode(triggerData: TriggerData) {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'address', 'uint256', 'uint8'], triggerData[0]) as string[];
+    return {
+      market: decodedData[1],
+      ratio: new Dec(mockedWeb3.utils.fromWei(decodedData[2])).mul(100).toNumber(),
+      ratioState: Number(decodedData[3]),
+    };
+  },
+};
+
+export const aaveV3QuotePriceTrigger = {
+  encode(
+    baseTokenAddress: EthereumAddress,
+    quoteTokenAddress: EthereumAddress,
+    price: number,
+    ratioState: RatioState,
+  ) {
+    // Price is always in 8 decimals
+    const _price = new Dec(price.toString()).mul(10 ** 8).floor().toString();
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'address', 'uint256', 'uint8'], [baseTokenAddress, quoteTokenAddress, _price, ratioState])];
+  },
+  decode(
+    triggerData: TriggerData,
+  ): { baseTokenAddress: EthereumAddress, quoteTokenAddress: EthereumAddress, price: string, ratioState: RatioState } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'address', 'uint256', 'uint8'], triggerData[0]) as Array<string>;
+    // Price is always in 8 decimals
+    const price = new Dec(decodedData[2]).div(10 ** 8).toDP(8).toString();
+    return {
+      price,
+      baseTokenAddress: decodedData[0],
+      quoteTokenAddress: decodedData[1],
+      ratioState: +decodedData[3],
+    };
+  },
+};
+
+export const compoundV2RatioTrigger = {
+  encode(owner: EthereumAddress, ratioPercentage: number, ratioState: RatioState) {
+    const ratioWei = ratioPercentageToWei(ratioPercentage);
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'uint256', 'uint8'], [owner, ratioWei, ratioState])];
+  },
+  decode(triggerData: TriggerData): { owner: EthereumAddress, ratioState: RatioState, ratio: string } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'uint256', 'uint8'], triggerData[0]);
+    return {
+      owner: decodedData[0],
+      ratio: new Dec(mockedWeb3.utils.fromWei(decodedData[1])).mul(100).toString(),
+      ratioState: +decodedData[2],
+    };
+  },
+};
+
+export const liquityRatioTrigger = {
+  encode(owner: EthereumAddress, ratioPercentage: number, ratioState: RatioState) {
+    const ratioWei = ratioPercentageToWei(ratioPercentage);
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'uint256', 'uint8'], [owner, ratioWei, ratioState])];
+  },
+  decode(triggerData: TriggerData): { owner: EthereumAddress, ratioState: RatioState, ratio: string } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'uint256', 'uint8'], triggerData[0]);
+    return {
+      owner: decodedData[0],
+      ratio: new Dec(mockedWeb3.utils.fromWei(decodedData[1])).mul(100).toString(),
+      ratioState: +decodedData[2],
+    };
+  },
+};
+
+export const liquityDebtInFrontTrigger = {
+  encode(owner: EthereumAddress, debtInFrontMin: string) {
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'uint256'], [owner, debtInFrontMin])];
+  },
+  decode(triggerData: TriggerData): { owner: EthereumAddress, debtInFrontMin: string } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'uint256'], triggerData[0]);
+    return {
+      owner: decodedData[0],
+      debtInFrontMin: decodedData[1],
+    };
+  },
+};
+
+export const aaveV2RatioTrigger = {
+  encode(owner: EthereumAddress, market: EthereumAddress, ratioPercentage: number, ratioState: RatioState) {
+    const ratioWei = ratioPercentageToWei(ratioPercentage);
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'address', 'uint256', 'uint8'], [owner, market, ratioWei, ratioState])];
+  },
+  decode(triggerData: TriggerData): { owner: EthereumAddress, market:EthereumAddress, ratioState: RatioState, ratio: string } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'address', 'uint256', 'uint8'], triggerData[0]);
+    return {
+      owner: decodedData[0],
+      market: decodedData[1],
+      ratio: new Dec(mockedWeb3.utils.fromWei(decodedData[2])).mul(100).toString(),
+      ratioState: +decodedData[3],
+    };
+  },
+};
+
+export const cBondsRebondTrigger = {
+  encode(bondId: number | string) {
+    return [mockedWeb3.eth.abi.encodeParameters(['uint256'], [bondId])];
+  },
+  decode(triggerData: TriggerData): { bondId: string } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['uint256'], triggerData[0]);
+    return { bondId: decodedData[0] };
+  },
+};
+
+export const compoundV3RatioTrigger = {
+  encode(
+    owner: EthereumAddress,
+    market: EthereumAddress,
+    ratioPercentage: number,
+    ratioState: RatioState,
+  ) {
+    const ratioWei = ratioPercentageToWei(ratioPercentage);
+    return [mockedWeb3.eth.abi.encodeParameters(['address', 'address', 'uint256', 'uint8'], [owner, market, ratioWei, ratioState])];
+  },
+  decode(
+    triggerData: TriggerData,
+  ): { owner: EthereumAddress, market: EthereumAddress, ratioState: RatioState, ratio: number } {
+    const decodedData = mockedWeb3.eth.abi.decodeParameters(['address', 'address', 'uint256', 'uint8'], triggerData[0]);
+    return {
+      owner: decodedData[0],
+      market: decodedData[1],
+      ratio: new Dec(mockedWeb3.utils.fromWei(decodedData[2])).mul(100).toNumber(),
+      ratioState: +decodedData[3],
+    };
+  },
+};

package/src/services/utils.ts

@@ -0,0 +1,101 @@
+import { getAssetInfo, getAssetInfoByAddress } from '@defisaver/tokens';
+import Dec from 'decimal.js';
+
+import type { EthereumAddress } from '../types';
+
+import { ChainId, RatioState } from '../types/enums';
+
+const { mockedWeb3 } = process;
+
+export function isDefined<T>(value: T): value is NonNullable<T> {
+  return value !== undefined && value !== null;
+}
+
+export function isUndefined(value: unknown): boolean {
+  return !isDefined(value);
+}
+
+export function compareAddresses(firstAddress: EthereumAddress, secondAddress: EthereumAddress): boolean {
+  return firstAddress.toLowerCase() === secondAddress.toLowerCase();
+}
+
+export function isAddress(address: EthereumAddress) {
+  return new RegExp(/0x[0-9a-fA-F]{40}/).test(address);
+}
+
+export function addToArrayIf(condition: boolean, ...items: any): Array<any> {
+  return (condition ? items : []);
+}
+
+export function addToObjectIf(condition: boolean, item: any): object {
+  return (condition ? item : {});
+}
+
+export function ethToWeth(maybeEth: string) {
+  return maybeEth?.replace(/^ETH$/, 'WETH');
+}
+
+export function wethToEth(maybeWeth: string) {
+  return maybeWeth?.replace(/^WETH$/, 'ETH');
+}
+
+export function wethToEthByAddress(maybeWethAddr: EthereumAddress, chainId: ChainId = ChainId.Ethereum): EthereumAddress {
+  return getAssetInfo(wethToEth(getAssetInfoByAddress(maybeWethAddr, chainId).symbol), chainId).address;
+}
+
+export function compareSubHashes(currentSubHash: string, newSubStructDecoded: object): boolean {
+  return currentSubHash === mockedWeb3.utils.keccak256(mockedWeb3.eth.abi.encodeParameter('(uint64,bool,bytes[],bytes32[])', newSubStructDecoded));
+}
+
+export function encodeSubId(subIdDec: string = '0') {
+  return new Dec(subIdDec).toHex().slice(2).padStart(8, '0');
+}
+
+export function ratioPercentageToWei(ratioPercentage: number) {
+  return mockedWeb3.utils.toWei(new Dec(ratioPercentage).div(100).toString());
+}
+
+export function weiToRatioPercentage(ratioWei: string) {
+  return new Dec(mockedWeb3.utils.fromWei(new Dec(ratioWei).mul(100).toString())).toNumber();
+}
+
+export function isRatioStateOver(ratioState: RatioState): boolean {
+  return ratioState === RatioState.OVER;
+}
+
+export function isRatioStateUnder(ratioState: RatioState): boolean {
+  return ratioState === RatioState.UNDER;
+}
+
+export function isEmptyBytes(string: string) {
+  return string === '0x0000000000000000000000000000000000000000';
+}
+
+export function requireAddress(address: EthereumAddress): void | never {
+  if (typeof address !== 'string') throw new Error('Address is not a string');
+  if (address === '') throw new Error('Address is empty string');
+  if (address.length < 42) throw new Error(`Address too short (${address.length} instead of 42)`);
+  if (isEmptyBytes(address)) throw new Error('Address is empty bytes');
+  if (!(new RegExp(/0x[0-9a-fA-F]{40}/).test(address))) throw new Error('Address invalid');
+}
+
+export function requireAddresses(addresses: EthereumAddress[]) {
+  addresses.forEach((address) => requireAddress(address));
+}
+
+export function getRatioStateInfoForAaveCloseStrategy(
+  currentRatioState: RatioState,
+  collAsset: EthereumAddress,
+  debtAsset: EthereumAddress,
+  chainId: ChainId,
+): { shouldFlip: boolean, ratioState: RatioState } {
+  // Flip only if stable/volatile to keep human-readable trigger price setting
+  const shouldFlip = getAssetInfoByAddress(collAsset, chainId).isStable && !getAssetInfoByAddress(debtAsset, chainId).isStable;
+  let ratioState = currentRatioState;
+  if (shouldFlip) {
+    ratioState = isRatioStateOver(currentRatioState)
+      ? ratioState = RatioState.UNDER
+      : ratioState = RatioState.OVER;
+  }
+  return { shouldFlip, ratioState };
+}

package/src/types/contracts/generated/Erc20.ts

@@ -0,0 +1,95 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import type BN from "bn.js";
+import type { ContractOptions } from "web3-eth-contract";
+import type { EventLog } from "web3-core";
+import type { EventEmitter } from "events";
+import type {
+  Callback,
+  PayableTransactionObject,
+  NonPayableTransactionObject,
+  BlockType,
+  ContractEventLog,
+  BaseContract,
+} from "./types";
+
+export interface EventOptions {
+  filter?: object;
+  fromBlock?: BlockType;
+  topics?: string[];
+}
+
+export type Approval = ContractEventLog<{
+  owner: string;
+  spender: string;
+  value: string;
+  0: string;
+  1: string;
+  2: string;
+}>;
+export type Transfer = ContractEventLog<{
+  from: string;
+  to: string;
+  value: string;
+  0: string;
+  1: string;
+  2: string;
+}>;
+
+export interface Erc20 extends BaseContract {
+  constructor(
+    jsonInterface: any[],
+    address?: string,
+    options?: ContractOptions
+  ): Erc20;
+  clone(): Erc20;
+  methods: {
+    name(): NonPayableTransactionObject<string>;
+
+    approve(
+      _spender: string,
+      _value: number | string | BN
+    ): NonPayableTransactionObject<boolean>;
+
+    totalSupply(): NonPayableTransactionObject<string>;
+
+    transferFrom(
+      _from: string,
+      _to: string,
+      _value: number | string | BN
+    ): NonPayableTransactionObject<boolean>;
+
+    decimals(): NonPayableTransactionObject<string>;
+
+    balanceOf(_owner: string): NonPayableTransactionObject<string>;
+
+    symbol(): NonPayableTransactionObject<string>;
+
+    transfer(
+      _to: string,
+      _value: number | string | BN
+    ): NonPayableTransactionObject<boolean>;
+
+    allowance(
+      _owner: string,
+      _spender: string
+    ): NonPayableTransactionObject<string>;
+  };
+  events: {
+    Approval(cb?: Callback<Approval>): EventEmitter;
+    Approval(options?: EventOptions, cb?: Callback<Approval>): EventEmitter;
+
+    Transfer(cb?: Callback<Transfer>): EventEmitter;
+    Transfer(options?: EventOptions, cb?: Callback<Transfer>): EventEmitter;
+
+    allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+  };
+
+  once(event: "Approval", cb: Callback<Approval>): void;
+  once(event: "Approval", options: EventOptions, cb: Callback<Approval>): void;
+
+  once(event: "Transfer", cb: Callback<Transfer>): void;
+  once(event: "Transfer", options: EventOptions, cb: Callback<Transfer>): void;
+}