@alephium/powfi-sdk 0.0.1-rc.1

package/clmm/artifacts/ts/PoolUser.ts

@@ -0,0 +1,237 @@
+/* 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 PoolUserContractJson } from "../PoolUser.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace PoolUserTypes {
+  export type Fields = {
+    token0: HexString;
+    token1: HexString;
+    token2: HexString;
+    pool0: HexString;
+    pool1: HexString;
+    pool2: HexString;
+    pool3: HexString;
+    factory: HexString;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    deploy: {
+      params: CallContractParams<{
+        counter: bigint;
+        payer: Address;
+        pool_: HexString;
+        position_: HexString;
+        tick_: HexString;
+        word_: HexString;
+        factory_: HexString;
+        config_: HexString;
+        dexAccount_: HexString;
+      }>;
+      result: CallContractResult<
+        [
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          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<{
+        counter: bigint;
+        payer: Address;
+        pool_: HexString;
+        position_: HexString;
+        tick_: HexString;
+        word_: HexString;
+        factory_: HexString;
+        config_: HexString;
+        dexAccount_: 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<PoolUserInstance, PoolUserTypes.Fields> {
+  encodeFields(fields: PoolUserTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  at(address: string): PoolUserInstance {
+    return new PoolUserInstance(address);
+  }
+
+  tests = {
+    deploy: async (
+      params: TestContractParamsWithoutMaps<
+        PoolUserTypes.Fields,
+        {
+          counter: bigint;
+          payer: Address;
+          pool_: HexString;
+          position_: HexString;
+          tick_: HexString;
+          word_: HexString;
+          factory_: HexString;
+          config_: HexString;
+          dexAccount_: HexString;
+        }
+      >
+    ): Promise<
+      TestContractResultWithoutMaps<
+        [
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          HexString,
+          HexString
+        ]
+      >
+    > => {
+      return testMethod(this, "deploy", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: PoolUserTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const PoolUser = new Factory(
+  Contract.fromJson(
+    PoolUserContractJson,
+    "",
+    "9e1114eb366a5aaf1730e3b16068a672c09da46c4e5111267129c5a0bceeaa97",
+    types.AllStructs
+  )
+);
+registerContract(PoolUser);
+
+// Use this class to interact with the blockchain
+export class PoolUserInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<PoolUserTypes.State> {
+    return fetchContractState(PoolUser, this);
+  }
+
+  view = {
+    deploy: async (
+      params: PoolUserTypes.CallMethodParams<"deploy">
+    ): Promise<PoolUserTypes.CallMethodResult<"deploy">> => {
+      return callMethod(
+        PoolUser,
+        this,
+        "deploy",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    deploy: async (
+      params: PoolUserTypes.SignExecuteMethodParams<"deploy">
+    ): Promise<PoolUserTypes.SignExecuteMethodResult<"deploy">> => {
+      return signExecuteMethod(PoolUser, this, "deploy", params);
+    },
+  };
+
+  async multicall<Calls extends PoolUserTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<PoolUserTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends PoolUserTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<PoolUserTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | PoolUserTypes.MultiCallParams
+      | PoolUserTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      PoolUser,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}

package/clmm/artifacts/ts/Position.ts

@@ -0,0 +1,440 @@
+/* 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 PositionContractJson } from "../Position.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace PositionTypes {
+  export type Fields = {
+    parent: Address;
+    nftIndex: bigint;
+    liquidity: bigint;
+    growthsInside: [bigint, bigint, bigint];
+    tokensOwed: [bigint, bigint, bigint];
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    getTokenUri: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<HexString>;
+    };
+    getCollectionIndex: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<[HexString, bigint]>;
+    };
+    mulDiv: {
+      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    mulDivRoundingUp: {
+      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    update: {
+      params: CallContractParams<{
+        liquidityDelta: bigint;
+        growths: [bigint, bigint, bigint];
+      }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    deposit: {
+      params: CallContractParams<{ amount0: bigint; amount1: bigint }>;
+      result: CallContractResult<null>;
+    };
+    collect: {
+      params: CallContractParams<{ maxAmounts: [bigint, bigint, bigint] }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    getState: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<[bigint, [bigint, bigint, 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 {
+    getTokenUri: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    getCollectionIndex: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    mulDiv: {
+      params: SignExecuteContractMethodParams<{
+        a: bigint;
+        b: bigint;
+        denominator: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    mulDivRoundingUp: {
+      params: SignExecuteContractMethodParams<{
+        a: bigint;
+        b: bigint;
+        denominator: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    update: {
+      params: SignExecuteContractMethodParams<{
+        liquidityDelta: bigint;
+        growths: [bigint, bigint, bigint];
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    deposit: {
+      params: SignExecuteContractMethodParams<{
+        amount0: bigint;
+        amount1: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    collect: {
+      params: SignExecuteContractMethodParams<{
+        maxAmounts: [bigint, bigint, bigint];
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getState: {
+      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<PositionInstance, PositionTypes.Fields> {
+  encodeFields(fields: PositionTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  consts = {
+    FullMathError: { MulDivOverflow: BigInt("351") },
+    PositionError: { NotParent: BigInt("901") },
+  };
+
+  at(address: string): PositionInstance {
+    return new PositionInstance(address);
+  }
+
+  tests = {
+    getTokenUri: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<PositionTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "getTokenUri", params, getContractByCodeHash);
+    },
+    getCollectionIndex: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<PositionTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<[HexString, bigint]>> => {
+      return testMethod(
+        this,
+        "getCollectionIndex",
+        params,
+        getContractByCodeHash
+      );
+    },
+    mulDiv: async (
+      params: TestContractParamsWithoutMaps<
+        PositionTypes.Fields,
+        { a: bigint; b: bigint; denominator: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "mulDiv", params, getContractByCodeHash);
+    },
+    mulDivRoundingUp: async (
+      params: TestContractParamsWithoutMaps<
+        PositionTypes.Fields,
+        { a: bigint; b: bigint; denominator: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(
+        this,
+        "mulDivRoundingUp",
+        params,
+        getContractByCodeHash
+      );
+    },
+    update: async (
+      params: TestContractParamsWithoutMaps<
+        PositionTypes.Fields,
+        { liquidityDelta: bigint; growths: [bigint, bigint, bigint] }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(this, "update", params, getContractByCodeHash);
+    },
+    deposit: async (
+      params: TestContractParamsWithoutMaps<
+        PositionTypes.Fields,
+        { amount0: bigint; amount1: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "deposit", params, getContractByCodeHash);
+    },
+    collect: async (
+      params: TestContractParamsWithoutMaps<
+        PositionTypes.Fields,
+        { maxAmounts: [bigint, bigint, bigint] }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(this, "collect", params, getContractByCodeHash);
+    },
+    getState: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<PositionTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<
+      TestContractResultWithoutMaps<[bigint, [bigint, bigint, bigint]]>
+    > => {
+      return testMethod(this, "getState", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: PositionTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const Position = new Factory(
+  Contract.fromJson(
+    PositionContractJson,
+    "",
+    "893257ca0a6b91cb3976f1cdb74a6b56f8a9f0d54a8034e22e8281dd33c6f313",
+    types.AllStructs
+  )
+);
+registerContract(Position);
+
+// Use this class to interact with the blockchain
+export class PositionInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<PositionTypes.State> {
+    return fetchContractState(Position, this);
+  }
+
+  view = {
+    getTokenUri: async (
+      params?: PositionTypes.CallMethodParams<"getTokenUri">
+    ): Promise<PositionTypes.CallMethodResult<"getTokenUri">> => {
+      return callMethod(
+        Position,
+        this,
+        "getTokenUri",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getCollectionIndex: async (
+      params?: PositionTypes.CallMethodParams<"getCollectionIndex">
+    ): Promise<PositionTypes.CallMethodResult<"getCollectionIndex">> => {
+      return callMethod(
+        Position,
+        this,
+        "getCollectionIndex",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    mulDiv: async (
+      params: PositionTypes.CallMethodParams<"mulDiv">
+    ): Promise<PositionTypes.CallMethodResult<"mulDiv">> => {
+      return callMethod(
+        Position,
+        this,
+        "mulDiv",
+        params,
+        getContractByCodeHash
+      );
+    },
+    mulDivRoundingUp: async (
+      params: PositionTypes.CallMethodParams<"mulDivRoundingUp">
+    ): Promise<PositionTypes.CallMethodResult<"mulDivRoundingUp">> => {
+      return callMethod(
+        Position,
+        this,
+        "mulDivRoundingUp",
+        params,
+        getContractByCodeHash
+      );
+    },
+    update: async (
+      params: PositionTypes.CallMethodParams<"update">
+    ): Promise<PositionTypes.CallMethodResult<"update">> => {
+      return callMethod(
+        Position,
+        this,
+        "update",
+        params,
+        getContractByCodeHash
+      );
+    },
+    deposit: async (
+      params: PositionTypes.CallMethodParams<"deposit">
+    ): Promise<PositionTypes.CallMethodResult<"deposit">> => {
+      return callMethod(
+        Position,
+        this,
+        "deposit",
+        params,
+        getContractByCodeHash
+      );
+    },
+    collect: async (
+      params: PositionTypes.CallMethodParams<"collect">
+    ): Promise<PositionTypes.CallMethodResult<"collect">> => {
+      return callMethod(
+        Position,
+        this,
+        "collect",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getState: async (
+      params?: PositionTypes.CallMethodParams<"getState">
+    ): Promise<PositionTypes.CallMethodResult<"getState">> => {
+      return callMethod(
+        Position,
+        this,
+        "getState",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    getTokenUri: async (
+      params: PositionTypes.SignExecuteMethodParams<"getTokenUri">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"getTokenUri">> => {
+      return signExecuteMethod(Position, this, "getTokenUri", params);
+    },
+    getCollectionIndex: async (
+      params: PositionTypes.SignExecuteMethodParams<"getCollectionIndex">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"getCollectionIndex">> => {
+      return signExecuteMethod(Position, this, "getCollectionIndex", params);
+    },
+    mulDiv: async (
+      params: PositionTypes.SignExecuteMethodParams<"mulDiv">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"mulDiv">> => {
+      return signExecuteMethod(Position, this, "mulDiv", params);
+    },
+    mulDivRoundingUp: async (
+      params: PositionTypes.SignExecuteMethodParams<"mulDivRoundingUp">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"mulDivRoundingUp">> => {
+      return signExecuteMethod(Position, this, "mulDivRoundingUp", params);
+    },
+    update: async (
+      params: PositionTypes.SignExecuteMethodParams<"update">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"update">> => {
+      return signExecuteMethod(Position, this, "update", params);
+    },
+    deposit: async (
+      params: PositionTypes.SignExecuteMethodParams<"deposit">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"deposit">> => {
+      return signExecuteMethod(Position, this, "deposit", params);
+    },
+    collect: async (
+      params: PositionTypes.SignExecuteMethodParams<"collect">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"collect">> => {
+      return signExecuteMethod(Position, this, "collect", params);
+    },
+    getState: async (
+      params: PositionTypes.SignExecuteMethodParams<"getState">
+    ): Promise<PositionTypes.SignExecuteMethodResult<"getState">> => {
+      return signExecuteMethod(Position, this, "getState", params);
+    },
+  };
+
+  async multicall<Calls extends PositionTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<PositionTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends PositionTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<PositionTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | PositionTypes.MultiCallParams
+      | PositionTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      Position,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}