@alephium/powfi-sdk 0.0.1-rc.1

package/cpmm/artifacts/ts/TokenPair.ts

@@ -0,0 +1,947 @@
+/* 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
+    );
+  }
+}