@alephium/powfi-sdk 0.0.1-rc.1

package/staking/artifacts/ts/TestMerkleProof.ts

@@ -0,0 +1,343 @@
+/* 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 TestMerkleProofContractJson } from "../utils/TestMerkleProof.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace TestMerkleProofTypes {
+  export type Fields = {
+    merkleRoot: HexString;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export type UpdateRootEvent = ContractEvent<{
+    newMerkleRoot: HexString;
+    updatedBy: Address;
+  }>;
+
+  export interface CallMethodTable {
+    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>;
+    };
+  }
+  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 {
+    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;
+    };
+  }
+  export type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["params"];
+  export type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["result"];
+}
+
+class Factory extends ContractFactory<
+  TestMerkleProofInstance,
+  TestMerkleProofTypes.Fields
+> {
+  encodeFields(fields: TestMerkleProofTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  eventIndex = { UpdateRoot: 0 };
+  consts = {
+    MerkleProofErrorCodes: {
+      InvalidProofSize: BigInt("11001"),
+      InvalidDataHash: BigInt("11002"),
+      InvalidMerkleRoot: BigInt("11003"),
+    },
+  };
+
+  at(address: string): TestMerkleProofInstance {
+    return new TestMerkleProofInstance(address);
+  }
+
+  tests = {
+    getMerkleRoot: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<TestMerkleProofTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "getMerkleRoot", params, getContractByCodeHash);
+    },
+    updateRoot: async (
+      params: TestContractParamsWithoutMaps<
+        TestMerkleProofTypes.Fields,
+        { newMerkleRoot: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "updateRoot", params, getContractByCodeHash);
+    },
+    verify: async (
+      params: TestContractParamsWithoutMaps<
+        TestMerkleProofTypes.Fields,
+        { proof: HexString; dataHash: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<boolean>> => {
+      return testMethod(this, "verify", params, getContractByCodeHash);
+    },
+    hashPair: async (
+      params: TestContractParamsWithoutMaps<
+        TestMerkleProofTypes.Fields,
+        { a: HexString; b: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "hashPair", params, getContractByCodeHash);
+    },
+    hash: async (
+      params: TestContractParamsWithoutMaps<
+        TestMerkleProofTypes.Fields,
+        { dataToHash: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "hash", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: TestMerkleProofTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const TestMerkleProof = new Factory(
+  Contract.fromJson(
+    TestMerkleProofContractJson,
+    "",
+    "a6d0eadb4c4fbe25c0155c0a2e31ba6cc7a993cd27b3f708c6af418af44a7c57",
+    types.AllStructs
+  )
+);
+registerContract(TestMerkleProof);
+
+// Use this class to interact with the blockchain
+export class TestMerkleProofInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<TestMerkleProofTypes.State> {
+    return fetchContractState(TestMerkleProof, this);
+  }
+
+  async getContractEventsCurrentCount(): Promise<number> {
+    return getContractEventsCurrentCount(this.address);
+  }
+
+  subscribeUpdateRootEvent(
+    options: EventSubscribeOptions<TestMerkleProofTypes.UpdateRootEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      TestMerkleProof.contract,
+      this,
+      options,
+      "UpdateRoot",
+      fromCount
+    );
+  }
+
+  view = {
+    getMerkleRoot: async (
+      params?: TestMerkleProofTypes.CallMethodParams<"getMerkleRoot">
+    ): Promise<TestMerkleProofTypes.CallMethodResult<"getMerkleRoot">> => {
+      return callMethod(
+        TestMerkleProof,
+        this,
+        "getMerkleRoot",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    updateRoot: async (
+      params: TestMerkleProofTypes.CallMethodParams<"updateRoot">
+    ): Promise<TestMerkleProofTypes.CallMethodResult<"updateRoot">> => {
+      return callMethod(
+        TestMerkleProof,
+        this,
+        "updateRoot",
+        params,
+        getContractByCodeHash
+      );
+    },
+    verify: async (
+      params: TestMerkleProofTypes.CallMethodParams<"verify">
+    ): Promise<TestMerkleProofTypes.CallMethodResult<"verify">> => {
+      return callMethod(
+        TestMerkleProof,
+        this,
+        "verify",
+        params,
+        getContractByCodeHash
+      );
+    },
+    hashPair: async (
+      params: TestMerkleProofTypes.CallMethodParams<"hashPair">
+    ): Promise<TestMerkleProofTypes.CallMethodResult<"hashPair">> => {
+      return callMethod(
+        TestMerkleProof,
+        this,
+        "hashPair",
+        params,
+        getContractByCodeHash
+      );
+    },
+    hash: async (
+      params: TestMerkleProofTypes.CallMethodParams<"hash">
+    ): Promise<TestMerkleProofTypes.CallMethodResult<"hash">> => {
+      return callMethod(
+        TestMerkleProof,
+        this,
+        "hash",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    getMerkleRoot: async (
+      params: TestMerkleProofTypes.SignExecuteMethodParams<"getMerkleRoot">
+    ): Promise<
+      TestMerkleProofTypes.SignExecuteMethodResult<"getMerkleRoot">
+    > => {
+      return signExecuteMethod(TestMerkleProof, this, "getMerkleRoot", params);
+    },
+    updateRoot: async (
+      params: TestMerkleProofTypes.SignExecuteMethodParams<"updateRoot">
+    ): Promise<TestMerkleProofTypes.SignExecuteMethodResult<"updateRoot">> => {
+      return signExecuteMethod(TestMerkleProof, this, "updateRoot", params);
+    },
+    verify: async (
+      params: TestMerkleProofTypes.SignExecuteMethodParams<"verify">
+    ): Promise<TestMerkleProofTypes.SignExecuteMethodResult<"verify">> => {
+      return signExecuteMethod(TestMerkleProof, this, "verify", params);
+    },
+    hashPair: async (
+      params: TestMerkleProofTypes.SignExecuteMethodParams<"hashPair">
+    ): Promise<TestMerkleProofTypes.SignExecuteMethodResult<"hashPair">> => {
+      return signExecuteMethod(TestMerkleProof, this, "hashPair", params);
+    },
+    hash: async (
+      params: TestMerkleProofTypes.SignExecuteMethodParams<"hash">
+    ): Promise<TestMerkleProofTypes.SignExecuteMethodResult<"hash">> => {
+      return signExecuteMethod(TestMerkleProof, this, "hash", params);
+    },
+  };
+
+  async multicall<Calls extends TestMerkleProofTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<TestMerkleProofTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends TestMerkleProofTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<TestMerkleProofTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | TestMerkleProofTypes.MultiCallParams
+      | TestMerkleProofTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      TestMerkleProof,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}