@alephium/powfi-sdk 0.0.1-rc.1

package/clmm/artifacts/ts/TickBitmapTest.ts

@@ -0,0 +1,512 @@
+/* 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 TickBitmapTestContractJson } from "../TickBitmapTest.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace TickBitmapTestTypes {
+  export type Fields = {
+    wordTemplate: HexString;
+    tickSpacing: bigint;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    wordPath: {
+      params: CallContractParams<{ compressed: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    getWord: {
+      params: CallContractParams<{ compressed: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    getWordOrTemplate: {
+      params: CallContractParams<{ compressed: bigint }>;
+      result: CallContractResult<HexString>;
+    };
+    flipTick: {
+      params: CallContractParams<{ tick: bigint }>;
+      result: CallContractResult<null>;
+    };
+    nextInitializedTickWithinOneWord: {
+      params: CallContractParams<{ tick: bigint; zeroForOne: boolean }>;
+      result: CallContractResult<[bigint, boolean]>;
+    };
+    positionPath: {
+      params: CallContractParams<{
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    positionContractId: {
+      params: CallContractParams<{
+        pool: HexString;
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    deploy: {
+      params: CallContractParams<{
+        payer: Address;
+        word: HexString;
+        ts: bigint;
+      }>;
+      result: CallContractResult<HexString>;
+    };
+    flipTick_: {
+      params: CallContractParams<{ tick: bigint }>;
+      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 {
+    wordPath: {
+      params: SignExecuteContractMethodParams<{ compressed: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getWord: {
+      params: SignExecuteContractMethodParams<{ compressed: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getWordOrTemplate: {
+      params: SignExecuteContractMethodParams<{ compressed: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    flipTick: {
+      params: SignExecuteContractMethodParams<{ tick: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    nextInitializedTickWithinOneWord: {
+      params: SignExecuteContractMethodParams<{
+        tick: bigint;
+        zeroForOne: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    positionPath: {
+      params: SignExecuteContractMethodParams<{
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    positionContractId: {
+      params: SignExecuteContractMethodParams<{
+        pool: HexString;
+        o: Address;
+        tickLower: bigint;
+        tickUpper: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    deploy: {
+      params: SignExecuteContractMethodParams<{
+        payer: Address;
+        word: HexString;
+        ts: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    flipTick_: {
+      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<
+  TickBitmapTestInstance,
+  TickBitmapTestTypes.Fields
+> {
+  encodeFields(fields: TickBitmapTestTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  consts = {
+    TickBitmapError: { TickNotAligned: BigInt("301") },
+    PathPrefixes: {
+      Tick: BigInt("0"),
+      Position: BigInt("1"),
+      Word: BigInt("2"),
+    },
+  };
+
+  at(address: string): TickBitmapTestInstance {
+    return new TickBitmapTestInstance(address);
+  }
+
+  tests = {
+    wordPath: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { compressed: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "wordPath", params, getContractByCodeHash);
+    },
+    getWord: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { compressed: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "getWord", params, getContractByCodeHash);
+    },
+    getWordOrTemplate: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { compressed: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(
+        this,
+        "getWordOrTemplate",
+        params,
+        getContractByCodeHash
+      );
+    },
+    flipTick: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { tick: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "flipTick", params, getContractByCodeHash);
+    },
+    nextInitializedTickWithinOneWord: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { tick: bigint; zeroForOne: boolean }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, boolean]>> => {
+      return testMethod(
+        this,
+        "nextInitializedTickWithinOneWord",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionPath: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { o: Address; tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "positionPath", params, getContractByCodeHash);
+    },
+    positionContractId: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { pool: HexString; o: Address; tickLower: bigint; tickUpper: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(
+        this,
+        "positionContractId",
+        params,
+        getContractByCodeHash
+      );
+    },
+    deploy: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { payer: Address; word: HexString; ts: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "deploy", params, getContractByCodeHash);
+    },
+    flipTick_: async (
+      params: TestContractParamsWithoutMaps<
+        TickBitmapTestTypes.Fields,
+        { tick: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "flipTick_", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: TickBitmapTestTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const TickBitmapTest = new Factory(
+  Contract.fromJson(
+    TickBitmapTestContractJson,
+    "",
+    "5cb6cce5c5b8adb88a18a993227d51465e3e54b5a34936cafc51100725724b54",
+    types.AllStructs
+  )
+);
+registerContract(TickBitmapTest);
+
+// Use this class to interact with the blockchain
+export class TickBitmapTestInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<TickBitmapTestTypes.State> {
+    return fetchContractState(TickBitmapTest, this);
+  }
+
+  view = {
+    wordPath: async (
+      params: TickBitmapTestTypes.CallMethodParams<"wordPath">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"wordPath">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "wordPath",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getWord: async (
+      params: TickBitmapTestTypes.CallMethodParams<"getWord">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"getWord">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "getWord",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getWordOrTemplate: async (
+      params: TickBitmapTestTypes.CallMethodParams<"getWordOrTemplate">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"getWordOrTemplate">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "getWordOrTemplate",
+        params,
+        getContractByCodeHash
+      );
+    },
+    flipTick: async (
+      params: TickBitmapTestTypes.CallMethodParams<"flipTick">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"flipTick">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "flipTick",
+        params,
+        getContractByCodeHash
+      );
+    },
+    nextInitializedTickWithinOneWord: async (
+      params: TickBitmapTestTypes.CallMethodParams<"nextInitializedTickWithinOneWord">
+    ): Promise<
+      TickBitmapTestTypes.CallMethodResult<"nextInitializedTickWithinOneWord">
+    > => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "nextInitializedTickWithinOneWord",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionPath: async (
+      params: TickBitmapTestTypes.CallMethodParams<"positionPath">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"positionPath">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "positionPath",
+        params,
+        getContractByCodeHash
+      );
+    },
+    positionContractId: async (
+      params: TickBitmapTestTypes.CallMethodParams<"positionContractId">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"positionContractId">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "positionContractId",
+        params,
+        getContractByCodeHash
+      );
+    },
+    deploy: async (
+      params: TickBitmapTestTypes.CallMethodParams<"deploy">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"deploy">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "deploy",
+        params,
+        getContractByCodeHash
+      );
+    },
+    flipTick_: async (
+      params: TickBitmapTestTypes.CallMethodParams<"flipTick_">
+    ): Promise<TickBitmapTestTypes.CallMethodResult<"flipTick_">> => {
+      return callMethod(
+        TickBitmapTest,
+        this,
+        "flipTick_",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    wordPath: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"wordPath">
+    ): Promise<TickBitmapTestTypes.SignExecuteMethodResult<"wordPath">> => {
+      return signExecuteMethod(TickBitmapTest, this, "wordPath", params);
+    },
+    getWord: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"getWord">
+    ): Promise<TickBitmapTestTypes.SignExecuteMethodResult<"getWord">> => {
+      return signExecuteMethod(TickBitmapTest, this, "getWord", params);
+    },
+    getWordOrTemplate: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"getWordOrTemplate">
+    ): Promise<
+      TickBitmapTestTypes.SignExecuteMethodResult<"getWordOrTemplate">
+    > => {
+      return signExecuteMethod(
+        TickBitmapTest,
+        this,
+        "getWordOrTemplate",
+        params
+      );
+    },
+    flipTick: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"flipTick">
+    ): Promise<TickBitmapTestTypes.SignExecuteMethodResult<"flipTick">> => {
+      return signExecuteMethod(TickBitmapTest, this, "flipTick", params);
+    },
+    nextInitializedTickWithinOneWord: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"nextInitializedTickWithinOneWord">
+    ): Promise<
+      TickBitmapTestTypes.SignExecuteMethodResult<"nextInitializedTickWithinOneWord">
+    > => {
+      return signExecuteMethod(
+        TickBitmapTest,
+        this,
+        "nextInitializedTickWithinOneWord",
+        params
+      );
+    },
+    positionPath: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"positionPath">
+    ): Promise<TickBitmapTestTypes.SignExecuteMethodResult<"positionPath">> => {
+      return signExecuteMethod(TickBitmapTest, this, "positionPath", params);
+    },
+    positionContractId: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"positionContractId">
+    ): Promise<
+      TickBitmapTestTypes.SignExecuteMethodResult<"positionContractId">
+    > => {
+      return signExecuteMethod(
+        TickBitmapTest,
+        this,
+        "positionContractId",
+        params
+      );
+    },
+    deploy: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"deploy">
+    ): Promise<TickBitmapTestTypes.SignExecuteMethodResult<"deploy">> => {
+      return signExecuteMethod(TickBitmapTest, this, "deploy", params);
+    },
+    flipTick_: async (
+      params: TickBitmapTestTypes.SignExecuteMethodParams<"flipTick_">
+    ): Promise<TickBitmapTestTypes.SignExecuteMethodResult<"flipTick_">> => {
+      return signExecuteMethod(TickBitmapTest, this, "flipTick_", params);
+    },
+  };
+
+  async multicall<Calls extends TickBitmapTestTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<TickBitmapTestTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends TickBitmapTestTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<TickBitmapTestTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | TickBitmapTestTypes.MultiCallParams
+      | TickBitmapTestTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      TickBitmapTest,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}

package/clmm/artifacts/ts/constants.ts

@@ -0,0 +1,17 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export const MIN_TICK = BigInt("-887272");
+export const MAX_TICK = BigInt("887272");
+export const MIN_SQRT_RATIO = BigInt("4295128739");
+export const MAX_SQRT_RATIO = BigInt(
+  "1461446703485210103287273052203988822378723970342"
+);
+export const Q128 = BigInt("340282366920938463463374607431768211456");
+export const U128_MAX = BigInt("340282366920938463463374607431768211455");
+export const Q64 = BigInt("18446744073709551616");
+export const Q32 = BigInt("4294967296");
+export const Q96 = BigInt("79228162514264337593543950336");
+export const Q160 = BigInt("1461501637330902918203684832716283019655932542976");
+export const MAX_REWARDS = BigInt("3");

package/clmm/artifacts/ts/contracts.ts

@@ -0,0 +1,26 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import { Contract, ContractFactory } from "@alephium/web3";
+
+let contracts: ContractFactory<any>[] | undefined = undefined;
+
+export function getAllContracts(): ContractFactory<any>[] {
+  return contracts ?? [];
+}
+
+export function registerContract(factory: ContractFactory<any>) {
+  if (contracts === undefined) {
+    contracts = [factory];
+  } else {
+    contracts.push(factory);
+  }
+}
+export function getContractByCodeHash(codeHash: string): Contract {
+  const c = contracts?.find((c) => c.contract.hasCodeHash(codeHash));
+  if (c === undefined) {
+    throw new Error("Unknown code with code hash: " + codeHash);
+  }
+  return c.contract;
+}