/* 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 RouterContractJson } from "../dex/Router.ral.json";
import { getContractByCodeHash, registerContract } from "./contracts";

// Custom types for the contract
export namespace RouterTypes {
  export type State = Omit<ContractState<any>, "fields">;

  export interface CallMethodTable {
    addLiquidity_: {
      params: CallContractParams<{
        reserve0: bigint;
        reserve1: bigint;
        amount0Desired: bigint;
        amount1Desired: bigint;
        amount0Min: bigint;
        amount1Min: bigint;
      }>;
      result: CallContractResult<[bigint, bigint]>;
    };
    addLiquidity: {
      params: CallContractParams<{
        tokenPair: HexString;
        sender: Address;
        amount0Desired: bigint;
        amount1Desired: bigint;
        amount0Min: bigint;
        amount1Min: bigint;
        deadline: bigint;
      }>;
      result: CallContractResult<[bigint, bigint, bigint]>;
    };
    removeLiquidity: {
      params: CallContractParams<{
        tokenPairId: HexString;
        sender: Address;
        liquidity: bigint;
        amount0Min: bigint;
        amount1Min: bigint;
        deadline: bigint;
      }>;
      result: CallContractResult<[bigint, bigint]>;
    };
    getReserveInAndReserveOut: {
      params: CallContractParams<{
        tokenPair: HexString;
        tokenInId: HexString;
      }>;
      result: CallContractResult<[bigint, bigint]>;
    };
    swapExactTokenForToken: {
      params: CallContractParams<{
        tokenPair: HexString;
        sender: Address;
        tokenInId: HexString;
        amountIn: bigint;
        amountOutMin: bigint;
        to: Address;
        deadline: bigint;
      }>;
      result: CallContractResult<null>;
    };
    swapTokenForExactToken: {
      params: CallContractParams<{
        tokenPair: HexString;
        sender: Address;
        tokenInId: HexString;
        amountInMax: bigint;
        amountOut: bigint;
        to: Address;
        deadline: bigint;
      }>;
      result: CallContractResult<null>;
    };
    swap: {
      params: CallContractParams<{
        tokenPair: HexString;
        sender: Address;
        to: Address;
        tokenInId: HexString;
        amountIn: bigint;
        amountOut: bigint;
      }>;
      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 {
    addLiquidity_: {
      params: SignExecuteContractMethodParams<{
        reserve0: bigint;
        reserve1: bigint;
        amount0Desired: bigint;
        amount1Desired: bigint;
        amount0Min: bigint;
        amount1Min: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    addLiquidity: {
      params: SignExecuteContractMethodParams<{
        tokenPair: HexString;
        sender: Address;
        amount0Desired: bigint;
        amount1Desired: bigint;
        amount0Min: bigint;
        amount1Min: bigint;
        deadline: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    removeLiquidity: {
      params: SignExecuteContractMethodParams<{
        tokenPairId: HexString;
        sender: Address;
        liquidity: bigint;
        amount0Min: bigint;
        amount1Min: bigint;
        deadline: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    getReserveInAndReserveOut: {
      params: SignExecuteContractMethodParams<{
        tokenPair: HexString;
        tokenInId: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    swapExactTokenForToken: {
      params: SignExecuteContractMethodParams<{
        tokenPair: HexString;
        sender: Address;
        tokenInId: HexString;
        amountIn: bigint;
        amountOutMin: bigint;
        to: Address;
        deadline: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    swapTokenForExactToken: {
      params: SignExecuteContractMethodParams<{
        tokenPair: HexString;
        sender: Address;
        tokenInId: HexString;
        amountInMax: bigint;
        amountOut: bigint;
        to: Address;
        deadline: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    swap: {
      params: SignExecuteContractMethodParams<{
        tokenPair: HexString;
        sender: Address;
        to: Address;
        tokenInId: HexString;
        amountIn: bigint;
        amountOut: 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<RouterInstance, {}> {
  encodeFields() {
    return encodeContractFields({}, this.contract.fieldsSig, []);
  }

  consts = {
    ErrorCodes: {
      ReserveOverflow: BigInt("0"),
      InsufficientInitLiquidity: BigInt("1"),
      InsufficientLiquidityMinted: BigInt("2"),
      InsufficientLiquidityBurned: BigInt("3"),
      InvalidToAddress: BigInt("4"),
      InsufficientLiquidity: BigInt("5"),
      InvalidTokenInId: BigInt("6"),
      InvalidCalleeId: BigInt("7"),
      InvalidK: BigInt("8"),
      InsufficientOutputAmount: BigInt("9"),
      InsufficientInputAmount: BigInt("10"),
      IdenticalTokenIds: BigInt("11"),
      Expired: BigInt("12"),
      InsufficientToken0Amount: BigInt("13"),
      InsufficientToken1Amount: BigInt("14"),
      TokenNotExist: BigInt("15"),
      InvalidCaller: BigInt("16"),
      FeeCollectorNotEnabled: BigInt("17"),
      InvalidAccount: BigInt("18"),
    },
  };

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

  tests = {
    addLiquidity_: async (
      params: Omit<
        TestContractParamsWithoutMaps<
          never,
          {
            reserve0: bigint;
            reserve1: bigint;
            amount0Desired: bigint;
            amount1Desired: bigint;
            amount0Min: bigint;
            amount1Min: bigint;
          }
        >,
        "initialFields"
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
      return testMethod(this, "addLiquidity_", params, getContractByCodeHash);
    },
    addLiquidity: async (
      params: Omit<
        TestContractParamsWithoutMaps<
          never,
          {
            tokenPair: HexString;
            sender: Address;
            amount0Desired: bigint;
            amount1Desired: bigint;
            amount0Min: bigint;
            amount1Min: bigint;
            deadline: bigint;
          }
        >,
        "initialFields"
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
      return testMethod(this, "addLiquidity", params, getContractByCodeHash);
    },
    removeLiquidity: async (
      params: Omit<
        TestContractParamsWithoutMaps<
          never,
          {
            tokenPairId: HexString;
            sender: Address;
            liquidity: bigint;
            amount0Min: bigint;
            amount1Min: bigint;
            deadline: bigint;
          }
        >,
        "initialFields"
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
      return testMethod(this, "removeLiquidity", params, getContractByCodeHash);
    },
    getReserveInAndReserveOut: async (
      params: Omit<
        TestContractParamsWithoutMaps<
          never,
          { tokenPair: HexString; tokenInId: HexString }
        >,
        "initialFields"
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
      return testMethod(
        this,
        "getReserveInAndReserveOut",
        params,
        getContractByCodeHash
      );
    },
    swapExactTokenForToken: async (
      params: Omit<
        TestContractParamsWithoutMaps<
          never,
          {
            tokenPair: HexString;
            sender: Address;
            tokenInId: HexString;
            amountIn: bigint;
            amountOutMin: bigint;
            to: Address;
            deadline: bigint;
          }
        >,
        "initialFields"
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "swapExactTokenForToken",
        params,
        getContractByCodeHash
      );
    },
    swapTokenForExactToken: async (
      params: Omit<
        TestContractParamsWithoutMaps<
          never,
          {
            tokenPair: HexString;
            sender: Address;
            tokenInId: HexString;
            amountInMax: bigint;
            amountOut: bigint;
            to: Address;
            deadline: bigint;
          }
        >,
        "initialFields"
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "swapTokenForExactToken",
        params,
        getContractByCodeHash
      );
    },
    swap: async (
      params: Omit<
        TestContractParamsWithoutMaps<
          never,
          {
            tokenPair: HexString;
            sender: Address;
            to: Address;
            tokenInId: HexString;
            amountIn: bigint;
            amountOut: bigint;
          }
        >,
        "initialFields"
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "swap", params, getContractByCodeHash);
    },
  };

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

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

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

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

  view = {
    addLiquidity_: async (
      params: RouterTypes.CallMethodParams<"addLiquidity_">
    ): Promise<RouterTypes.CallMethodResult<"addLiquidity_">> => {
      return callMethod(
        Router,
        this,
        "addLiquidity_",
        params,
        getContractByCodeHash
      );
    },
    addLiquidity: async (
      params: RouterTypes.CallMethodParams<"addLiquidity">
    ): Promise<RouterTypes.CallMethodResult<"addLiquidity">> => {
      return callMethod(
        Router,
        this,
        "addLiquidity",
        params,
        getContractByCodeHash
      );
    },
    removeLiquidity: async (
      params: RouterTypes.CallMethodParams<"removeLiquidity">
    ): Promise<RouterTypes.CallMethodResult<"removeLiquidity">> => {
      return callMethod(
        Router,
        this,
        "removeLiquidity",
        params,
        getContractByCodeHash
      );
    },
    getReserveInAndReserveOut: async (
      params: RouterTypes.CallMethodParams<"getReserveInAndReserveOut">
    ): Promise<RouterTypes.CallMethodResult<"getReserveInAndReserveOut">> => {
      return callMethod(
        Router,
        this,
        "getReserveInAndReserveOut",
        params,
        getContractByCodeHash
      );
    },
    swapExactTokenForToken: async (
      params: RouterTypes.CallMethodParams<"swapExactTokenForToken">
    ): Promise<RouterTypes.CallMethodResult<"swapExactTokenForToken">> => {
      return callMethod(
        Router,
        this,
        "swapExactTokenForToken",
        params,
        getContractByCodeHash
      );
    },
    swapTokenForExactToken: async (
      params: RouterTypes.CallMethodParams<"swapTokenForExactToken">
    ): Promise<RouterTypes.CallMethodResult<"swapTokenForExactToken">> => {
      return callMethod(
        Router,
        this,
        "swapTokenForExactToken",
        params,
        getContractByCodeHash
      );
    },
    swap: async (
      params: RouterTypes.CallMethodParams<"swap">
    ): Promise<RouterTypes.CallMethodResult<"swap">> => {
      return callMethod(Router, this, "swap", params, getContractByCodeHash);
    },
  };

  transact = {
    addLiquidity_: async (
      params: RouterTypes.SignExecuteMethodParams<"addLiquidity_">
    ): Promise<RouterTypes.SignExecuteMethodResult<"addLiquidity_">> => {
      return signExecuteMethod(Router, this, "addLiquidity_", params);
    },
    addLiquidity: async (
      params: RouterTypes.SignExecuteMethodParams<"addLiquidity">
    ): Promise<RouterTypes.SignExecuteMethodResult<"addLiquidity">> => {
      return signExecuteMethod(Router, this, "addLiquidity", params);
    },
    removeLiquidity: async (
      params: RouterTypes.SignExecuteMethodParams<"removeLiquidity">
    ): Promise<RouterTypes.SignExecuteMethodResult<"removeLiquidity">> => {
      return signExecuteMethod(Router, this, "removeLiquidity", params);
    },
    getReserveInAndReserveOut: async (
      params: RouterTypes.SignExecuteMethodParams<"getReserveInAndReserveOut">
    ): Promise<
      RouterTypes.SignExecuteMethodResult<"getReserveInAndReserveOut">
    > => {
      return signExecuteMethod(
        Router,
        this,
        "getReserveInAndReserveOut",
        params
      );
    },
    swapExactTokenForToken: async (
      params: RouterTypes.SignExecuteMethodParams<"swapExactTokenForToken">
    ): Promise<
      RouterTypes.SignExecuteMethodResult<"swapExactTokenForToken">
    > => {
      return signExecuteMethod(Router, this, "swapExactTokenForToken", params);
    },
    swapTokenForExactToken: async (
      params: RouterTypes.SignExecuteMethodParams<"swapTokenForExactToken">
    ): Promise<
      RouterTypes.SignExecuteMethodResult<"swapTokenForExactToken">
    > => {
      return signExecuteMethod(Router, this, "swapTokenForExactToken", params);
    },
    swap: async (
      params: RouterTypes.SignExecuteMethodParams<"swap">
    ): Promise<RouterTypes.SignExecuteMethodResult<"swap">> => {
      return signExecuteMethod(Router, this, "swap", params);
    },
  };

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