@alephium/powfi-sdk 0.0.1-rc.1

package/staking/artifacts/ts/XAlphToken.ts

@@ -0,0 +1,835 @@
+/* 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 XAlphTokenContractJson } from "../XAlphToken.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+import { RalphMap } from "@alephium/web3";
+
+// Custom types for the contract
+export namespace XAlphTokenTypes {
+  export type Fields = {
+    symbol: HexString;
+    name: HexString;
+    decimals: bigint;
+    unstakeVaultTemplateId: HexString;
+    maxActiveUnstakeRequestsPerUser: bigint;
+    unstakeDuration: bigint;
+    totalStaked: bigint;
+    lastUnstakeVaultIndex: bigint;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export type StakedEvent = ContractEvent<{ to: Address; amount: bigint }>;
+  export type UnstakeScheduledEvent = ContractEvent<{
+    to: Address;
+    amount: bigint;
+  }>;
+
+  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>;
+    };
+    get: {
+      params: CallContractParams<{ array: HexString; index: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    find: {
+      params: CallContractParams<{ array: HexString; value: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    remove: {
+      params: CallContractParams<{ array: HexString; value: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    push: {
+      params: CallContractParams<{ array: HexString; value: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    binarySearch: {
+      params: CallContractParams<{
+        array: HexString;
+        value: bigint;
+        left: bigint;
+        right: bigint;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    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>;
+    };
+    stake: {
+      params: CallContractParams<{ amount: bigint }>;
+      result: CallContractResult<null>;
+    };
+    startUnstake: {
+      params: CallContractParams<{ amount: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    getActiveUnstakeVaultIndexes: {
+      params: CallContractParams<{ caller: Address }>;
+      result: CallContractResult<HexString>;
+    };
+    getClaimableAmount: {
+      params: CallContractParams<{ user: Address; vaultIndex: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    claimUnstaked: {
+      params: CallContractParams<{ vaultIndex: bigint; amount: 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;
+    };
+    get: {
+      params: SignExecuteContractMethodParams<{
+        array: HexString;
+        index: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    find: {
+      params: SignExecuteContractMethodParams<{
+        array: HexString;
+        value: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    remove: {
+      params: SignExecuteContractMethodParams<{
+        array: HexString;
+        value: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    push: {
+      params: SignExecuteContractMethodParams<{
+        array: HexString;
+        value: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    binarySearch: {
+      params: SignExecuteContractMethodParams<{
+        array: HexString;
+        value: bigint;
+        left: bigint;
+        right: bigint;
+      }>;
+      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;
+    };
+    stake: {
+      params: SignExecuteContractMethodParams<{ amount: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    startUnstake: {
+      params: SignExecuteContractMethodParams<{ amount: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getActiveUnstakeVaultIndexes: {
+      params: SignExecuteContractMethodParams<{ caller: Address }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getClaimableAmount: {
+      params: SignExecuteContractMethodParams<{
+        user: Address;
+        vaultIndex: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    claimUnstaked: {
+      params: SignExecuteContractMethodParams<{
+        vaultIndex: bigint;
+        amount: bigint;
+      }>;
+      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 = { userActiveUnstakeVaults?: Map<Address, HexString> };
+}
+
+class Factory extends ContractFactory<
+  XAlphTokenInstance,
+  XAlphTokenTypes.Fields
+> {
+  encodeFields(fields: XAlphTokenTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  eventIndex = { Staked: 0, UnstakeScheduled: 1 };
+  consts = {
+    IntByteLength: BigInt("32"),
+    ErrorCode: {
+      InvalidArrayLength: BigInt("550"),
+      IndexOutOfBound: BigInt("551"),
+      InvalidByteVecLength: BigInt("552"),
+    },
+    ErrorCodes: {
+      AssetAddressCallerOnly: BigInt("10"),
+      TooManyActiveUnstakeVaults: BigInt("11"),
+      InvalidUnstakeDuration: BigInt("12"),
+      NonExistantUnstakeVault: BigInt("13"),
+      AmountMustBeGreaterThanZero: BigInt("14"),
+    },
+  };
+
+  at(address: string): XAlphTokenInstance {
+    return new XAlphTokenInstance(address);
+  }
+
+  tests = {
+    getSymbol: async (
+      params: Omit<
+        TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>,
+        "args"
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "getSymbol", params, getContractByCodeHash);
+    },
+    getName: async (
+      params: Omit<
+        TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>,
+        "args"
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "getName", params, getContractByCodeHash);
+    },
+    getDecimals: async (
+      params: Omit<
+        TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>,
+        "args"
+      >
+    ): Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "getDecimals", params, getContractByCodeHash);
+    },
+    getTotalSupply: async (
+      params: Omit<
+        TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>,
+        "args"
+      >
+    ): Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "getTotalSupply", params, getContractByCodeHash);
+    },
+    get: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { array: HexString; index: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "get", params, getContractByCodeHash);
+    },
+    find: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { array: HexString; value: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "find", params, getContractByCodeHash);
+    },
+    remove: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { array: HexString; value: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "remove", params, getContractByCodeHash);
+    },
+    push: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { array: HexString; value: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "push", params, getContractByCodeHash);
+    },
+    binarySearch: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { array: HexString; value: bigint; left: bigint; right: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "binarySearch", params, getContractByCodeHash);
+    },
+    removeAt: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { array: HexString; index: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "removeAt", params, getContractByCodeHash);
+    },
+    size: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { array: HexString },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "size", params, getContractByCodeHash);
+    },
+    empty: async (
+      params: Omit<
+        TestContractParams<XAlphTokenTypes.Fields, never, XAlphTokenTypes.Maps>,
+        "args"
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "empty", params, getContractByCodeHash);
+    },
+    stake: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { amount: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<null, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "stake", params, getContractByCodeHash);
+    },
+    startUnstake: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { amount: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "startUnstake", params, getContractByCodeHash);
+    },
+    getActiveUnstakeVaultIndexes: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { caller: Address },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<HexString, XAlphTokenTypes.Maps>> => {
+      return testMethod(
+        this,
+        "getActiveUnstakeVaultIndexes",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getClaimableAmount: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { user: Address; vaultIndex: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<bigint, XAlphTokenTypes.Maps>> => {
+      return testMethod(
+        this,
+        "getClaimableAmount",
+        params,
+        getContractByCodeHash
+      );
+    },
+    claimUnstaked: async (
+      params: TestContractParams<
+        XAlphTokenTypes.Fields,
+        { vaultIndex: bigint; amount: bigint },
+        XAlphTokenTypes.Maps
+      >
+    ): Promise<TestContractResult<null, XAlphTokenTypes.Maps>> => {
+      return testMethod(this, "claimUnstaked", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: XAlphTokenTypes.Fields,
+    asset?: Asset,
+    address?: string,
+    maps?: XAlphTokenTypes.Maps
+  ) {
+    return this.stateForTest_(initFields, asset, address, maps);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const XAlphToken = new Factory(
+  Contract.fromJson(
+    XAlphTokenContractJson,
+    "=52-2+91=2+c=1-1=2+e=1-1=2-2+8f=857-1+b=235-1+b=34+7a7e0214696e73657274206174206d617020706174683a2000=333-1+2=79-1+b=69-1+c=40+7a7e021472656d6f7665206174206d617020706174683a2000=70",
+    "8ded2201203cffd39adc32f6278f37f0ef1a543cf34872a159a1f36de68620d4",
+    types.AllStructs
+  )
+);
+registerContract(XAlphToken);
+
+// Use this class to interact with the blockchain
+export class XAlphTokenInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  maps = {
+    userActiveUnstakeVaults: new RalphMap<Address, HexString>(
+      XAlphToken.contract,
+      this.contractId,
+      "userActiveUnstakeVaults"
+    ),
+  };
+
+  async fetchState(): Promise<XAlphTokenTypes.State> {
+    return fetchContractState(XAlphToken, this);
+  }
+
+  async getContractEventsCurrentCount(): Promise<number> {
+    return getContractEventsCurrentCount(this.address);
+  }
+
+  subscribeStakedEvent(
+    options: EventSubscribeOptions<XAlphTokenTypes.StakedEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      XAlphToken.contract,
+      this,
+      options,
+      "Staked",
+      fromCount
+    );
+  }
+
+  subscribeUnstakeScheduledEvent(
+    options: EventSubscribeOptions<XAlphTokenTypes.UnstakeScheduledEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      XAlphToken.contract,
+      this,
+      options,
+      "UnstakeScheduled",
+      fromCount
+    );
+  }
+
+  subscribeAllEvents(
+    options: EventSubscribeOptions<
+      XAlphTokenTypes.StakedEvent | XAlphTokenTypes.UnstakeScheduledEvent
+    >,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvents(
+      XAlphToken.contract,
+      this,
+      options,
+      fromCount
+    );
+  }
+
+  view = {
+    getSymbol: async (
+      params?: XAlphTokenTypes.CallMethodParams<"getSymbol">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"getSymbol">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "getSymbol",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getName: async (
+      params?: XAlphTokenTypes.CallMethodParams<"getName">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"getName">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "getName",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getDecimals: async (
+      params?: XAlphTokenTypes.CallMethodParams<"getDecimals">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"getDecimals">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "getDecimals",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getTotalSupply: async (
+      params?: XAlphTokenTypes.CallMethodParams<"getTotalSupply">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"getTotalSupply">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "getTotalSupply",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    get: async (
+      params: XAlphTokenTypes.CallMethodParams<"get">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"get">> => {
+      return callMethod(XAlphToken, this, "get", params, getContractByCodeHash);
+    },
+    find: async (
+      params: XAlphTokenTypes.CallMethodParams<"find">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"find">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "find",
+        params,
+        getContractByCodeHash
+      );
+    },
+    remove: async (
+      params: XAlphTokenTypes.CallMethodParams<"remove">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"remove">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "remove",
+        params,
+        getContractByCodeHash
+      );
+    },
+    push: async (
+      params: XAlphTokenTypes.CallMethodParams<"push">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"push">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "push",
+        params,
+        getContractByCodeHash
+      );
+    },
+    binarySearch: async (
+      params: XAlphTokenTypes.CallMethodParams<"binarySearch">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"binarySearch">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "binarySearch",
+        params,
+        getContractByCodeHash
+      );
+    },
+    removeAt: async (
+      params: XAlphTokenTypes.CallMethodParams<"removeAt">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"removeAt">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "removeAt",
+        params,
+        getContractByCodeHash
+      );
+    },
+    size: async (
+      params: XAlphTokenTypes.CallMethodParams<"size">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"size">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "size",
+        params,
+        getContractByCodeHash
+      );
+    },
+    empty: async (
+      params?: XAlphTokenTypes.CallMethodParams<"empty">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"empty">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "empty",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    stake: async (
+      params: XAlphTokenTypes.CallMethodParams<"stake">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"stake">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "stake",
+        params,
+        getContractByCodeHash
+      );
+    },
+    startUnstake: async (
+      params: XAlphTokenTypes.CallMethodParams<"startUnstake">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"startUnstake">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "startUnstake",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getActiveUnstakeVaultIndexes: async (
+      params: XAlphTokenTypes.CallMethodParams<"getActiveUnstakeVaultIndexes">
+    ): Promise<
+      XAlphTokenTypes.CallMethodResult<"getActiveUnstakeVaultIndexes">
+    > => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "getActiveUnstakeVaultIndexes",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getClaimableAmount: async (
+      params: XAlphTokenTypes.CallMethodParams<"getClaimableAmount">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"getClaimableAmount">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "getClaimableAmount",
+        params,
+        getContractByCodeHash
+      );
+    },
+    claimUnstaked: async (
+      params: XAlphTokenTypes.CallMethodParams<"claimUnstaked">
+    ): Promise<XAlphTokenTypes.CallMethodResult<"claimUnstaked">> => {
+      return callMethod(
+        XAlphToken,
+        this,
+        "claimUnstaked",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    getSymbol: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"getSymbol">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"getSymbol">> => {
+      return signExecuteMethod(XAlphToken, this, "getSymbol", params);
+    },
+    getName: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"getName">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"getName">> => {
+      return signExecuteMethod(XAlphToken, this, "getName", params);
+    },
+    getDecimals: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"getDecimals">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"getDecimals">> => {
+      return signExecuteMethod(XAlphToken, this, "getDecimals", params);
+    },
+    getTotalSupply: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"getTotalSupply">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"getTotalSupply">> => {
+      return signExecuteMethod(XAlphToken, this, "getTotalSupply", params);
+    },
+    get: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"get">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"get">> => {
+      return signExecuteMethod(XAlphToken, this, "get", params);
+    },
+    find: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"find">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"find">> => {
+      return signExecuteMethod(XAlphToken, this, "find", params);
+    },
+    remove: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"remove">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"remove">> => {
+      return signExecuteMethod(XAlphToken, this, "remove", params);
+    },
+    push: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"push">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"push">> => {
+      return signExecuteMethod(XAlphToken, this, "push", params);
+    },
+    binarySearch: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"binarySearch">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"binarySearch">> => {
+      return signExecuteMethod(XAlphToken, this, "binarySearch", params);
+    },
+    removeAt: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"removeAt">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"removeAt">> => {
+      return signExecuteMethod(XAlphToken, this, "removeAt", params);
+    },
+    size: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"size">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"size">> => {
+      return signExecuteMethod(XAlphToken, this, "size", params);
+    },
+    empty: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"empty">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"empty">> => {
+      return signExecuteMethod(XAlphToken, this, "empty", params);
+    },
+    stake: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"stake">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"stake">> => {
+      return signExecuteMethod(XAlphToken, this, "stake", params);
+    },
+    startUnstake: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"startUnstake">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"startUnstake">> => {
+      return signExecuteMethod(XAlphToken, this, "startUnstake", params);
+    },
+    getActiveUnstakeVaultIndexes: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"getActiveUnstakeVaultIndexes">
+    ): Promise<
+      XAlphTokenTypes.SignExecuteMethodResult<"getActiveUnstakeVaultIndexes">
+    > => {
+      return signExecuteMethod(
+        XAlphToken,
+        this,
+        "getActiveUnstakeVaultIndexes",
+        params
+      );
+    },
+    getClaimableAmount: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"getClaimableAmount">
+    ): Promise<
+      XAlphTokenTypes.SignExecuteMethodResult<"getClaimableAmount">
+    > => {
+      return signExecuteMethod(XAlphToken, this, "getClaimableAmount", params);
+    },
+    claimUnstaked: async (
+      params: XAlphTokenTypes.SignExecuteMethodParams<"claimUnstaked">
+    ): Promise<XAlphTokenTypes.SignExecuteMethodResult<"claimUnstaked">> => {
+      return signExecuteMethod(XAlphToken, this, "claimUnstaked", params);
+    },
+  };
+
+  async multicall<Calls extends XAlphTokenTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<XAlphTokenTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends XAlphTokenTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<XAlphTokenTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | XAlphTokenTypes.MultiCallParams
+      | XAlphTokenTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      XAlphToken,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}