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

// Custom types for the contract
export namespace TokenPairTypes {
  export type Fields = {
    tokenPairFactory: HexString;
    token0Id: HexString;
    token1Id: HexString;
    dexAccount0: HexString;
    reserve0: bigint;
    reserve1: bigint;
    blockTimeStampLast: bigint;
    price0CumulativeLast: bigint;
    price1CumulativeLast: bigint;
    totalSupply: bigint;
    kLast: bigint;
    feeCollectorId: HexString;
  };

  export type State = ContractState<Fields>;

  export type MintEvent = ContractEvent<{
    sender: Address;
    amount0: bigint;
    amount1: bigint;
    liquidity: bigint;
    totalSupply: bigint;
  }>;
  export type BurnEvent = ContractEvent<{
    sender: Address;
    amount0: bigint;
    amount1: bigint;
    liquidity: bigint;
    totalSupply: bigint;
  }>;
  export type SwapEvent = ContractEvent<{
    sender: Address;
    amount0In: bigint;
    amount1In: bigint;
    amount0Out: bigint;
    amount1Out: bigint;
    to: Address;
  }>;

  export interface CallMethodTable {
    getSymbol: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<HexString>;
    };
    getName: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<HexString>;
    };
    getDecimals: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<bigint>;
    };
    getTotalSupply: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<bigint>;
    };
    uqdiv: {
      params: CallContractParams<{ a: bigint; b: bigint }>;
      result: CallContractResult<bigint>;
    };
    sqrt: {
      params: CallContractParams<{ y: bigint }>;
      result: CallContractResult<bigint>;
    };
    setFeeCollectorId: {
      params: CallContractParams<{ id: HexString }>;
      result: CallContractResult<null>;
    };
    getTokenPair: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<[HexString, HexString]>;
    };
    getReserves: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<[bigint, bigint]>;
    };
    getBlockTimeStampLast: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<bigint>;
    };
    getPrice0CumulativeLast: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<bigint>;
    };
    getPrice1CumulativeLast: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<bigint>;
    };
    update: {
      params: CallContractParams<{ newReserve0: bigint; newReserve1: bigint }>;
      result: CallContractResult<null>;
    };
    mintFee: {
      params: CallContractParams<{ reserve0_: bigint; reserve1_: bigint }>;
      result: CallContractResult<[boolean, bigint]>;
    };
    mint: {
      params: CallContractParams<{
        sender: Address;
        amount0: bigint;
        amount1: bigint;
      }>;
      result: CallContractResult<bigint>;
    };
    burn: {
      params: CallContractParams<{ sender: Address; liquidity: bigint }>;
      result: CallContractResult<[bigint, bigint]>;
    };
    swap: {
      params: CallContractParams<{
        sender: Address;
        to: Address;
        amount0In: bigint;
        amount1In: bigint;
        amount0Out: bigint;
        amount1Out: bigint;
      }>;
      result: CallContractResult<null>;
    };
    collectFeeManually: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<null>;
    };
    collectFeeAndUpdateKLast: {
      params: CallContractParams<{ feeAmount: 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 {
    getSymbol: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getName: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getDecimals: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getTotalSupply: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    uqdiv: {
      params: SignExecuteContractMethodParams<{ a: bigint; b: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    sqrt: {
      params: SignExecuteContractMethodParams<{ y: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    setFeeCollectorId: {
      params: SignExecuteContractMethodParams<{ id: HexString }>;
      result: SignExecuteScriptTxResult;
    };
    getTokenPair: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getReserves: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getBlockTimeStampLast: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getPrice0CumulativeLast: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getPrice1CumulativeLast: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    update: {
      params: SignExecuteContractMethodParams<{
        newReserve0: bigint;
        newReserve1: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    mintFee: {
      params: SignExecuteContractMethodParams<{
        reserve0_: bigint;
        reserve1_: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    mint: {
      params: SignExecuteContractMethodParams<{
        sender: Address;
        amount0: bigint;
        amount1: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    burn: {
      params: SignExecuteContractMethodParams<{
        sender: Address;
        liquidity: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    swap: {
      params: SignExecuteContractMethodParams<{
        sender: Address;
        to: Address;
        amount0In: bigint;
        amount1In: bigint;
        amount0Out: bigint;
        amount1Out: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    collectFeeManually: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    collectFeeAndUpdateKLast: {
      params: SignExecuteContractMethodParams<{ feeAmount: 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<
  TokenPairInstance,
  TokenPairTypes.Fields
> {
  encodeFields(fields: TokenPairTypes.Fields) {
    return encodeContractFields(
      addStdIdToFields(this.contract, fields),
      this.contract.fieldsSig,
      []
    );
  }

  eventIndex = { Mint: 0, Burn: 1, Swap: 2 };
  consts = {
    MINIMUM_LIQUIDITY: BigInt("1000"),
    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): TokenPairInstance {
    return new TokenPairInstance(address);
  }

  tests = {
    getSymbol: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "getSymbol", params, getContractByCodeHash);
    },
    getName: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<HexString>> => {
      return testMethod(this, "getName", params, getContractByCodeHash);
    },
    getDecimals: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "getDecimals", params, getContractByCodeHash);
    },
    getTotalSupply: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "getTotalSupply", params, getContractByCodeHash);
    },
    uqdiv: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { a: bigint; b: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "uqdiv", params, getContractByCodeHash);
    },
    sqrt: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { y: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "sqrt", params, getContractByCodeHash);
    },
    setFeeCollectorId: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { id: HexString }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "setFeeCollectorId",
        params,
        getContractByCodeHash
      );
    },
    getTokenPair: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<[HexString, HexString]>> => {
      return testMethod(this, "getTokenPair", params, getContractByCodeHash);
    },
    getReserves: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
      return testMethod(this, "getReserves", params, getContractByCodeHash);
    },
    getBlockTimeStampLast: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "getBlockTimeStampLast",
        params,
        getContractByCodeHash
      );
    },
    getPrice0CumulativeLast: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "getPrice0CumulativeLast",
        params,
        getContractByCodeHash
      );
    },
    getPrice1CumulativeLast: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(
        this,
        "getPrice1CumulativeLast",
        params,
        getContractByCodeHash
      );
    },
    update: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { newReserve0: bigint; newReserve1: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "update", params, getContractByCodeHash);
    },
    mintFee: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { reserve0_: bigint; reserve1_: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<[boolean, bigint]>> => {
      return testMethod(this, "mintFee", params, getContractByCodeHash);
    },
    mint: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { sender: Address; amount0: bigint; amount1: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<bigint>> => {
      return testMethod(this, "mint", params, getContractByCodeHash);
    },
    burn: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { sender: Address; liquidity: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
      return testMethod(this, "burn", params, getContractByCodeHash);
    },
    swap: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        {
          sender: Address;
          to: Address;
          amount0In: bigint;
          amount1In: bigint;
          amount0Out: bigint;
          amount1Out: bigint;
        }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(this, "swap", params, getContractByCodeHash);
    },
    collectFeeManually: async (
      params: Omit<
        TestContractParamsWithoutMaps<TokenPairTypes.Fields, never>,
        "args"
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "collectFeeManually",
        params,
        getContractByCodeHash
      );
    },
    collectFeeAndUpdateKLast: async (
      params: TestContractParamsWithoutMaps<
        TokenPairTypes.Fields,
        { feeAmount: bigint }
      >
    ): Promise<TestContractResultWithoutMaps<null>> => {
      return testMethod(
        this,
        "collectFeeAndUpdateKLast",
        params,
        getContractByCodeHash
      );
    },
  };

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

// Use this object to test and deploy the contract
export const TokenPair = new Factory(
  Contract.fromJson(
    TokenPairContractJson,
    "",
    "3a4ac01ae47b1c84a567e7ef467fc4f7f8e5da32c6546192f0e2b2af3d79891f",
    []
  )
);
registerContract(TokenPair);

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

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

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

  subscribeMintEvent(
    options: EventSubscribeOptions<TokenPairTypes.MintEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      TokenPair.contract,
      this,
      options,
      "Mint",
      fromCount
    );
  }

  subscribeBurnEvent(
    options: EventSubscribeOptions<TokenPairTypes.BurnEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      TokenPair.contract,
      this,
      options,
      "Burn",
      fromCount
    );
  }

  subscribeSwapEvent(
    options: EventSubscribeOptions<TokenPairTypes.SwapEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      TokenPair.contract,
      this,
      options,
      "Swap",
      fromCount
    );
  }

  subscribeAllEvents(
    options: EventSubscribeOptions<
      | TokenPairTypes.MintEvent
      | TokenPairTypes.BurnEvent
      | TokenPairTypes.SwapEvent
    >,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvents(
      TokenPair.contract,
      this,
      options,
      fromCount
    );
  }

  view = {
    getSymbol: async (
      params?: TokenPairTypes.CallMethodParams<"getSymbol">
    ): Promise<TokenPairTypes.CallMethodResult<"getSymbol">> => {
      return callMethod(
        TokenPair,
        this,
        "getSymbol",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getName: async (
      params?: TokenPairTypes.CallMethodParams<"getName">
    ): Promise<TokenPairTypes.CallMethodResult<"getName">> => {
      return callMethod(
        TokenPair,
        this,
        "getName",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getDecimals: async (
      params?: TokenPairTypes.CallMethodParams<"getDecimals">
    ): Promise<TokenPairTypes.CallMethodResult<"getDecimals">> => {
      return callMethod(
        TokenPair,
        this,
        "getDecimals",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getTotalSupply: async (
      params?: TokenPairTypes.CallMethodParams<"getTotalSupply">
    ): Promise<TokenPairTypes.CallMethodResult<"getTotalSupply">> => {
      return callMethod(
        TokenPair,
        this,
        "getTotalSupply",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    uqdiv: async (
      params: TokenPairTypes.CallMethodParams<"uqdiv">
    ): Promise<TokenPairTypes.CallMethodResult<"uqdiv">> => {
      return callMethod(
        TokenPair,
        this,
        "uqdiv",
        params,
        getContractByCodeHash
      );
    },
    sqrt: async (
      params: TokenPairTypes.CallMethodParams<"sqrt">
    ): Promise<TokenPairTypes.CallMethodResult<"sqrt">> => {
      return callMethod(TokenPair, this, "sqrt", params, getContractByCodeHash);
    },
    setFeeCollectorId: async (
      params: TokenPairTypes.CallMethodParams<"setFeeCollectorId">
    ): Promise<TokenPairTypes.CallMethodResult<"setFeeCollectorId">> => {
      return callMethod(
        TokenPair,
        this,
        "setFeeCollectorId",
        params,
        getContractByCodeHash
      );
    },
    getTokenPair: async (
      params?: TokenPairTypes.CallMethodParams<"getTokenPair">
    ): Promise<TokenPairTypes.CallMethodResult<"getTokenPair">> => {
      return callMethod(
        TokenPair,
        this,
        "getTokenPair",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getReserves: async (
      params?: TokenPairTypes.CallMethodParams<"getReserves">
    ): Promise<TokenPairTypes.CallMethodResult<"getReserves">> => {
      return callMethod(
        TokenPair,
        this,
        "getReserves",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getBlockTimeStampLast: async (
      params?: TokenPairTypes.CallMethodParams<"getBlockTimeStampLast">
    ): Promise<TokenPairTypes.CallMethodResult<"getBlockTimeStampLast">> => {
      return callMethod(
        TokenPair,
        this,
        "getBlockTimeStampLast",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getPrice0CumulativeLast: async (
      params?: TokenPairTypes.CallMethodParams<"getPrice0CumulativeLast">
    ): Promise<TokenPairTypes.CallMethodResult<"getPrice0CumulativeLast">> => {
      return callMethod(
        TokenPair,
        this,
        "getPrice0CumulativeLast",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getPrice1CumulativeLast: async (
      params?: TokenPairTypes.CallMethodParams<"getPrice1CumulativeLast">
    ): Promise<TokenPairTypes.CallMethodResult<"getPrice1CumulativeLast">> => {
      return callMethod(
        TokenPair,
        this,
        "getPrice1CumulativeLast",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    update: async (
      params: TokenPairTypes.CallMethodParams<"update">
    ): Promise<TokenPairTypes.CallMethodResult<"update">> => {
      return callMethod(
        TokenPair,
        this,
        "update",
        params,
        getContractByCodeHash
      );
    },
    mintFee: async (
      params: TokenPairTypes.CallMethodParams<"mintFee">
    ): Promise<TokenPairTypes.CallMethodResult<"mintFee">> => {
      return callMethod(
        TokenPair,
        this,
        "mintFee",
        params,
        getContractByCodeHash
      );
    },
    mint: async (
      params: TokenPairTypes.CallMethodParams<"mint">
    ): Promise<TokenPairTypes.CallMethodResult<"mint">> => {
      return callMethod(TokenPair, this, "mint", params, getContractByCodeHash);
    },
    burn: async (
      params: TokenPairTypes.CallMethodParams<"burn">
    ): Promise<TokenPairTypes.CallMethodResult<"burn">> => {
      return callMethod(TokenPair, this, "burn", params, getContractByCodeHash);
    },
    swap: async (
      params: TokenPairTypes.CallMethodParams<"swap">
    ): Promise<TokenPairTypes.CallMethodResult<"swap">> => {
      return callMethod(TokenPair, this, "swap", params, getContractByCodeHash);
    },
    collectFeeManually: async (
      params?: TokenPairTypes.CallMethodParams<"collectFeeManually">
    ): Promise<TokenPairTypes.CallMethodResult<"collectFeeManually">> => {
      return callMethod(
        TokenPair,
        this,
        "collectFeeManually",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    collectFeeAndUpdateKLast: async (
      params: TokenPairTypes.CallMethodParams<"collectFeeAndUpdateKLast">
    ): Promise<TokenPairTypes.CallMethodResult<"collectFeeAndUpdateKLast">> => {
      return callMethod(
        TokenPair,
        this,
        "collectFeeAndUpdateKLast",
        params,
        getContractByCodeHash
      );
    },
  };

  transact = {
    getSymbol: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getSymbol">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"getSymbol">> => {
      return signExecuteMethod(TokenPair, this, "getSymbol", params);
    },
    getName: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getName">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"getName">> => {
      return signExecuteMethod(TokenPair, this, "getName", params);
    },
    getDecimals: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getDecimals">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"getDecimals">> => {
      return signExecuteMethod(TokenPair, this, "getDecimals", params);
    },
    getTotalSupply: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getTotalSupply">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"getTotalSupply">> => {
      return signExecuteMethod(TokenPair, this, "getTotalSupply", params);
    },
    uqdiv: async (
      params: TokenPairTypes.SignExecuteMethodParams<"uqdiv">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"uqdiv">> => {
      return signExecuteMethod(TokenPair, this, "uqdiv", params);
    },
    sqrt: async (
      params: TokenPairTypes.SignExecuteMethodParams<"sqrt">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"sqrt">> => {
      return signExecuteMethod(TokenPair, this, "sqrt", params);
    },
    setFeeCollectorId: async (
      params: TokenPairTypes.SignExecuteMethodParams<"setFeeCollectorId">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"setFeeCollectorId">> => {
      return signExecuteMethod(TokenPair, this, "setFeeCollectorId", params);
    },
    getTokenPair: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getTokenPair">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"getTokenPair">> => {
      return signExecuteMethod(TokenPair, this, "getTokenPair", params);
    },
    getReserves: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getReserves">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"getReserves">> => {
      return signExecuteMethod(TokenPair, this, "getReserves", params);
    },
    getBlockTimeStampLast: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getBlockTimeStampLast">
    ): Promise<
      TokenPairTypes.SignExecuteMethodResult<"getBlockTimeStampLast">
    > => {
      return signExecuteMethod(
        TokenPair,
        this,
        "getBlockTimeStampLast",
        params
      );
    },
    getPrice0CumulativeLast: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getPrice0CumulativeLast">
    ): Promise<
      TokenPairTypes.SignExecuteMethodResult<"getPrice0CumulativeLast">
    > => {
      return signExecuteMethod(
        TokenPair,
        this,
        "getPrice0CumulativeLast",
        params
      );
    },
    getPrice1CumulativeLast: async (
      params: TokenPairTypes.SignExecuteMethodParams<"getPrice1CumulativeLast">
    ): Promise<
      TokenPairTypes.SignExecuteMethodResult<"getPrice1CumulativeLast">
    > => {
      return signExecuteMethod(
        TokenPair,
        this,
        "getPrice1CumulativeLast",
        params
      );
    },
    update: async (
      params: TokenPairTypes.SignExecuteMethodParams<"update">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"update">> => {
      return signExecuteMethod(TokenPair, this, "update", params);
    },
    mintFee: async (
      params: TokenPairTypes.SignExecuteMethodParams<"mintFee">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"mintFee">> => {
      return signExecuteMethod(TokenPair, this, "mintFee", params);
    },
    mint: async (
      params: TokenPairTypes.SignExecuteMethodParams<"mint">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"mint">> => {
      return signExecuteMethod(TokenPair, this, "mint", params);
    },
    burn: async (
      params: TokenPairTypes.SignExecuteMethodParams<"burn">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"burn">> => {
      return signExecuteMethod(TokenPair, this, "burn", params);
    },
    swap: async (
      params: TokenPairTypes.SignExecuteMethodParams<"swap">
    ): Promise<TokenPairTypes.SignExecuteMethodResult<"swap">> => {
      return signExecuteMethod(TokenPair, this, "swap", params);
    },
    collectFeeManually: async (
      params: TokenPairTypes.SignExecuteMethodParams<"collectFeeManually">
    ): Promise<
      TokenPairTypes.SignExecuteMethodResult<"collectFeeManually">
    > => {
      return signExecuteMethod(TokenPair, this, "collectFeeManually", params);
    },
    collectFeeAndUpdateKLast: async (
      params: TokenPairTypes.SignExecuteMethodParams<"collectFeeAndUpdateKLast">
    ): Promise<
      TokenPairTypes.SignExecuteMethodResult<"collectFeeAndUpdateKLast">
    > => {
      return signExecuteMethod(
        TokenPair,
        this,
        "collectFeeAndUpdateKLast",
        params
      );
    },
  };

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