@alephium/powfi-sdk 0.0.1-rc.1

package/staking/artifacts/ts/XAlphStakeVault.ts

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