/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

import {
  Address,
  Contract,
  ContractState,
  TestContractResult,
  HexString,
  ContractFactory,
  EventSubscribeOptions,
  EventSubscription,
  CallContractParams,
  CallContractResult,
  TestContractParams,
  ContractEvent,
  subscribeContractEvent,
  subscribeContractEvents,
  testMethod,
  callMethod,
  multicallMethods,
  fetchContractState,
  Asset,
  ContractInstance,
  getContractEventsCurrentCount,
  TestContractParamsWithoutMaps,
  TestContractResultWithoutMaps,
  SignExecuteContractMethodParams,
  SignExecuteScriptTxResult,
  signExecuteMethod,
  addStdIdToFields,
  encodeContractFields,
  Narrow,
} from "@alephium/web3";
import { default as ExampleOracleSimpleContractJson } from "../examples/ExampleOracleSimple.ral.json";
import { getContractByCodeHash, registerContract } from "./contracts";

// Custom types for the contract
export namespace ExampleOracleSimpleTypes {
  export type Fields = {
    pair: HexString;
    price0CumulativeLast: bigint;
    price1CumulativeLast: bigint;
    blockTimeStampLast: bigint;
    price0Average: bigint;
    price1Average: bigint;
  };

  export type State = ContractState<Fields>;

