@alephium/powfi-sdk 0.0.1-rc.1

package/staking/artifacts/ts/TestDynamicSortedArrayForU256.ts

@@ -0,0 +1,516 @@
+/* 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 TestDynamicSortedArrayForU256ContractJson } from "../utils/TestDynamicSortedArrayForU256.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace TestDynamicSortedArrayForU256Types {
+  export type State = Omit<ContractState<any>, "fields">;
+
+  export interface CallMethodTable {
+    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>;
+    };
+  }
+  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 {
+    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;
+    };
+  }
+  export type SignExecuteMethodParams<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["params"];
+  export type SignExecuteMethodResult<T extends keyof SignExecuteMethodTable> =
+    SignExecuteMethodTable[T]["result"];
+}
+
+class Factory extends ContractFactory<
+  TestDynamicSortedArrayForU256Instance,
+  {}
+> {
+  encodeFields() {
+    return encodeContractFields({}, this.contract.fieldsSig, types.AllStructs);
+  }
+
+  consts = {
+    IntByteLength: BigInt("32"),
+    ErrorCode: {
+      InvalidArrayLength: BigInt("550"),
+      IndexOutOfBound: BigInt("551"),
+      InvalidByteVecLength: BigInt("552"),
+    },
+  };
+
+  at(address: string): TestDynamicSortedArrayForU256Instance {
+    return new TestDynamicSortedArrayForU256Instance(address);
+  }
+
+  tests = {
+    get: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<
+          never,
+          { array: HexString; index: bigint }
+        >,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "get", params, getContractByCodeHash);
+    },
+    find: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<
+          never,
+          { array: HexString; value: bigint }
+        >,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "find", params, getContractByCodeHash);
+    },
+    remove: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<
+          never,
+          { array: HexString; value: bigint }
+        >,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "remove", params, getContractByCodeHash);
+    },
+    push: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<
+          never,
+          { array: HexString; value: bigint }
+        >,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "push", params, getContractByCodeHash);
+    },
+    binarySearch: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<
+          never,
+          { array: HexString; value: bigint; left: bigint; right: bigint }
+        >,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "binarySearch", params, getContractByCodeHash);
+    },
+    removeAt: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<
+          never,
+          { array: HexString; index: bigint }
+        >,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "removeAt", params, getContractByCodeHash);
+    },
+    size: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<never, { array: HexString }>,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "size", params, getContractByCodeHash);
+    },
+    empty: async (
+      params?: Omit<
+        TestContractParamsWithoutMaps<never, never>,
+        "args" | "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(
+        this,
+        "empty",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  stateForTest(initFields: {}, asset?: Asset, address?: string) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const TestDynamicSortedArrayForU256 = new Factory(
+  Contract.fromJson(
+    TestDynamicSortedArrayForU256ContractJson,
+    "",
+    "86f2584a16af632c63b6c1ead625d4d53f11b9a3f2d465010085bd740be281d3",
+    types.AllStructs
+  )
+);
+registerContract(TestDynamicSortedArrayForU256);
+
+// Use this class to interact with the blockchain
+export class TestDynamicSortedArrayForU256Instance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<TestDynamicSortedArrayForU256Types.State> {
+    return fetchContractState(TestDynamicSortedArrayForU256, this);
+  }
+
+  view = {
+    get: async (
+      params: TestDynamicSortedArrayForU256Types.CallMethodParams<"get">
+    ): Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"get">> => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "get",
+        params,
+        getContractByCodeHash
+      );
+    },
+    find: async (
+      params: TestDynamicSortedArrayForU256Types.CallMethodParams<"find">
+    ): Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"find">> => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "find",
+        params,
+        getContractByCodeHash
+      );
+    },
+    remove: async (
+      params: TestDynamicSortedArrayForU256Types.CallMethodParams<"remove">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.CallMethodResult<"remove">
+    > => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "remove",
+        params,
+        getContractByCodeHash
+      );
+    },
+    push: async (
+      params: TestDynamicSortedArrayForU256Types.CallMethodParams<"push">
+    ): Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"push">> => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "push",
+        params,
+        getContractByCodeHash
+      );
+    },
+    binarySearch: async (
+      params: TestDynamicSortedArrayForU256Types.CallMethodParams<"binarySearch">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.CallMethodResult<"binarySearch">
+    > => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "binarySearch",
+        params,
+        getContractByCodeHash
+      );
+    },
+    removeAt: async (
+      params: TestDynamicSortedArrayForU256Types.CallMethodParams<"removeAt">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.CallMethodResult<"removeAt">
+    > => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "removeAt",
+        params,
+        getContractByCodeHash
+      );
+    },
+    size: async (
+      params: TestDynamicSortedArrayForU256Types.CallMethodParams<"size">
+    ): Promise<TestDynamicSortedArrayForU256Types.CallMethodResult<"size">> => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "size",
+        params,
+        getContractByCodeHash
+      );
+    },
+    empty: async (
+      params?: TestDynamicSortedArrayForU256Types.CallMethodParams<"empty">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.CallMethodResult<"empty">
+    > => {
+      return callMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "empty",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    get: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"get">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"get">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "get",
+        params
+      );
+    },
+    find: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"find">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"find">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "find",
+        params
+      );
+    },
+    remove: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"remove">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"remove">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "remove",
+        params
+      );
+    },
+    push: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"push">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"push">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "push",
+        params
+      );
+    },
+    binarySearch: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"binarySearch">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"binarySearch">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "binarySearch",
+        params
+      );
+    },
+    removeAt: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"removeAt">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"removeAt">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "removeAt",
+        params
+      );
+    },
+    size: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"size">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"size">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "size",
+        params
+      );
+    },
+    empty: async (
+      params: TestDynamicSortedArrayForU256Types.SignExecuteMethodParams<"empty">
+    ): Promise<
+      TestDynamicSortedArrayForU256Types.SignExecuteMethodResult<"empty">
+    > => {
+      return signExecuteMethod(
+        TestDynamicSortedArrayForU256,
+        this,
+        "empty",
+        params
+      );
+    },
+  };
+
+  async multicall<
+    Calls extends TestDynamicSortedArrayForU256Types.MultiCallParams
+  >(
+    calls: Calls
+  ): Promise<TestDynamicSortedArrayForU256Types.MultiCallResults<Calls>>;
+  async multicall<
+    Callss extends TestDynamicSortedArrayForU256Types.MultiCallParams[]
+  >(
+    callss: Narrow<Callss>
+  ): Promise<TestDynamicSortedArrayForU256Types.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | TestDynamicSortedArrayForU256Types.MultiCallParams
+      | TestDynamicSortedArrayForU256Types.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      TestDynamicSortedArrayForU256,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}