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

// Custom types for the contract
export namespace RewardSharingVaultTypes {
  export type Fields = {
    stakeVault: HexString;
    rewardTokenId: HexString;
    totalAmountStaked: bigint;
    rewardPerTokenCumulative: bigint;
  };

  export type State = ContractState<Fields>;

  export type StakedEvent = ContractEvent<{ staker: Address; amount: bigint }>;
  export type UnstakedEvent = ContractEvent<{
    staker: Address;
    amount: bigint;
  }>;
  export type RewardDepositedEvent = ContractEvent<{
    depositor: Address;
    amount: bigint;
  }>;
  export type RewardClaimedEvent = ContractEvent<{
    staker: Address;
    amount: bigint;
  }>;

  export interface CallMethodTable {
    onStake: {
      params: CallContractParams<{ user: Address; newStakedAmount: bigint }>;
      result: CallContractResult<null>;
    };
    onUnstake: {
      params: CallContractParams<{ user: Address; unstakedAmount: bigint }>;
      result: CallContractResult<null>;
    };
    mulDiv: {
      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
      result: CallContractResult<bigint>;
    };
    depositReward: {
      params: CallContractParams<{ amount: bigint }>;
      result: CallContractResult<null>;
    };
    claimPendingRewards: {
      params: Omit<CallContractParams<{}>, "args">;
      result: CallContractResult<null>;
    };
    claimUserPendingRewards: {
      params: CallContractParams<{ user: Address }>;
      result: CallContractResult<null>;
    };
    getUserPendingRewards: {
      params: CallContractParams<{ user: Address }>;
      result: CallContractResult<bigint>;
    };
  }
  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 {
    onStake: {
      params: SignExecuteContractMethodParams<{
        user: Address;
        newStakedAmount: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    onUnstake: {
      params: SignExecuteContractMethodParams<{
        user: Address;
        unstakedAmount: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    mulDiv: {
      params: SignExecuteContractMethodParams<{
        a: bigint;
        b: bigint;
        denominator: bigint;
      }>;
      result: SignExecuteScriptTxResult;
    };
    depositReward: {
      params: SignExecuteContractMethodParams<{ amount: bigint }>;
      result: SignExecuteScriptTxResult;
    };
    claimPendingRewards: {
      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
      result: SignExecuteScriptTxResult;
    };
    claimUserPendingRewards: {
      params: SignExecuteContractMethodParams<{ user: Address }>;
      result: SignExecuteScriptTxResult;
    };
    getUserPendingRewards: {
      params: SignExecuteContractMethodParams<{ user: Address }>;
      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 = {
    userRewardSharingInfo?: Map<Address, types.UserRewardSharingInfo>;
  };
}

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

  eventIndex = { Staked: 0, Unstaked: 1, RewardDeposited: 2, RewardClaimed: 3 };
  consts = {
    SCALING_FACTOR: BigInt("1000000000000000000"),
    FullMathError: { DivByZero: BigInt("350"), MulDivOverflow: BigInt("351") },
    ErrorCodes: {
      StakeVaultCallerOnly: BigInt("40"),
      NoUserRewardSharingInfo: BigInt("41"),
      TotalStakedAmountIsZero: BigInt("42"),
      InvalidStakedAmount: BigInt("43"),
      InvalidUnstakedAmount: BigInt("44"),
    },
  };

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

  tests = {
    onStake: async (
      params: TestContractParams<
        RewardSharingVaultTypes.Fields,
        { user: Address; newStakedAmount: bigint },
        RewardSharingVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>> => {
      return testMethod(this, "onStake", params, getContractByCodeHash);
    },
    onUnstake: async (
      params: TestContractParams<
        RewardSharingVaultTypes.Fields,
        { user: Address; unstakedAmount: bigint },
        RewardSharingVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>> => {
      return testMethod(this, "onUnstake", params, getContractByCodeHash);
    },
    mulDiv: async (
      params: TestContractParams<
        RewardSharingVaultTypes.Fields,
        { a: bigint; b: bigint; denominator: bigint },
        RewardSharingVaultTypes.Maps
      >
    ): Promise<TestContractResult<bigint, RewardSharingVaultTypes.Maps>> => {
      return testMethod(this, "mulDiv", params, getContractByCodeHash);
    },
    depositReward: async (
      params: TestContractParams<
        RewardSharingVaultTypes.Fields,
        { amount: bigint },
        RewardSharingVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>> => {
      return testMethod(this, "depositReward", params, getContractByCodeHash);
    },
    claimPendingRewards: async (
      params: Omit<
        TestContractParams<
          RewardSharingVaultTypes.Fields,
          never,
          RewardSharingVaultTypes.Maps
        >,
        "args"
      >
    ): Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>> => {
      return testMethod(
        this,
        "claimPendingRewards",
        params,
        getContractByCodeHash
      );
    },
    claimUserPendingRewards: async (
      params: TestContractParams<
        RewardSharingVaultTypes.Fields,
        { user: Address },
        RewardSharingVaultTypes.Maps
      >
    ): Promise<TestContractResult<null, RewardSharingVaultTypes.Maps>> => {
      return testMethod(
        this,
        "claimUserPendingRewards",
        params,
        getContractByCodeHash
      );
    },
    getUserPendingRewards: async (
      params: TestContractParams<
        RewardSharingVaultTypes.Fields,
        { user: Address },
        RewardSharingVaultTypes.Maps
      >
    ): Promise<TestContractResult<bigint, RewardSharingVaultTypes.Maps>> => {
      return testMethod(
        this,
        "getUserPendingRewards",
        params,
        getContractByCodeHash
      );
    },
  };

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

// Use this object to test and deploy the contract
export const RewardSharingVault = new Factory(
  Contract.fromJson(
    RewardSharingVaultContractJson,
    "=6-2+d0=2-2+8=1-3=2-2+6e=2-1+a=3-2+bb42f2=2-2+50=13-1+6=235-1+7=74+7a7e0214696e73657274206174206d617020706174683a2000=55-1+8=173-1+c=38+7a7e021472656d6f7665206174206d617020706174683a2000=1004",
    "ad1203de899174ecc3a6b2fdf1ea73664ad5ae8ae74b0113feb5404f15b96347",
    types.AllStructs
  )
);
registerContract(RewardSharingVault);

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

  maps = {
    userRewardSharingInfo: new RalphMap<Address, types.UserRewardSharingInfo>(
      RewardSharingVault.contract,
      this.contractId,
      "userRewardSharingInfo"
    ),
  };

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

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

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

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

  subscribeRewardDepositedEvent(
    options: EventSubscribeOptions<RewardSharingVaultTypes.RewardDepositedEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      RewardSharingVault.contract,
      this,
      options,
      "RewardDeposited",
      fromCount
    );
  }

  subscribeRewardClaimedEvent(
    options: EventSubscribeOptions<RewardSharingVaultTypes.RewardClaimedEvent>,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvent(
      RewardSharingVault.contract,
      this,
      options,
      "RewardClaimed",
      fromCount
    );
  }

  subscribeAllEvents(
    options: EventSubscribeOptions<
      | RewardSharingVaultTypes.StakedEvent
      | RewardSharingVaultTypes.UnstakedEvent
      | RewardSharingVaultTypes.RewardDepositedEvent
      | RewardSharingVaultTypes.RewardClaimedEvent
    >,
    fromCount?: number
  ): EventSubscription {
    return subscribeContractEvents(
      RewardSharingVault.contract,
      this,
      options,
      fromCount
    );
  }

  view = {
    onStake: async (
      params: RewardSharingVaultTypes.CallMethodParams<"onStake">
    ): Promise<RewardSharingVaultTypes.CallMethodResult<"onStake">> => {
      return callMethod(
        RewardSharingVault,
        this,
        "onStake",
        params,
        getContractByCodeHash
      );
    },
    onUnstake: async (
      params: RewardSharingVaultTypes.CallMethodParams<"onUnstake">
    ): Promise<RewardSharingVaultTypes.CallMethodResult<"onUnstake">> => {
      return callMethod(
        RewardSharingVault,
        this,
        "onUnstake",
        params,
        getContractByCodeHash
      );
    },
    mulDiv: async (
      params: RewardSharingVaultTypes.CallMethodParams<"mulDiv">
    ): Promise<RewardSharingVaultTypes.CallMethodResult<"mulDiv">> => {
      return callMethod(
        RewardSharingVault,
        this,
        "mulDiv",
        params,
        getContractByCodeHash
      );
    },
    depositReward: async (
      params: RewardSharingVaultTypes.CallMethodParams<"depositReward">
    ): Promise<RewardSharingVaultTypes.CallMethodResult<"depositReward">> => {
      return callMethod(
        RewardSharingVault,
        this,
        "depositReward",
        params,
        getContractByCodeHash
      );
    },
    claimPendingRewards: async (
      params?: RewardSharingVaultTypes.CallMethodParams<"claimPendingRewards">
    ): Promise<
      RewardSharingVaultTypes.CallMethodResult<"claimPendingRewards">
    > => {
      return callMethod(
        RewardSharingVault,
        this,
        "claimPendingRewards",
        params === undefined ? {} : params,
        getContractByCodeHash
      );
    },
    claimUserPendingRewards: async (
      params: RewardSharingVaultTypes.CallMethodParams<"claimUserPendingRewards">
    ): Promise<
      RewardSharingVaultTypes.CallMethodResult<"claimUserPendingRewards">
    > => {
      return callMethod(
        RewardSharingVault,
        this,
        "claimUserPendingRewards",
        params,
        getContractByCodeHash
      );
    },
    getUserPendingRewards: async (
      params: RewardSharingVaultTypes.CallMethodParams<"getUserPendingRewards">
    ): Promise<
      RewardSharingVaultTypes.CallMethodResult<"getUserPendingRewards">
    > => {
      return callMethod(
        RewardSharingVault,
        this,
        "getUserPendingRewards",
        params,
        getContractByCodeHash
      );
    },
  };

  transact = {
    onStake: async (
      params: RewardSharingVaultTypes.SignExecuteMethodParams<"onStake">
    ): Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"onStake">> => {
      return signExecuteMethod(RewardSharingVault, this, "onStake", params);
    },
    onUnstake: async (
      params: RewardSharingVaultTypes.SignExecuteMethodParams<"onUnstake">
    ): Promise<
      RewardSharingVaultTypes.SignExecuteMethodResult<"onUnstake">
    > => {
      return signExecuteMethod(RewardSharingVault, this, "onUnstake", params);
    },
    mulDiv: async (
      params: RewardSharingVaultTypes.SignExecuteMethodParams<"mulDiv">
    ): Promise<RewardSharingVaultTypes.SignExecuteMethodResult<"mulDiv">> => {
      return signExecuteMethod(RewardSharingVault, this, "mulDiv", params);
    },
    depositReward: async (
      params: RewardSharingVaultTypes.SignExecuteMethodParams<"depositReward">
    ): Promise<
      RewardSharingVaultTypes.SignExecuteMethodResult<"depositReward">
    > => {
      return signExecuteMethod(
        RewardSharingVault,
        this,
        "depositReward",
        params
      );
    },
    claimPendingRewards: async (
      params: RewardSharingVaultTypes.SignExecuteMethodParams<"claimPendingRewards">
    ): Promise<
      RewardSharingVaultTypes.SignExecuteMethodResult<"claimPendingRewards">
    > => {
      return signExecuteMethod(
        RewardSharingVault,
        this,
        "claimPendingRewards",
        params
      );
    },
    claimUserPendingRewards: async (
      params: RewardSharingVaultTypes.SignExecuteMethodParams<"claimUserPendingRewards">
    ): Promise<
      RewardSharingVaultTypes.SignExecuteMethodResult<"claimUserPendingRewards">
    > => {
      return signExecuteMethod(
        RewardSharingVault,
        this,
        "claimUserPendingRewards",
        params
      );
    },
    getUserPendingRewards: async (
      params: RewardSharingVaultTypes.SignExecuteMethodParams<"getUserPendingRewards">
    ): Promise<
      RewardSharingVaultTypes.SignExecuteMethodResult<"getUserPendingRewards">
    > => {
      return signExecuteMethod(
        RewardSharingVault,
        this,
        "getUserPendingRewards",
        params
      );
    },
  };

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