  export interface CallMethodTable {
    fullMul: {
      params: CallContractParams<{ x: bigint; y: bigint }>;
      result: CallContractResult<[bigint, bigint]>;
    };
    mulDiv: {
      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
      result: CallContractResult<bigint>;
    };
    fraction: {
      params: CallContractParams<{ numerator: bigint; denominator: bigint }>;
      result: CallContractResult<bigint>;
    };
    currentCumulativePrices: {
      params: CallContractParams<{ currentBlockTimeStamp: bigint }>;
      result: CallContractResult<[bigint, bigint]>;
    };
    update: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<null>;
    };
    consult: {
      params: CallContractParams<{ tokenId: HexString; amountIn: bigint }>;
      result: CallContractResult<bigint>;
    };
  }
  export type CallMethodParams<T extends keyof CallMethodTable> =
    CallMethodTable[T]["params"];
  export type CallMethodResult<T extends keyof CallMethodTable> =
    CallMethodTable[T]["result"];
  export type MultiCallParams = Partial<{
    [Name in keyof CallMethodTable]: CallMethodTable[Name]["params"];
  }>;
  export type MultiCallResults<T extends MultiCallParams> = {
    [MaybeName in keyof T]: MaybeName extends keyof CallMethodTable
      ? CallMethodTable[MaybeName]["result"]
      : undefined;
  };
  export type MulticallReturnType<Callss extends MultiCallParams[]> = {
    [index in keyof Callss]: MultiCallResults<Callss[index]>;
  };

  export interface SignExecuteMethodTable {
    fullMul: {
      params: SignExecuteContractMethodParams<{ x: bigint; y: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    mulDiv: {
      params: SignExecuteContractMethodParams<{
        a: bigint;
        b: bigint;
        denominator: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    fraction: {
      params: SignExecuteContractMethodParams<{
        numerator: bigint;
        denominator: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    currentCumulativePrices: {
      params: SignExecuteContractMethodParams<{
        currentBlockTimeStamp: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    update: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    consult: {
      params: SignExecuteContractMethodParams<{
        tokenId: HexString;
        amountIn: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
  }
  export type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> =
    SignExecuteMethodTable[T]["params"];
  export type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> =
    SignExecuteMethodTable[T]["result"];
}

class Factory extends ContractFactory<
  ExampleOracleSimpleInstance,
  ExampleOracleSimpleTypes.Fields
> {
  encodeFields(fields: ExampleOracleSimpleTypes.Fields) {
    return encodeContractFields(
      addStdIdToFields(this.contract, fields),
      this.contract.fieldsSig,
      []
    );
  }

  consts = {
    Resolution: BigInt("112"),
    Period: BigInt("86400"),
    ErrorCodes: {
      FullDivOverflow: BigInt("0"),
      DivByZero: BigInt("1"),
      FractionOverflow: BigInt("2"),
      PeriodNotElapsed: BigInt("3"),
      InvalidToken: BigInt("4"),
    },
  };

  at(address: string): ExampleOracleSimpleInstance {
    return new ExampleOracleSimpleInstance(address);
  }

  tests = {
    fullMul: async (
      params: TestContractParamsWithoutMaps<
        ExampleOracleSimpleTypes.Fields,
        { x: bigint; y: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
      return testMethod(this, "fullMul", params, getContractByCodeHash);
    },
    mulDiv: async (
      params: TestContractParamsWithoutMaps<
        ExampleOracleSimpleTypes.Fields,
        { a: bigint; b: bigint; denominator: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "mulDiv", params, getContractByCodeHash);
    },
    fraction: async (
      params: TestContractParamsWithoutMaps<
        ExampleOracleSimpleTypes.Fields,
        { numerator: bigint; denominator: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "fraction", params, getContractByCodeHash);
    },
    currentCumulativePrices: async (
      params: TestContractParamsWithoutMaps<
        ExampleOracleSimpleTypes.Fields,
        { currentBlockTimeStamp: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
      return testMethod(
        this,
        "currentCumulativePrices",
        params,
        getContractByCodeHash
      );
    },
    update: async (
      params: Omit<
        TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "update", params, getContractByCodeHash);
    },
    consult: async (
      params: TestContractParamsWithoutMaps<
        ExampleOracleSimpleTypes.Fields,
        { tokenId: HexString; amountIn: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "consult", params, getContractByCodeHash);
    },
  };

  stateForTest(
    initFields: ExampleOracleSimpleTypes.Fields,
    asset?: Asset,
    address?: string
  ) {
    return this.stateForTest_(initFields, asset, address, undefined);
  }
}

// Use this object to test and deploy the contract
export const ExampleOracleSimple = new Factory(
  Contract.fromJson(
    ExampleOracleSimpleContractJson,
    "",
    "c96ea41f2579f435d70c7801c2ec158031575b7571d8e8bbb2e460a8814cfbdf",
    []
  )
);
registerContract(ExampleOracleSimple);

// Use this class to interact with the blockchain
export class ExampleOracleSimpleInstance extends ContractInstance {
  constructor(address: Address) {
    super(address);
  }

  async fetchState(): Promise<ExampleOracleSimpleTypes.State> {
    return fetchContractState(ExampleOracleSimple, this);
  }

  view = {
    fullMul: async (
      params: ExampleOracleSimpleTypes.CallMethodParams<"fullMul">
    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"fullMul">> => {
      return callMethod(
        ExampleOracleSimple,
        this,
        "fullMul",
        params,
        getContractByCodeHash
      );
    },
    mulDiv: async (
      params: ExampleOracleSimpleTypes.CallMethodParams<"mulDiv">
    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"mulDiv">> => {
      return callMethod(
        ExampleOracleSimple,
        this,
        "mulDiv",
        params,
        getContractByCodeHash
      );
    },
    fraction: async (
      params: ExampleOracleSimpleTypes.CallMethodParams<"fraction">
    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"fraction">> => {
      return callMethod(
        ExampleOracleSimple,
        this,
        "fraction",
        params,
        getContractByCodeHash
      );
    },
    currentCumulativePrices: async (
      params: ExampleOracleSimpleTypes.CallMethodParams<"currentCumulativePrices">
    ): Promise<
      ExampleOracleSimpleTypes.CallMethodResult<"currentCumulativePrices">
    > => {
      return callMethod(
        ExampleOracleSimple,
        this,
        "currentCumulativePrices",
        params,
        getContractByCodeHash
      );
    },
    update: async (
      params?: ExampleOracleSimpleTypes.CallMethodParams<"update">
    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"update">> => {
      return callMethod(
        ExampleOracleSimple,
        this,
        "update",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    consult: async (
      params: ExampleOracleSimpleTypes.CallMethodParams<"consult">
    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"consult">> => {
      return callMethod(
        ExampleOracleSimple,
        this,
        "consult",
        params,
        getContractByCodeHash
      );
    },
  };

  transact = {
    fullMul: async (
      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"fullMul">
    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"fullMul">> => {
      return signExecuteMethod(ExampleOracleSimple, this, "fullMul", params);
    },
    mulDiv: async (
      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"mulDiv">
    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"mulDiv">> => {
      return signExecuteMethod(ExampleOracleSimple, this, "mulDiv", params);
    },
    fraction: async (
      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"fraction">
    ): Promise<
      ExampleOracleSimpleTypes.SignExecuteMethodResult<"fraction">
    > => {
      return signExecuteMethod(ExampleOracleSimple, this, "fraction", params);
    },
    currentCumulativePrices: async (
      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"currentCumulativePrices">
    ): Promise<
      ExampleOracleSimpleTypes.SignExecuteMethodResult<"currentCumulativePrices">
    > => {
      return signExecuteMethod(
        ExampleOracleSimple,
        this,
        "currentCumulativePrices",
        params
      );
    },
    update: async (
      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"update">
    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"update">> => {
      return signExecuteMethod(ExampleOracleSimple, this, "update", params);
    },
    consult: async (
      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"consult">
    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"consult">> => {
      return signExecuteMethod(ExampleOracleSimple, this, "consult", params);
    },
  };

  async multicall<Calls extends ExampleOracleSimpleTypes.MultiCallParams>(
    calls: Calls
  ): Promise<ExampleOracleSimpleTypes.MultiCallResults<Calls>>;
  async multicall<Callss extends ExampleOracleSimpleTypes.MultiCallParams[]>(
    callss: Narrow<Callss>
  ): Promise<ExampleOracleSimpleTypes.MulticallReturnType<Callss>>;
  async multicall<
    Callss extends
      | ExampleOracleSimpleTypes.MultiCallParams
      | ExampleOracleSimpleTypes.MultiCallParams[]
  >(callss: Callss): Promise<unknown> {
    return await multicallMethods(
      ExampleOracleSimple,
      this,
      callss,
      getContractByCodeHash
    );
  }
}