@alephium/powfi-sdk 0.0.1-rc.1

package/staking/artifacts/ts/RewardSharingVault.ts

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