/* 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 XAlphStakeVaultContractJson } from "../XAlphStakeVault.ral.json";
import { getContractByCodeHash, registerContract } from "./contracts";
import * as types from "./types";
import { RalphMap } from "@alephium/web3";

// Custom types for the contract
export namespace XAlphStakeVaultTypes {
  export type Fields = {
    stakeTokenId: HexString;
    maxConnectedDapps: bigint;
    merkleRoot: HexString;
    totalStakedAmount: bigint;
    owner: Address;
  };

  export type State = ContractState<Fields>;

  export type UpdateRootEvent = ContractEvent<{
    newMerkleRoot: HexString;
    updatedBy: Address;
  }>;
  export type StakedEvent = ContractEvent<{ staker: Address; amount: bigint }>;
  export type UnstakedEvent = ContractEvent<{
    staker: Address;
    amount: bigint;
  }>;

  export interface CallMethodTable {
    get: {
      params: CallContractParams<{ array: HexString; index: bigint }>;
      result: CallContractResult<HexString>;
    };
    find: {
      params: CallContractParams<{ array: HexString; value: HexString }>;
      result: CallContractResult<bigint>;
    };
    remove: {
      params: CallContractParams<{ array: HexString; value: HexString }>;
      result: CallContractResult<HexString>;
    };
    push: {
      params: CallContractParams<{ array: HexString; value: HexString }>;
      result: CallContractResult<HexString>;
    };
    removeAt: {
      params: CallContractParams<{ array: HexString; index: bigint }>;
      result: CallContractResult<HexString>;
    };
    size: {
      params: CallContractParams<{ array: HexString }>;
      result: CallContractResult<bigint>;
    };
    empty: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<HexString>;
    };
    getMerkleRoot: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<HexString>;
    };
    updateRoot: {
      params: CallContractParams<{ newMerkleRoot: HexString }>;
      result: CallContractResult<null>;
    };
    verify: {
      params: CallContractParams<{ proof: HexString; dataHash: HexString }>;
      result: CallContractResult<boolean>;
    };
    hashPair: {
      params: CallContractParams<{ a: HexString; b: HexString }>;
      result: CallContractResult<HexString>;
    };
    hash: {
      params: CallContractParams<{ dataToHash: HexString }>;
      result: CallContractResult<HexString>;
    };
    getStakeTokenId: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<HexString>;
    };
    getUserStakingInfo: {
      params: CallContractParams<{ user: Address }>;
      result: CallContractResult<types.UserStakingInfo>;
    };
    isStaking: {
      params: CallContractParams<{ user: Address }>;
      result: CallContractResult<boolean>;
    };
    stake: {
      params: CallContractParams<{ amount: bigint }>;
      result: CallContractResult<null>;
    };
    unstake: {
      params: CallContractParams<{ amount: bigint }>;
      result: CallContractResult<null>;
    };
    connectToDapp: {
      params: CallContractParams<{
        contractId: HexString;
        merkleProof: HexString;
      }>;
      result: CallContractResult<null>;
    };
    disconnectFromDapp: {
      params: CallContractParams<{ contractId: HexString }>;
      result: CallContractResult<null>;
    };
    getWeight: {
      params: CallContractParams<{ user: Address }>;
      result: CallContractResult<bigint>;
    };
    updateDappTemplatesWhitelistMerkleRoot: {
      params: CallContractParams<{ newMerkleRoot: HexString }>;
      result: CallContractResult<null>;
    };
    updateOwner: {
      params: CallContractParams<{ newOwner: Address }>;
      result: CallContractResult<null>;
    };
    verifyDappTemplatesWhiteListed: {
      params: CallContractParams<{ proof: HexString; contractId: HexString }>;
      result: CallContractResult<boolean>;
    };
  }
  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 {
    get: {
      params: SignExecuteContractMethodParams<{
        array: HexString;
        index: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    find: {
      params: SignExecuteContractMethodParams<{
        array: HexString;
        value: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    remove: {
      params: SignExecuteContractMethodParams<{
        array: HexString;
        value: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    push: {
      params: SignExecuteContractMethodParams<{
        array: HexString;
        value: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    removeAt: {
      params: SignExecuteContractMethodParams<{
        array: HexString;
        index: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    size: {
      params: SignExecuteContractMethodParams<{ array: HexString }>;
      result: SignExecuteScriptTxResult;
    };
    empty: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getMerkleRoot: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    updateRoot: {
      params: SignExecuteContractMethodParams<{ newMerkleRoot: HexString }>;
      result: SignExecuteScriptTxResult;
    };
    verify: {
      params: SignExecuteContractMethodParams<{
        proof: HexString;
        dataHash: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    hashPair: {
      params: SignExecuteContractMethodParams<{ a: HexString; b: HexString }>;
      result: SignExecuteScriptTxResult;
    };
    hash: {
      params: SignExecuteContractMethodParams<{ dataToHash: HexString }>;
      result: SignExecuteScriptTxResult;
    };
    getStakeTokenId: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    getUserStakingInfo: {
      params: SignExecuteContractMethodParams<{ user: Address }>;
      result: SignExecuteScriptTxResult;
    };
    isStaking: {
      params: SignExecuteContractMethodParams<{ user: Address }>;
      result: SignExecuteScriptTxResult;
    };
    stake: {
      params: SignExecuteContractMethodParams<{ amount: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    unstake: {
      params: SignExecuteContractMethodParams<{ amount: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    connectToDapp: {
      params: SignExecuteContractMethodParams<{
        contractId: HexString;
        merkleProof: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
    disconnectFromDapp: {
      params: SignExecuteContractMethodParams<{ contractId: HexString }>;
      result: SignExecuteScriptTxResult;
    };
    getWeight: {
      params: SignExecuteContractMethodParams<{ user: Address }>;
      result: SignExecuteScriptTxResult;
    };
    updateDappTemplatesWhitelistMerkleRoot: {
      params: SignExecuteContractMethodParams<{ newMerkleRoot: HexString }>;
      result: SignExecuteScriptTxResult;
    };
    updateOwner: {
      params: SignExecuteContractMethodParams<{ newOwner: Address }>;
      result: SignExecuteScriptTxResult;
    };
    verifyDappTemplatesWhiteListed: {
      params: SignExecuteContractMethodParams<{
        proof: HexString;
        contractId: HexString;
      }>;
      result: SignExecuteScriptTxResult;
    };
  }
  export type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> =
    SignExecuteMethodTable[T]["params"];
  export type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> =
    SignExecuteMethodTable[T]["result"];

  export type Maps = { userStakingInfo?: Map<Address, types.UserStakingInfo> };
}

class Factory extends ContractFactory<
  XAlphStakeVaultInstance,
  XAlphStakeVaultTypes.Fields
> {
  encodeFields(fields: XAlphStakeVaultTypes.Fields) {
    return encodeContractFields(
      addStdIdToFields(this.contract, fields),
      this.contract.fieldsSig,
      types.AllStructs
    );
  }

  eventIndex = { UpdateRoot: 0, Staked: 1, Unstaked: 2 };
  consts = {
    IntByteLength: BigInt("32"),
    WEIGHT_SCALING_FACTOR: BigInt("1000000000000000000"),
    ErrorCode: {
      InvalidArrayLength: BigInt("550"),
      IndexOutOfBound: BigInt("551"),
      InvalidByteVecLength: BigInt("552"),
    },
    MerkleProofErrorCodes: {
      InvalidProofSize: BigInt("11001"),
      InvalidDataHash: BigInt("11002"),
      InvalidMerkleRoot: BigInt("11003"),
    },
    ErrorCodes: {
      NotOwner: BigInt("300"),
      AssetAddressCallerOnly: BigInt("301"),
      NoStakingInfo: BigInt("302"),
      InsufficientStakedAmount: BigInt("303"),
      InvalidStakedAmount: BigInt("304"),
      InvalidUnstakedAmount: BigInt("305"),
      MaxConnectedDappsReached: BigInt("306"),
      DappAlreadyConnected: BigInt("307"),
      DappNotConnected: BigInt("308"),
      DappNotAllowed: BigInt("309"),
    },
  };

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

  tests = {
    get: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { array: HexString; index: bigint },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "get", params, getContractByCodeHash);
    },
    find: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { array: HexString; value: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<bigint, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "find", params, getContractByCodeHash);
    },
    remove: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { array: HexString; value: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "remove", params, getContractByCodeHash);
    },
    push: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { array: HexString; value: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "push", params, getContractByCodeHash);
    },
    removeAt: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { array: HexString; index: bigint },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "removeAt", params, getContractByCodeHash);
    },
    size: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { array: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<bigint, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "size", params, getContractByCodeHash);
    },
    empty: async (
      params: Omit<
        TestContractParams<
          XAlphStakeVaultTypes.Fields,
          never,
          XAlphStakeVaultTypes.Maps
        >,
        "args"
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "empty", params, getContractByCodeHash);
    },
    getMerkleRoot: async (
      params: Omit<
        TestContractParams<
          XAlphStakeVaultTypes.Fields,
          never,
          XAlphStakeVaultTypes.Maps
        >,
        "args"
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "getMerkleRoot", params, getContractByCodeHash);
    },
    updateRoot: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { newMerkleRoot: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "updateRoot", params, getContractByCodeHash);
    },
    verify: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { proof: HexString; dataHash: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<boolean, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "verify", params, getContractByCodeHash);
    },
    hashPair: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { a: HexString; b: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "hashPair", params, getContractByCodeHash);
    },
    hash: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { dataToHash: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "hash", params, getContractByCodeHash);
    },
    getStakeTokenId: async (
      params: Omit<
        TestContractParams<
          XAlphStakeVaultTypes.Fields,
          never,
          XAlphStakeVaultTypes.Maps
        >,
        "args"
      >
    ): Promise<TestContractResult<HexString, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "getStakeTokenId", params, getContractByCodeHash);
    },
    getUserStakingInfo: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { user: Address },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<
      TestContractResult<types.UserStakingInfo, XAlphStakeVaultTypes.Maps>
    > => {
      return testMethod(
        this,
        "getUserStakingInfo",
        params,
        getContractByCodeHash
      );
    },
    isStaking: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { user: Address },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<boolean, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "isStaking", params, getContractByCodeHash);
    },
    stake: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { amount: bigint },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "stake", params, getContractByCodeHash);
    },
    unstake: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { amount: bigint },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "unstake", params, getContractByCodeHash);
    },
    connectToDapp: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { contractId: HexString; merkleProof: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "connectToDapp", params, getContractByCodeHash);
    },
    disconnectFromDapp: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { contractId: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(
        this,
        "disconnectFromDapp",
        params,
        getContractByCodeHash
      );
    },
    getWeight: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { user: Address },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<bigint, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "getWeight", params, getContractByCodeHash);
    },
    updateDappTemplatesWhitelistMerkleRoot: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { newMerkleRoot: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(
        this,
        "updateDappTemplatesWhitelistMerkleRoot",
        params,
        getContractByCodeHash
      );
    },
    updateOwner: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { newOwner: Address },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(this, "updateOwner", params, getContractByCodeHash);
    },
    verifyDappTemplatesWhiteListed: async (
      params: TestContractParams<
        XAlphStakeVaultTypes.Fields,
        { proof: HexString; contractId: HexString },
        XAlphStakeVaultTypes.Maps
      >
    ): Promise<TestContractResult<boolean, XAlphStakeVaultTypes.Maps>> => {
      return testMethod(
        this,
        "verifyDappTemplatesWhiteListed",
        params,
        getContractByCodeHash
      );
    },
  };

  stateForTest(
    initFields: XAlphStakeVaultTypes.Fields,
    asset?: Asset,
    address?: string,
    maps?: XAlphStakeVaultTypes.Maps
  ) {
    return this.stateForTest_(initFields, asset, address, maps);
  }
}

// Use this object to test and deploy the contract
export const XAlphStakeVault = new Factory(
  Contract.fromJson(
    XAlphStakeVaultContractJson,
    "=66-2+29=1-3=1+22=1-1+4=1+d=2-2+43=2-2+92=2-2+a9=2-2+c0=2-2+d9=1166-2+61=323-1+b=34+7a7e0214696e73657274206174206d617020706174683a2000=55-1+d=297-1+c=38+7a7e021472656d6f7665206174206d617020706174683a2000=976",
    "5a98904451536bfc5851ac53658d832b096d820da66892272b361692d7a31790",
    types.AllStructs
  )
);
registerContract(XAlphStakeVault);

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

  maps = {
    userStakingInfo: new RalphMap<Address, types.UserStakingInfo>(
      XAlphStakeVault.contract,
      this.contractId,
      "userStakingInfo"
    ),
  };

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

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

  subscribeUpdateRootEvent(
    options: EventSubscribeOptions<XAlphStakeVaultTypes.UpdateRootEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      XAlphStakeVault.contract,
      this,
      options,
      "UpdateRoot",
      fromCount
    );
  }

  subscribeStakedEvent(
    options: EventSubscribeOptions<XAlphStakeVaultTypes.StakedEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      XAlphStakeVault.contract,
      this,
      options,
      "Staked",
      fromCount
    );
  }

  subscribeUnstakedEvent(
    options: EventSubscribeOptions<XAlphStakeVaultTypes.UnstakedEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      XAlphStakeVault.contract,
      this,
      options,
      "Unstaked",
      fromCount
    );
  }

  subscribeAllEvents(
    options: EventSubscribeOptions<
      | XAlphStakeVaultTypes.UpdateRootEvent
      | XAlphStakeVaultTypes.StakedEvent
      | XAlphStakeVaultTypes.UnstakedEvent
    >,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvents(
      XAlphStakeVault.contract,
      this,
      options,
      fromCount
    );
  }

  view = {
    get: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"get">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"get">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "get",
        params,
        getContractByCodeHash
      );
    },
    find: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"find">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"find">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "find",
        params,
        getContractByCodeHash
      );
    },
    remove: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"remove">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"remove">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "remove",
        params,
        getContractByCodeHash
      );
    },
    push: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"push">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"push">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "push",
        params,
        getContractByCodeHash
      );
    },
    removeAt: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"removeAt">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"removeAt">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "removeAt",
        params,
        getContractByCodeHash
      );
    },
    size: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"size">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"size">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "size",
        params,
        getContractByCodeHash
      );
    },
    empty: async (
      params?: XAlphStakeVaultTypes.CallMethodParams<"empty">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"empty">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "empty",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getMerkleRoot: async (
      params?: XAlphStakeVaultTypes.CallMethodParams<"getMerkleRoot">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"getMerkleRoot">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "getMerkleRoot",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    updateRoot: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"updateRoot">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"updateRoot">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "updateRoot",
        params,
        getContractByCodeHash
      );
    },
    verify: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"verify">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"verify">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "verify",
        params,
        getContractByCodeHash
      );
    },
    hashPair: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"hashPair">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"hashPair">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "hashPair",
        params,
        getContractByCodeHash
      );
    },
    hash: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"hash">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"hash">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "hash",
        params,
        getContractByCodeHash
      );
    },
    getStakeTokenId: async (
      params?: XAlphStakeVaultTypes.CallMethodParams<"getStakeTokenId">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"getStakeTokenId">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "getStakeTokenId",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    getUserStakingInfo: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"getUserStakingInfo">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"getUserStakingInfo">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "getUserStakingInfo",
        params,
        getContractByCodeHash
      );
    },
    isStaking: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"isStaking">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"isStaking">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "isStaking",
        params,
        getContractByCodeHash
      );
    },
    stake: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"stake">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"stake">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "stake",
        params,
        getContractByCodeHash
      );
    },
    unstake: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"unstake">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"unstake">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "unstake",
        params,
        getContractByCodeHash
      );
    },
    connectToDapp: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"connectToDapp">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"connectToDapp">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "connectToDapp",
        params,
        getContractByCodeHash
      );
    },
    disconnectFromDapp: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"disconnectFromDapp">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"disconnectFromDapp">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "disconnectFromDapp",
        params,
        getContractByCodeHash
      );
    },
    getWeight: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"getWeight">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"getWeight">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "getWeight",
        params,
        getContractByCodeHash
      );
    },
    updateDappTemplatesWhitelistMerkleRoot: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"updateDappTemplatesWhitelistMerkleRoot">
    ): Promise<
      XAlphStakeVaultTypes.CallMethodResult<"updateDappTemplatesWhitelistMerkleRoot">
    > => {
      return callMethod(
        XAlphStakeVault,
        this,
        "updateDappTemplatesWhitelistMerkleRoot",
        params,
        getContractByCodeHash
      );
    },
    updateOwner: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"updateOwner">
    ): Promise<XAlphStakeVaultTypes.CallMethodResult<"updateOwner">> => {
      return callMethod(
        XAlphStakeVault,
        this,
        "updateOwner",
        params,
        getContractByCodeHash
      );
    },
    verifyDappTemplatesWhiteListed: async (
      params: XAlphStakeVaultTypes.CallMethodParams<"verifyDappTemplatesWhiteListed">
    ): Promise<
      XAlphStakeVaultTypes.CallMethodResult<"verifyDappTemplatesWhiteListed">
    > => {
      return callMethod(
        XAlphStakeVault,
        this,
        "verifyDappTemplatesWhiteListed",
        params,
        getContractByCodeHash
      );
    },
  };

  transact = {
    get: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"get">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"get">> => {
      return signExecuteMethod(XAlphStakeVault, this, "get", params);
    },
    find: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"find">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"find">> => {
      return signExecuteMethod(XAlphStakeVault, this, "find", params);
    },
    remove: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"remove">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"remove">> => {
      return signExecuteMethod(XAlphStakeVault, this, "remove", params);
    },
    push: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"push">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"push">> => {
      return signExecuteMethod(XAlphStakeVault, this, "push", params);
    },
    removeAt: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"removeAt">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"removeAt">> => {
      return signExecuteMethod(XAlphStakeVault, this, "removeAt", params);
    },
    size: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"size">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"size">> => {
      return signExecuteMethod(XAlphStakeVault, this, "size", params);
    },
    empty: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"empty">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"empty">> => {
      return signExecuteMethod(XAlphStakeVault, this, "empty", params);
    },
    getMerkleRoot: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getMerkleRoot">
    ): Promise<
      XAlphStakeVaultTypes.SignExecuteMethodResult<"getMerkleRoot">
    > => {
      return signExecuteMethod(XAlphStakeVault, this, "getMerkleRoot", params);
    },
    updateRoot: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"updateRoot">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"updateRoot">> => {
      return signExecuteMethod(XAlphStakeVault, this, "updateRoot", params);
    },
    verify: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"verify">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"verify">> => {
      return signExecuteMethod(XAlphStakeVault, this, "verify", params);
    },
    hashPair: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"hashPair">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"hashPair">> => {
      return signExecuteMethod(XAlphStakeVault, this, "hashPair", params);
    },
    hash: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"hash">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"hash">> => {
      return signExecuteMethod(XAlphStakeVault, this, "hash", params);
    },
    getStakeTokenId: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getStakeTokenId">
    ): Promise<
      XAlphStakeVaultTypes.SignExecuteMethodResult<"getStakeTokenId">
    > => {
      return signExecuteMethod(
        XAlphStakeVault,
        this,
        "getStakeTokenId",
        params
      );
    },
    getUserStakingInfo: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getUserStakingInfo">
    ): Promise<
      XAlphStakeVaultTypes.SignExecuteMethodResult<"getUserStakingInfo">
    > => {
      return signExecuteMethod(
        XAlphStakeVault,
        this,
        "getUserStakingInfo",
        params
      );
    },
    isStaking: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"isStaking">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"isStaking">> => {
      return signExecuteMethod(XAlphStakeVault, this, "isStaking", params);
    },
    stake: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"stake">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"stake">> => {
      return signExecuteMethod(XAlphStakeVault, this, "stake", params);
    },
    unstake: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"unstake">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"unstake">> => {
      return signExecuteMethod(XAlphStakeVault, this, "unstake", params);
    },
    connectToDapp: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"connectToDapp">
    ): Promise<
      XAlphStakeVaultTypes.SignExecuteMethodResult<"connectToDapp">
    > => {
      return signExecuteMethod(XAlphStakeVault, this, "connectToDapp", params);
    },
    disconnectFromDapp: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"disconnectFromDapp">
    ): Promise<
      XAlphStakeVaultTypes.SignExecuteMethodResult<"disconnectFromDapp">
    > => {
      return signExecuteMethod(
        XAlphStakeVault,
        this,
        "disconnectFromDapp",
        params
      );
    },
    getWeight: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"getWeight">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"getWeight">> => {
      return signExecuteMethod(XAlphStakeVault, this, "getWeight", params);
    },
    updateDappTemplatesWhitelistMerkleRoot: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"updateDappTemplatesWhitelistMerkleRoot">
    ): Promise<
      XAlphStakeVaultTypes.SignExecuteMethodResult<"updateDappTemplatesWhitelistMerkleRoot">
    > => {
      return signExecuteMethod(
        XAlphStakeVault,
        this,
        "updateDappTemplatesWhitelistMerkleRoot",
        params
      );
    },
    updateOwner: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"updateOwner">
    ): Promise<XAlphStakeVaultTypes.SignExecuteMethodResult<"updateOwner">> => {
      return signExecuteMethod(XAlphStakeVault, this, "updateOwner", params);
    },
    verifyDappTemplatesWhiteListed: async (
      params: XAlphStakeVaultTypes.SignExecuteMethodParams<"verifyDappTemplatesWhiteListed">
    ): Promise<
      XAlphStakeVaultTypes.SignExecuteMethodResult<"verifyDappTemplatesWhiteListed">
    > => {
      return signExecuteMethod(
        XAlphStakeVault,
        this,
        "verifyDappTemplatesWhiteListed",
        params
      );
    },
  };

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