@alephium/powfi-sdk 0.0.1-rc.1

package/staking/artifacts/examples/RewardSharingVault.ral.json

@@ -0,0 +1,253 @@
+{
+  "version": "v4.2.5",
+  "name": "RewardSharingVault",
+  "bytecode": "040740b74152423c4277428942c0431e01000208004054d3926b380bb417021602ce00774513287b140a5f5f6d61705f5f305f5f16004744cbc54c40270c0d0d140a5f5f6d61705f5f305f5f16004744cb01011703160116032a16000d0ece00010d1707170616062f132b7b16000005160316012a0c0e0c140a5f5f6d61705f5f305f5f16004744cb01024a15160116000d0ece00010d1705170416042f132b7bca140a5f5f6d61705f5f305f5f16004744b11601a001d20102a00016012aa10005160016015f01000205004046d365b06caeb417021602ce00774513287b140a5f5f6d61705f5f305f5f16004744cbc513297b0c0d0d140a5f5f6d61705f5f305f5f16004744cb010117031601160332132c7b160316012b17041600000516040c2f4c0aca0d0c140a5f5f6d61705f5f305f5f16004744cb01034a0a16040c0e0c140a5f5f6d61705f5f305f5f16004744cb0102a00016012ba10006160016015f0000030901409216020c3013415e7b160016010c0d3687170316001601371704160316043616031604314c020d4a010c36170516050c2f4c04160416022d02160216053313415f7b160016011602871706160516061604334c020d4a010c361705160416063617040c1602361602381707160216072d1702160416072d17040c16073616072d0d351707160416051607373917040f1602370e3a170816080e16021608373637170816080e16021608373637170816080e16021608373637170816080e16021608373637170816080e16021608373637170816080e160216083736371708160416083702010101030019d3fe1110a1a0000c33132a7bb417011601ce011600ac160013c40de0b6b3a7640000a00000021702a00116022aa10107160116005f010300010005d3a28b71d5b417001600000500020102001916000006170116010c334c081600ce011601ab08160016015fa0010d0e0c140a5f5f6d61705f5f305f5f16004744cb010201000105014024d31191a066140a5f5f6d61705f5f305f5f16004744cbc513297b0c0d0d140a5f5f6d61705f5f305f5f16004744cb1704160401010d0d0d1604010117021701a00116022b17031601160313c40de0b6b3a7640000000202",
+  "codeHash": "8beaa8b570543344d4352cf8534bbc7df4591b4ecda97cfc3c30bc28dca5adb9",
+  "fieldsSig": {
+    "names": [
+      "stakeVault",
+      "rewardTokenId",
+      "totalAmountStaked",
+      "rewardPerTokenCumulative"
+    ],
+    "types": [
+      "XAlphStakeVault",
+      "ByteVec",
+      "U256",
+      "U256"
+    ],
+    "isMutable": [
+      false,
+      false,
+      true,
+      true
+    ]
+  },
+  "eventsSig": [
+    {
+      "name": "Staked",
+      "fieldNames": [
+        "staker",
+        "amount"
+      ],
+      "fieldTypes": [
+        "Address",
+        "U256"
+      ]
+    },
+    {
+      "name": "Unstaked",
+      "fieldNames": [
+        "staker",
+        "amount"
+      ],
+      "fieldTypes": [
+        "Address",
+        "U256"
+      ]
+    },
+    {
+      "name": "RewardDeposited",
+      "fieldNames": [
+        "depositor",
+        "amount"
+      ],
+      "fieldTypes": [
+        "Address",
+        "U256"
+      ]
+    },
+    {
+      "name": "RewardClaimed",
+      "fieldNames": [
+        "staker",
+        "amount"
+      ],
+      "fieldTypes": [
+        "Address",
+        "U256"
+      ]
+    }
+  ],
+  "functions": [
+    {
+      "name": "onStake",
+      "paramNames": [
+        "user",
+        "newStakedAmount"
+      ],
+      "paramTypes": [
+        "Address",
+        "U256"
+      ],
+      "paramIsMutable": [
+        false,
+        false
+      ],
+      "returnTypes": []
+    },
+    {
+      "name": "onUnstake",
+      "paramNames": [
+        "user",
+        "unstakedAmount"
+      ],
+      "paramTypes": [
+        "Address",
+        "U256"
+      ],
+      "paramIsMutable": [
+        false,
+        false
+      ],
+      "returnTypes": []
+    },
+    {
+      "name": "mulDiv",
+      "paramNames": [
+        "a",
+        "b",
+        "denominator"
+      ],
+      "paramTypes": [
+        "U256",
+        "U256",
+        "U256"
+      ],
+      "paramIsMutable": [
+        false,
+        false,
+        true
+      ],
+      "returnTypes": [
+        "U256"
+      ]
+    },
+    {
+      "name": "depositReward",
+      "paramNames": [
+        "amount"
+      ],
+      "paramTypes": [
+        "U256"
+      ],
+      "paramIsMutable": [
+        false
+      ],
+      "returnTypes": []
+    },
+    {
+      "name": "claimPendingRewards",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": []
+    },
+    {
+      "name": "claimUserPendingRewards",
+      "paramNames": [
+        "user"
+      ],
+      "paramTypes": [
+        "Address"
+      ],
+      "paramIsMutable": [
+        false
+      ],
+      "returnTypes": []
+    },
+    {
+      "name": "getUserPendingRewards",
+      "paramNames": [
+        "user"
+      ],
+      "paramTypes": [
+        "Address"
+      ],
+      "paramIsMutable": [
+        false
+      ],
+      "returnTypes": [
+        "U256"
+      ]
+    }
+  ],
+  "constants": [
+    {
+      "name": "SCALING_FACTOR",
+      "value": {
+        "type": "U256",
+        "value": "1000000000000000000"
+      }
+    }
+  ],
+  "enums": [
+    {
+      "name": "FullMathError",
+      "fields": [
+        {
+          "name": "DivByZero",
+          "value": {
+            "type": "U256",
+            "value": "350"
+          }
+        },
+        {
+          "name": "MulDivOverflow",
+          "value": {
+            "type": "U256",
+            "value": "351"
+          }
+        }
+      ]
+    },
+    {
+      "name": "ErrorCodes",
+      "fields": [
+        {
+          "name": "StakeVaultCallerOnly",
+          "value": {
+            "type": "U256",
+            "value": "40"
+          }
+        },
+        {
+          "name": "NoUserRewardSharingInfo",
+          "value": {
+            "type": "U256",
+            "value": "41"
+          }
+        },
+        {
+          "name": "TotalStakedAmountIsZero",
+          "value": {
+            "type": "U256",
+            "value": "42"
+          }
+        },
+        {
+          "name": "InvalidStakedAmount",
+          "value": {
+            "type": "U256",
+            "value": "43"
+          }
+        },
+        {
+          "name": "InvalidUnstakedAmount",
+          "value": {
+            "type": "U256",
+            "value": "44"
+          }
+        }
+      ]
+    }
+  ],
+  "mapsSig": {
+    "names": [
+      "userRewardSharingInfo"
+    ],
+    "types": [
+      "Map[Address,UserRewardSharingInfo]"
+    ]
+  }
+}

