@alephium/powfi-sdk 0.0.1-rc.1

package/clmm/artifacts/ts/BitmapWord.ts

@@ -0,0 +1,337 @@
+/* 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 BitmapWordContractJson } from "../BitmapWord.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace BitmapWordTypes {
+  export type Fields = {
+    parent: Address;
+    value: bigint;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    mostSignificantBit: {
+      params: CallContractParams<{ x: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    leastSignificantBit: {
+      params: CallContractParams<{ x: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    flip: {
+      params: CallContractParams<{ tick: bigint }>;
+      result: CallContractResult<null>;
+    };
+    getNext: {
+      params: CallContractParams<{
+        compressed: bigint;
+        zeroForOne: boolean;
+        tickSpacing: bigint;
+      }>;
+      result: CallContractResult<[bigint, boolean]>;
+    };
+    getBitPos: {
+      params: CallContractParams<{ tick: bigint }>;
+      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 {
+    mostSignificantBit: {
+      params: SignExecuteContractMethodParams<{ x: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    leastSignificantBit: {
+      params: SignExecuteContractMethodParams<{ x: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    flip: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getNext: {
+      params: SignExecuteContractMethodParams<{
+        compressed: bigint;
+        zeroForOne: boolean;
+        tickSpacing: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getBitPos: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      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<
+  BitmapWordInstance,
+  BitmapWordTypes.Fields
+> {
+  encodeFields(fields: BitmapWordTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  consts = {
+    BitMathError: {
+      NoMostSignificantBit: BigInt("150"),
+      NoLeastSignificantBit: BigInt("151"),
+    },
+  };
+
+  at(address: string): BitmapWordInstance {
+    return new BitmapWordInstance(address);
+  }
+
+  tests = {
+    mostSignificantBit: async (
+      params: TestContractParamsWithoutMaps<
+        BitmapWordTypes.Fields,
+        { x: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "mostSignificantBit",
+        params,
+        getContractByCodeHash
+      );
+    },
+    leastSignificantBit: async (
+      params: TestContractParamsWithoutMaps<
+        BitmapWordTypes.Fields,
+        { x: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "leastSignificantBit",
+        params,
+        getContractByCodeHash
+      );
+    },
+    flip: async (
+      params: TestContractParamsWithoutMaps<
+        BitmapWordTypes.Fields,
+        { tick: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "flip", params, getContractByCodeHash);
+    },
+    getNext: async (
+      params: TestContractParamsWithoutMaps<
+        BitmapWordTypes.Fields,
+        { compressed: bigint; zeroForOne: boolean; tickSpacing: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, boolean]>> => {
+      return testMethod(this, "getNext", params, getContractByCodeHash);
+    },
+    getBitPos: async (
+      params: TestContractParamsWithoutMaps<
+        BitmapWordTypes.Fields,
+        { tick: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "getBitPos", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: BitmapWordTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const BitmapWord = new Factory(
+  Contract.fromJson(
+    BitmapWordContractJson,
+    "",
+    "69fd344eb51899a9bdc30ae94beeb2dcfeb2fc312d39116ebe9d208a55293edd",
+    types.AllStructs
+  )
+);
+registerContract(BitmapWord);
+
+// Use this class to interact with the blockchain
+export class BitmapWordInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<BitmapWordTypes.State> {
+    return fetchContractState(BitmapWord, this);
+  }
+
+  view = {
+    mostSignificantBit: async (
+      params: BitmapWordTypes.CallMethodParams<"mostSignificantBit">
+    ): Promise<BitmapWordTypes.CallMethodResult<"mostSignificantBit">> => {
+      return callMethod(
+        BitmapWord,
+        this,
+        "mostSignificantBit",
+        params,
+        getContractByCodeHash
+      );
+    },
+    leastSignificantBit: async (
+      params: BitmapWordTypes.CallMethodParams<"leastSignificantBit">
+    ): Promise<BitmapWordTypes.CallMethodResult<"leastSignificantBit">> => {
+      return callMethod(
+        BitmapWord,
+        this,
+        "leastSignificantBit",
+        params,
+        getContractByCodeHash
+      );
+    },
+    flip: async (
+      params: BitmapWordTypes.CallMethodParams<"flip">
+    ): Promise<BitmapWordTypes.CallMethodResult<"flip">> => {
+      return callMethod(
+        BitmapWord,
+        this,
+        "flip",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getNext: async (
+      params: BitmapWordTypes.CallMethodParams<"getNext">
+    ): Promise<BitmapWordTypes.CallMethodResult<"getNext">> => {
+      return callMethod(
+        BitmapWord,
+        this,
+        "getNext",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getBitPos: async (
+      params: BitmapWordTypes.CallMethodParams<"getBitPos">
+    ): Promise<BitmapWordTypes.CallMethodResult<"getBitPos">> => {
+      return callMethod(
+        BitmapWord,
+        this,
+        "getBitPos",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    mostSignificantBit: async (
+      params: BitmapWordTypes.SignExecuteMethodParams<"mostSignificantBit">
+    ): Promise<
+      BitmapWordTypes.SignExecuteMethodResult<"mostSignificantBit">
+    > => {
+      return signExecuteMethod(BitmapWord, this, "mostSignificantBit", params);
+    },
+    leastSignificantBit: async (
+      params: BitmapWordTypes.SignExecuteMethodParams<"leastSignificantBit">
+    ): Promise<
+      BitmapWordTypes.SignExecuteMethodResult<"leastSignificantBit">
+    > => {
+      return signExecuteMethod(BitmapWord, this, "leastSignificantBit", params);
+    },
+    flip: async (
+      params: BitmapWordTypes.SignExecuteMethodParams<"flip">
+    ): Promise<BitmapWordTypes.SignExecuteMethodResult<"flip">> => {
+      return signExecuteMethod(BitmapWord, this, "flip", params);
+    },
+    getNext: async (
+      params: BitmapWordTypes.SignExecuteMethodParams<"getNext">
+    ): Promise<BitmapWordTypes.SignExecuteMethodResult<"getNext">> => {
+      return signExecuteMethod(BitmapWord, this, "getNext", params);
+    },
+    getBitPos: async (
+      params: BitmapWordTypes.SignExecuteMethodParams<"getBitPos">
+    ): Promise<BitmapWordTypes.SignExecuteMethodResult<"getBitPos">> => {
+      return signExecuteMethod(BitmapWord, this, "getBitPos", params);
+    },
+  };
+
+  async multicall<Calls extends BitmapWordTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<BitmapWordTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends BitmapWordTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<BitmapWordTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | BitmapWordTypes.MultiCallParams
+      | BitmapWordTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      BitmapWord,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}

package/clmm/artifacts/ts/BitmapWordDeployer.ts

@@ -0,0 +1,164 @@
+/* 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 BitmapWordDeployerContractJson } from "../BitmapWordDeployer.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace BitmapWordDeployerTypes {
+  export type State = Omit<ContractState<any>, "fields">;
+
+  export interface CallMethodTable {
+    deploy: {
+      params: CallContractParams<{ payer: Address }>;
+      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 {
+    deploy: {
+      params: SignExecuteContractMethodParams<{ payer: Address }>;
+      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<BitmapWordDeployerInstance, {}> {
+  encodeFields() {
+    return encodeContractFields({}, this.contract.fieldsSig, types.AllStructs);
+  }
+
+  at(address: string): BitmapWordDeployerInstance {
+    return new BitmapWordDeployerInstance(address);
+  }
+
+  tests = {
+    deploy: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<never, { payer: Address }>,
+        "initialFields"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "deploy", 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 BitmapWordDeployer = new Factory(
+  Contract.fromJson(
+    BitmapWordDeployerContractJson,
+    "",
+    "082de32f22857e094db5658611a1d2ba23e792a7f23a548525e6de2784f2a70b",
+    types.AllStructs
+  )
+);
+registerContract(BitmapWordDeployer);
+
+// Use this class to interact with the blockchain
+export class BitmapWordDeployerInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<BitmapWordDeployerTypes.State> {
+    return fetchContractState(BitmapWordDeployer, this);
+  }
+
+  view = {
+    deploy: async (
+      params: BitmapWordDeployerTypes.CallMethodParams<"deploy">
+    ): Promise<BitmapWordDeployerTypes.CallMethodResult<"deploy">> => {
+      return callMethod(
+        BitmapWordDeployer,
+        this,
+        "deploy",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    deploy: async (
+      params: BitmapWordDeployerTypes.SignExecuteMethodParams<"deploy">
+    ): Promise<BitmapWordDeployerTypes.SignExecuteMethodResult<"deploy">> => {
+      return signExecuteMethod(BitmapWordDeployer, this, "deploy", params);
+    },
+  };
+
+  async multicall<Calls extends BitmapWordDeployerTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<BitmapWordDeployerTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends BitmapWordDeployerTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<BitmapWordDeployerTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | BitmapWordDeployerTypes.MultiCallParams
+      | BitmapWordDeployerTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      BitmapWordDeployer,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}