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

// Custom types for the contract
export namespace TickTypes {
  export type Fields = {
    parent: Address;
    tick: bigint;
    liquidityGross: bigint;
    liquidityNet: bigint;
    feeGrowthsOutside: [bigint, bigint, bigint];
  };

  export type State = ContractState<Fields>;

  export interface CallMethodTable {
    update: {
      params: CallContractParams<{
        maxLiquidity: bigint;
        liquidityDelta: bigint;
        upper: boolean;
      }>;
      result: CallContractResult<boolean>;
    };
    feeGrowthBelow: {
      params: CallContractParams<{
        tickCurrent: bigint;
        globalGrowths: [bigint, bigint, bigint];
      }>;
      result: CallContractResult<[bigint, bigint, bigint]>;
    };
    feeGrowthAbove: {
      params: CallContractParams<{
        tickCurrent: bigint;
        globalGrowths: [bigint, bigint, bigint];
      }>;
      result: CallContractResult<[bigint, bigint, bigint]>;
    };
    clear: {
      params: CallContractParams<{ payer: Address }>;
      result: CallContractResult<null>;
    };
    cross: {
      params: CallContractParams<{
        globalGrowths: [bigint, bigint, bigint];
        zeroForOne: boolean;
        feeGrowthGlobalX128: bigint;
      }>;
      result: CallContractResult<bigint>;
    };
    getLiquidityNet: {
      params: Omit<CallContractParams<{}>, "args">;
      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 {
    update: {
      params: SignExecuteContractMethodParams<{
        maxLiquidity: bigint;
        liquidityDelta: bigint;
        upper: boolean;
      }>;
      result: SignExecuteScriptTxResult;
    };
    feeGrowthBelow: {
      params: SignExecuteContractMethodParams<{
        tickCurrent: bigint;
        globalGrowths: [bigint, bigint, bigint];
      }>;
      result: SignExecuteScriptTxResult;
    };
    feeGrowthAbove: {
      params: SignExecuteContractMethodParams<{
        tickCurrent: bigint;
        globalGrowths: [bigint, bigint, bigint];
      }>;
      result: SignExecuteScriptTxResult;
    };
    clear: {
      params: SignExecuteContractMethodParams<{ payer: Address }>;
      result: SignExecuteScriptTxResult;
    };
    cross: {
      params: SignExecuteContractMethodParams<{
        globalGrowths: [bigint, bigint, bigint];
        zeroForOne: boolean;
        feeGrowthGlobalX128: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    getLiquidityNet: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      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<TickInstance, TickTypes.Fields> {
  encodeFields(fields: TickTypes.Fields) {
    return encodeContractFields(
      addStdIdToFields(this.contract, fields),
      this.contract.fieldsSig,
      types.AllStructs
    );
  }

  consts = {
    TickError: {
      NotParent: BigInt("801"),
      LO: BigInt("802"),
      LS: BigInt("803"),
    },
  };

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

  tests = {
    update: async (
      params: TestContractParamsWithoutMaps<
        TickTypes.Fields,
        { maxLiquidity: bigint; liquidityDelta: bigint; upper: boolean }
      >
    ): Promise<TestContractResultWithoutMaps<boolean>> => {
      return testMethod(this, "update", params, getContractByCodeHash);
    },
    feeGrowthBelow: async (
      params: TestContractParamsWithoutMaps<
        TickTypes.Fields,
        { tickCurrent: bigint; globalGrowths: [bigint, bigint, bigint] }
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
      return testMethod(this, "feeGrowthBelow", params, getContractByCodeHash);
    },
    feeGrowthAbove: async (
      params: TestContractParamsWithoutMaps<
        TickTypes.Fields,
        { tickCurrent: bigint; globalGrowths: [bigint, bigint, bigint] }
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
      return testMethod(this, "feeGrowthAbove", params, getContractByCodeHash);
    },
    clear: async (
      params: TestContractParamsWithoutMaps<
        TickTypes.Fields,
        { payer: Address }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "clear", params, getContractByCodeHash);
    },
    cross: async (
      params: TestContractParamsWithoutMaps<
        TickTypes.Fields,
        {
          globalGrowths: [bigint, bigint, bigint];
          zeroForOne: boolean;
          feeGrowthGlobalX128: bigint;
        }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "cross", params, getContractByCodeHash);
    },
    getLiquidityNet: async (
      params: Omit<
        TestContractParamsWithoutMaps<TickTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "getLiquidityNet", params, getContractByCodeHash);
    },
  };

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

// Use this object to test and deploy the contract
export const Tick = new Factory(
  Contract.fromJson(
    TickContractJson,
    "",
    "1373551ca890d886980b8d33277d7ed7a2c9f7665d77a1e893a1f2554d10d4b1",
    types.AllStructs
  )
);
registerContract(Tick);

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

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

  view = {
    update: async (
      params: TickTypes.CallMethodParams<"update">
    ): Promise<TickTypes.CallMethodResult<"update">> => {
      return callMethod(Tick, this, "update", params, getContractByCodeHash);
    },
    feeGrowthBelow: async (
      params: TickTypes.CallMethodParams<"feeGrowthBelow">
    ): Promise<TickTypes.CallMethodResult<"feeGrowthBelow">> => {
      return callMethod(
        Tick,
        this,
        "feeGrowthBelow",
        params,
        getContractByCodeHash
      );
    },
    feeGrowthAbove: async (
      params: TickTypes.CallMethodParams<"feeGrowthAbove">
    ): Promise<TickTypes.CallMethodResult<"feeGrowthAbove">> => {
      return callMethod(
        Tick,
        this,
        "feeGrowthAbove",
        params,
        getContractByCodeHash
      );
    },
    clear: async (
      params: TickTypes.CallMethodParams<"clear">
    ): Promise<TickTypes.CallMethodResult<"clear">> => {
      return callMethod(Tick, this, "clear", params, getContractByCodeHash);
    },
    cross: async (
      params: TickTypes.CallMethodParams<"cross">
    ): Promise<TickTypes.CallMethodResult<"cross">> => {
      return callMethod(Tick, this, "cross", params, getContractByCodeHash);
    },
    getLiquidityNet: async (
      params?: TickTypes.CallMethodParams<"getLiquidityNet">
    ): Promise<TickTypes.CallMethodResult<"getLiquidityNet">> => {
      return callMethod(
        Tick,
        this,
        "getLiquidityNet",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
  };

  transact = {
    update: async (
      params: TickTypes.SignExecuteMethodParams<"update">
    ): Promise<TickTypes.SignExecuteMethodResult<"update">> => {
      return signExecuteMethod(Tick, this, "update", params);
    },
    feeGrowthBelow: async (
      params: TickTypes.SignExecuteMethodParams<"feeGrowthBelow">
    ): Promise<TickTypes.SignExecuteMethodResult<"feeGrowthBelow">> => {
      return signExecuteMethod(Tick, this, "feeGrowthBelow", params);
    },
    feeGrowthAbove: async (
      params: TickTypes.SignExecuteMethodParams<"feeGrowthAbove">
    ): Promise<TickTypes.SignExecuteMethodResult<"feeGrowthAbove">> => {
      return signExecuteMethod(Tick, this, "feeGrowthAbove", params);
    },
    clear: async (
      params: TickTypes.SignExecuteMethodParams<"clear">
    ): Promise<TickTypes.SignExecuteMethodResult<"clear">> => {
      return signExecuteMethod(Tick, this, "clear", params);
    },
    cross: async (
      params: TickTypes.SignExecuteMethodParams<"cross">
    ): Promise<TickTypes.SignExecuteMethodResult<"cross">> => {
      return signExecuteMethod(Tick, this, "cross", params);
    },
    getLiquidityNet: async (
      params: TickTypes.SignExecuteMethodParams<"getLiquidityNet">
    ): Promise<TickTypes.SignExecuteMethodResult<"getLiquidityNet">> => {
      return signExecuteMethod(Tick, this, "getLiquidityNet", params);
    },
  };

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