package/staking/artifacts/structs.ral.json

@@ -0,0 +1,47 @@
+[
+  {
+    "name": "VoteInfo",
+    "fieldNames": [
+      "proposalVoted",
+      "amount"
+    ],
+    "fieldTypes": [
+      "U256",
+      "U256"
+    ],
+    "isMutable": [
+      true,
+      true
+    ]
+  },
+  {
+    "name": "UserRewardSharingInfo",
+    "fieldNames": [
+      "amount",
+      "rewardPerToken"
+    ],
+    "fieldTypes": [
+      "U256",
+      "U256"
+    ],
+    "isMutable": [
+      true,
+      true
+    ]
+  },
+  {
+    "name": "UserStakingInfo",
+    "fieldNames": [
+      "amount",
+      "connectedDapps"
+    ],
+    "fieldTypes": [
+      "U256",
+      "ByteVec"
+    ],
+    "isMutable": [
+      true,
+      true
+    ]
+  }
+]

package/staking/artifacts/ts/AlphUnstakeVault.ts

@@ -0,0 +1,354 @@
+/* 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 AlphUnstakeVaultContractJson } from "../AlphUnstakeVault.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace AlphUnstakeVaultTypes {
+  export type Fields = {
+    xalphToken: HexString;
+    unstakerAddress: Address;
+    totalUnstakeAmount: bigint;
+    unstakeStartTime: bigint;
+    unstakeDuration: bigint;
+    withdrawnAmount: bigint;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    mulDiv: {
+      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    getTotalUnstakeAmount: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<bigint>;
+    };
+    getClaimableAmount: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<bigint>;
+    };
+    claim: {
+      params: CallContractParams<{ amount: bigint }>;
+      result: CallContractResult<boolean>;
+    };
+    destroy: {
+      params: Omit<CallContractParams<{}>, "args">;
+      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 {
+    mulDiv: {
+      params: SignExecuteContractMethodParams<{
+        a: bigint;
+        b: bigint;
+        denominator: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getTotalUnstakeAmount: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    getClaimableAmount: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    claim: {
+      params: SignExecuteContractMethodParams<{ amount: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    destroy: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+  }
+  export type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["params"];
+  export type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["result"];
+}
+
+class Factory extends ContractFactory<
+  AlphUnstakeVaultInstance,
+  AlphUnstakeVaultTypes.Fields
+> {
+  encodeFields(fields: AlphUnstakeVaultTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  consts = {
+    FullMathError: { DivByZero: BigInt("350"), MulDivOverflow: BigInt("351") },
+    ErrorCodes: {
+      InvalidCaller: BigInt("20"),
+      InsufficientClaimableAmount: BigInt("21"),
+      InvalidUnstakeDuration: BigInt("22"),
+      InvalidTimestamp: BigInt("23"),
+    },
+  };
+
+  at(address: string): AlphUnstakeVaultInstance {
+    return new AlphUnstakeVaultInstance(address);
+  }
+
+  tests = {
+    mulDiv: async (
+      params: TestContractParamsWithoutMaps<
+        AlphUnstakeVaultTypes.Fields,
+        { a: bigint; b: bigint; denominator: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "mulDiv", params, getContractByCodeHash);
+    },
+    getTotalUnstakeAmount: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getTotalUnstakeAmount",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getClaimableAmount: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "getClaimableAmount",
+        params,
+        getContractByCodeHash
+      );
+    },
+    claim: async (
+      params: TestContractParamsWithoutMaps<
+        AlphUnstakeVaultTypes.Fields,
+        { amount: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<boolean>> => {
+      return testMethod(this, "claim", params, getContractByCodeHash);
+    },
+    destroy: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<AlphUnstakeVaultTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "destroy", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: AlphUnstakeVaultTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const AlphUnstakeVault = new Factory(
+  Contract.fromJson(
+    AlphUnstakeVaultContractJson,
+    "",
+    "5216c458f360d0f51f5e2109a760814ff97eab76f546adc835eb318c6cbc5256",
+    types.AllStructs
+  )
+);
+registerContract(AlphUnstakeVault);
+
+// Use this class to interact with the blockchain
+export class AlphUnstakeVaultInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<AlphUnstakeVaultTypes.State> {
+    return fetchContractState(AlphUnstakeVault, this);
+  }
+
+  view = {
+    mulDiv: async (
+      params: AlphUnstakeVaultTypes.CallMethodParams<"mulDiv">
+    ): Promise<AlphUnstakeVaultTypes.CallMethodResult<"mulDiv">> => {
+      return callMethod(
+        AlphUnstakeVault,
+        this,
+        "mulDiv",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getTotalUnstakeAmount: async (
+      params?: AlphUnstakeVaultTypes.CallMethodParams<"getTotalUnstakeAmount">
+    ): Promise<
+      AlphUnstakeVaultTypes.CallMethodResult<"getTotalUnstakeAmount">
+    > => {
+      return callMethod(
+        AlphUnstakeVault,
+        this,
+        "getTotalUnstakeAmount",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getClaimableAmount: async (
+      params?: AlphUnstakeVaultTypes.CallMethodParams<"getClaimableAmount">
+    ): Promise<
+      AlphUnstakeVaultTypes.CallMethodResult<"getClaimableAmount">
+    > => {
+      return callMethod(
+        AlphUnstakeVault,
+        this,
+        "getClaimableAmount",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    claim: async (
+      params: AlphUnstakeVaultTypes.CallMethodParams<"claim">
+    ): Promise<AlphUnstakeVaultTypes.CallMethodResult<"claim">> => {
+      return callMethod(
+        AlphUnstakeVault,
+        this,
+        "claim",
+        params,
+        getContractByCodeHash
+      );
+    },
+    destroy: async (
+      params?: AlphUnstakeVaultTypes.CallMethodParams<"destroy">
+    ): Promise<AlphUnstakeVaultTypes.CallMethodResult<"destroy">> => {
+      return callMethod(
+        AlphUnstakeVault,
+        this,
+        "destroy",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    mulDiv: async (
+      params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"mulDiv">
+    ): Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"mulDiv">> => {
+      return signExecuteMethod(AlphUnstakeVault, this, "mulDiv", params);
+    },
+    getTotalUnstakeAmount: async (
+      params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"getTotalUnstakeAmount">
+    ): Promise<
+      AlphUnstakeVaultTypes.SignExecuteMethodResult<"getTotalUnstakeAmount">
+    > => {
+      return signExecuteMethod(
+        AlphUnstakeVault,
+        this,
+        "getTotalUnstakeAmount",
+        params
+      );
+    },
+    getClaimableAmount: async (
+      params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"getClaimableAmount">
+    ): Promise<
+      AlphUnstakeVaultTypes.SignExecuteMethodResult<"getClaimableAmount">
+    > => {
+      return signExecuteMethod(
+        AlphUnstakeVault,
+        this,
+        "getClaimableAmount",
+        params
+      );
+    },
+    claim: async (
+      params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"claim">
+    ): Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"claim">> => {
+      return signExecuteMethod(AlphUnstakeVault, this, "claim", params);
+    },
+    destroy: async (
+      params: AlphUnstakeVaultTypes.SignExecuteMethodParams<"destroy">
+    ): Promise<AlphUnstakeVaultTypes.SignExecuteMethodResult<"destroy">> => {
+      return signExecuteMethod(AlphUnstakeVault, this, "destroy", params);
+    },
+  };
+
+  async multicall<Calls extends AlphUnstakeVaultTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<AlphUnstakeVaultTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends AlphUnstakeVaultTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<AlphUnstakeVaultTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | AlphUnstakeVaultTypes.MultiCallParams
+      | AlphUnstakeVaultTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      AlphUnstakeVault,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}