/* 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 PoolFactoryContractJson } from "../PoolFactory.ral.json";
import { getContractByCodeHash, registerContract } from "./contracts";
import * as types from "./types";

// Custom types for the contract
export namespace PoolFactoryTypes {
  export type Fields = {
    owner: Address;
    poolTemplate: HexString;
    positionTemplate: HexString;
    tickTemplate: HexString;
    wordTemplate: HexString;
    poolConfigTemplate: HexString;
    dexAccountTemplate: HexString;
    nextConfigIndex: bigint;
  };

  export type State = ContractState<Fields>;

  export type ConfigCreatedEvent = ContractEvent<{ index: bigint }>;
  export type PoolCreatedEvent = ContractEvent<{
    id: HexString;
    token0: HexString;
    token1: HexString;
    configIndex: bigint;
  }>;
  export type FeeTierEnabledEvent = ContractEvent<{
    fee: bigint;
    tickSpacing: bigint;
    index: bigint;
  }>;

  export interface CallMethodTable {
    configPath: {
      params: CallContractParams<{ configIndex_: bigint }>;
      result: CallContractResult<HexString>;
    };
    poolPath: {
      params: CallContractParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: CallContractResult<HexString>;
    };
    poolContractId: {
      params: CallContractParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: CallContractResult<HexString>;
    };
    tickSpacingToMaxLiquidityPerTick: {
      params: CallContractParams<{ tickSpacing: bigint }>;
      result: CallContractResult<bigint>;
    };
    createConfig: {
      params: CallContractParams<{ config: types.Config }>;
      result: CallContractResult<bigint>;
    };
    create: {
      params: CallContractParams<{
        token0: HexString;
        token1: HexString;
        configIndex: bigint;
        sqrtPriceX96: bigint;
        rewardToken: HexString;
      }>;
      result: CallContractResult<HexString>;
    };
    collectProtocolFees: {
      params: CallContractParams<{
        recipient: Address;
        configIndex: bigint;
        token0: HexString;
        token1: HexString;
      }>;
      result: CallContractResult<null>;
    };
    setRewardParams: {
      params: CallContractParams<{
        configIndex: bigint;
        token0: HexString;
        token1: HexString;
        payer: Address;
        tokenId: HexString;
        index: bigint;
        openTime: bigint;
        endTime: bigint;
        amount: bigint;
      }>;
      result: CallContractResult<null>;
    };
    upgrate: {
      params: CallContractParams<{
        newBytecode: HexString;
        newEncodedImmFields: HexString;
        newEncodedMutFields: HexString;
      }>;
      result: CallContractResult<null>;
    };
  }
  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 {
    configPath: {
      params: SignExecuteContractMethodParams<{ configIndex_: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    poolPath: {
      params: SignExecuteContractMethodParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    poolContractId: {
      params: SignExecuteContractMethodParams<{
        factory: HexString;
        tokens: HexString;
        configIndex_: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    tickSpacingToMaxLiquidityPerTick: {
      params: SignExecuteContractMethodParams<{ tickSpacing: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    createConfig: {
      params: SignExecuteContractMethodParams<{ config: types.Config }>;
      result: SignExecuteScriptTxResult;
    };
    create: {
      params: SignExecuteContractMethodParams<{
        token0: HexString;
        token1: HexString;
        configIndex: bigint;
        sqrtPriceX96: bigint;
        rewardToken: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    collectProtocolFees: {
      params: SignExecuteContractMethodParams<{
        recipient: Address;
        configIndex: bigint;
        token0: HexString;
        token1: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    setRewardParams: {
      params: SignExecuteContractMethodParams<{
        configIndex: bigint;
        token0: HexString;
        token1: HexString;
        payer: Address;
        tokenId: HexString;
        index: bigint;
        openTime: bigint;
        endTime: bigint;
        amount: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    upgrate: {
      params: SignExecuteContractMethodParams<{
        newBytecode: HexString;
        newEncodedImmFields: HexString;
        newEncodedMutFields: HexString;
      }>;
      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<
  PoolFactoryInstance,
  PoolFactoryTypes.Fields
> {
  encodeFields(fields: PoolFactoryTypes.Fields) {
    return encodeContractFields(
      addStdIdToFields(this.contract, fields),
      this.contract.fieldsSig,
      types.AllStructs
    );
  }

  eventIndex = { ConfigCreated: 0, PoolCreated: 1, FeeTierEnabled: 2 };
  consts = {
    FactoryError: {
      InvalidTokenOrder: BigInt("701"),
      UnauthorizedRewardSender: BigInt("702"),
      UnauthorizedFeeCollector: BigInt("703"),
    },
  };

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

  tests = {
    configPath: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        { configIndex_: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "configPath", params, getContractByCodeHash);
    },
    poolPath: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        { factory: HexString; tokens: HexString; configIndex_: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "poolPath", params, getContractByCodeHash);
    },
    poolContractId: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        { factory: HexString; tokens: HexString; configIndex_: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "poolContractId", params, getContractByCodeHash);
    },
    tickSpacingToMaxLiquidityPerTick: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        { tickSpacing: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "tickSpacingToMaxLiquidityPerTick",
        params,
        getContractByCodeHash
      );
    },
    createConfig: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        { config: types.Config }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "createConfig", params, getContractByCodeHash);
    },
    create: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        {
          token0: HexString;
          token1: HexString;
          configIndex: bigint;
          sqrtPriceX96: bigint;
          rewardToken: HexString;
        }
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "create", params, getContractByCodeHash);
    },
    collectProtocolFees: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        {
          recipient: Address;
          configIndex: bigint;
          token0: HexString;
          token1: HexString;
        }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "collectProtocolFees",
        params,
        getContractByCodeHash
      );
    },
    setRewardParams: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        {
          configIndex: bigint;
          token0: HexString;
          token1: HexString;
          payer: Address;
          tokenId: HexString;
          index: bigint;
          openTime: bigint;
          endTime: bigint;
          amount: bigint;
        }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "setRewardParams", params, getContractByCodeHash);
    },
    upgrate: async (
      params: TestContractParamsWithoutMaps<
        PoolFactoryTypes.Fields,
        {
          newBytecode: HexString;
          newEncodedImmFields: HexString;
          newEncodedMutFields: HexString;
        }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "upgrate", params, getContractByCodeHash);
    },
  };

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

// Use this object to test and deploy the contract
export const PoolFactory = new Factory(
  Contract.fromJson(
    PoolFactoryContractJson,
    "",
    "4f2990418f84360134e2fe3c2732c0ad191b52d772a8406ae9afe6e87c427bf3",
    types.AllStructs
  )
);
registerContract(PoolFactory);

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

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

  async getContractEventsCurrentCount(): Promise<number> {
    return getContractEventsCurrentCount(this.address);
  }

  subscribeConfigCreatedEvent(
    options: EventSubscribeOptions<PoolFactoryTypes.ConfigCreatedEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      PoolFactory.contract,
      this,
      options,
      "ConfigCreated",
      fromCount
    );
  }

  subscribePoolCreatedEvent(
    options: EventSubscribeOptions<PoolFactoryTypes.PoolCreatedEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      PoolFactory.contract,
      this,
      options,
      "PoolCreated",
      fromCount
    );
  }

  subscribeFeeTierEnabledEvent(
    options: EventSubscribeOptions<PoolFactoryTypes.FeeTierEnabledEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      PoolFactory.contract,
      this,
      options,
      "FeeTierEnabled",
      fromCount
    );
  }

  subscribeAllEvents(
    options: EventSubscribeOptions<
      | PoolFactoryTypes.ConfigCreatedEvent
      | PoolFactoryTypes.PoolCreatedEvent
      | PoolFactoryTypes.FeeTierEnabledEvent
    >,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvents(
      PoolFactory.contract,
      this,
      options,
      fromCount
    );
  }

  view = {
    configPath: async (
      params: PoolFactoryTypes.CallMethodParams<"configPath">
    ): Promise<PoolFactoryTypes.CallMethodResult<"configPath">> => {
      return callMethod(
        PoolFactory,
        this,
        "configPath",
        params,
        getContractByCodeHash
      );
    },
    poolPath: async (
      params: PoolFactoryTypes.CallMethodParams<"poolPath">
    ): Promise<PoolFactoryTypes.CallMethodResult<"poolPath">> => {
      return callMethod(
        PoolFactory,
        this,
        "poolPath",
        params,
        getContractByCodeHash
      );
    },
    poolContractId: async (
      params: PoolFactoryTypes.CallMethodParams<"poolContractId">
    ): Promise<PoolFactoryTypes.CallMethodResult<"poolContractId">> => {
      return callMethod(
        PoolFactory,
        this,
        "poolContractId",
        params,
        getContractByCodeHash
      );
    },
    tickSpacingToMaxLiquidityPerTick: async (
      params: PoolFactoryTypes.CallMethodParams<"tickSpacingToMaxLiquidityPerTick">
    ): Promise<
      PoolFactoryTypes.CallMethodResult<"tickSpacingToMaxLiquidityPerTick">
    > => {
      return callMethod(
        PoolFactory,
        this,
        "tickSpacingToMaxLiquidityPerTick",
        params,
        getContractByCodeHash
      );
    },
    createConfig: async (
      params: PoolFactoryTypes.CallMethodParams<"createConfig">
    ): Promise<PoolFactoryTypes.CallMethodResult<"createConfig">> => {
      return callMethod(
        PoolFactory,
        this,
        "createConfig",
        params,
        getContractByCodeHash
      );
    },
    create: async (
      params: PoolFactoryTypes.CallMethodParams<"create">
    ): Promise<PoolFactoryTypes.CallMethodResult<"create">> => {
      return callMethod(
        PoolFactory,
        this,
        "create",
        params,
        getContractByCodeHash
      );
    },
    collectProtocolFees: async (
      params: PoolFactoryTypes.CallMethodParams<"collectProtocolFees">
    ): Promise<PoolFactoryTypes.CallMethodResult<"collectProtocolFees">> => {
      return callMethod(
        PoolFactory,
        this,
        "collectProtocolFees",
        params,
        getContractByCodeHash
      );
    },
    setRewardParams: async (
      params: PoolFactoryTypes.CallMethodParams<"setRewardParams">
    ): Promise<PoolFactoryTypes.CallMethodResult<"setRewardParams">> => {
      return callMethod(
        PoolFactory,
        this,
        "setRewardParams",
        params,
        getContractByCodeHash
      );
    },
    upgrate: async (
      params: PoolFactoryTypes.CallMethodParams<"upgrate">
    ): Promise<PoolFactoryTypes.CallMethodResult<"upgrate">> => {
      return callMethod(
        PoolFactory,
        this,
        "upgrate",
        params,
        getContractByCodeHash
      );
    },
  };

  transact = {
    configPath: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"configPath">
    ): Promise<PoolFactoryTypes.SignExecuteMethodResult<"configPath">> => {
      return signExecuteMethod(PoolFactory, this, "configPath", params);
    },
    poolPath: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"poolPath">
    ): Promise<PoolFactoryTypes.SignExecuteMethodResult<"poolPath">> => {
      return signExecuteMethod(PoolFactory, this, "poolPath", params);
    },
    poolContractId: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"poolContractId">
    ): Promise<PoolFactoryTypes.SignExecuteMethodResult<"poolContractId">> => {
      return signExecuteMethod(PoolFactory, this, "poolContractId", params);
    },
    tickSpacingToMaxLiquidityPerTick: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"tickSpacingToMaxLiquidityPerTick">
    ): Promise<
      PoolFactoryTypes.SignExecuteMethodResult<"tickSpacingToMaxLiquidityPerTick">
    > => {
      return signExecuteMethod(
        PoolFactory,
        this,
        "tickSpacingToMaxLiquidityPerTick",
        params
      );
    },
    createConfig: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"createConfig">
    ): Promise<PoolFactoryTypes.SignExecuteMethodResult<"createConfig">> => {
      return signExecuteMethod(PoolFactory, this, "createConfig", params);
    },
    create: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"create">
    ): Promise<PoolFactoryTypes.SignExecuteMethodResult<"create">> => {
      return signExecuteMethod(PoolFactory, this, "create", params);
    },
    collectProtocolFees: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"collectProtocolFees">
    ): Promise<
      PoolFactoryTypes.SignExecuteMethodResult<"collectProtocolFees">
    > => {
      return signExecuteMethod(
        PoolFactory,
        this,
        "collectProtocolFees",
        params
      );
    },
    setRewardParams: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"setRewardParams">
    ): Promise<PoolFactoryTypes.SignExecuteMethodResult<"setRewardParams">> => {
      return signExecuteMethod(PoolFactory, this, "setRewardParams", params);
    },
    upgrate: async (
      params: PoolFactoryTypes.SignExecuteMethodParams<"upgrate">
    ): Promise<PoolFactoryTypes.SignExecuteMethodResult<"upgrate">> => {
      return signExecuteMethod(PoolFactory, this, "upgrate", params);
    },
  };

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