@alephium/powfi-sdk 0.0.1-rc.1

package/clmm/artifacts/ts/TestToken.ts

@@ -0,0 +1,277 @@
+/* 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 TestTokenContractJson } from "../TestToken.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace TestTokenTypes {
+  export type Fields = {
+    symbol: HexString;
+    name: HexString;
+    decimals: bigint;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    getSymbol: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<HexString>;
+    };
+    getName: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<HexString>;
+    };
+    getDecimals: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<bigint>;
+    };
+    getTotalSupply: {
+      params: Omit<CallContractParams<{}>, "args">;
+      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 {
+    getSymbol: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    getName: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    getDecimals: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    getTotalSupply: {
+      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<
+  TestTokenInstance,
+  TestTokenTypes.Fields
+> {
+  encodeFields(fields: TestTokenTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  at(address: string): TestTokenInstance {
+    return new TestTokenInstance(address);
+  }
+
+  tests = {
+    getSymbol: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "getSymbol", params, getContractByCodeHash);
+    },
+    getName: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(this, "getName", params, getContractByCodeHash);
+    },
+    getDecimals: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "getDecimals", params, getContractByCodeHash);
+    },
+    getTotalSupply: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<TestTokenTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "getTotalSupply", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: TestTokenTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const TestToken = new Factory(
+  Contract.fromJson(
+    TestTokenContractJson,
+    "",
+    "32d99ee24650d37c7111a9cc02ed2694b608e2d1b52301d27c6b28abc9ba94e9",
+    types.AllStructs
+  )
+);
+registerContract(TestToken);
+
+// Use this class to interact with the blockchain
+export class TestTokenInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<TestTokenTypes.State> {
+    return fetchContractState(TestToken, this);
+  }
+
+  view = {
+    getSymbol: async (
+      params?: TestTokenTypes.CallMethodParams<"getSymbol">
+    ): Promise<TestTokenTypes.CallMethodResult<"getSymbol">> => {
+      return callMethod(
+        TestToken,
+        this,
+        "getSymbol",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getName: async (
+      params?: TestTokenTypes.CallMethodParams<"getName">
+    ): Promise<TestTokenTypes.CallMethodResult<"getName">> => {
+      return callMethod(
+        TestToken,
+        this,
+        "getName",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getDecimals: async (
+      params?: TestTokenTypes.CallMethodParams<"getDecimals">
+    ): Promise<TestTokenTypes.CallMethodResult<"getDecimals">> => {
+      return callMethod(
+        TestToken,
+        this,
+        "getDecimals",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    getTotalSupply: async (
+      params?: TestTokenTypes.CallMethodParams<"getTotalSupply">
+    ): Promise<TestTokenTypes.CallMethodResult<"getTotalSupply">> => {
+      return callMethod(
+        TestToken,
+        this,
+        "getTotalSupply",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    getSymbol: async (
+      params: TestTokenTypes.SignExecuteMethodParams<"getSymbol">
+    ): Promise<TestTokenTypes.SignExecuteMethodResult<"getSymbol">> => {
+      return signExecuteMethod(TestToken, this, "getSymbol", params);
+    },
+    getName: async (
+      params: TestTokenTypes.SignExecuteMethodParams<"getName">
+    ): Promise<TestTokenTypes.SignExecuteMethodResult<"getName">> => {
+      return signExecuteMethod(TestToken, this, "getName", params);
+    },
+    getDecimals: async (
+      params: TestTokenTypes.SignExecuteMethodParams<"getDecimals">
+    ): Promise<TestTokenTypes.SignExecuteMethodResult<"getDecimals">> => {
+      return signExecuteMethod(TestToken, this, "getDecimals", params);
+    },
+    getTotalSupply: async (
+      params: TestTokenTypes.SignExecuteMethodParams<"getTotalSupply">
+    ): Promise<TestTokenTypes.SignExecuteMethodResult<"getTotalSupply">> => {
+      return signExecuteMethod(TestToken, this, "getTotalSupply", params);
+    },
+  };
+
+  async multicall<Calls extends TestTokenTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<TestTokenTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends TestTokenTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<TestTokenTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | TestTokenTypes.MultiCallParams
+      | TestTokenTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      TestToken,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}

package/clmm/artifacts/ts/Tick.ts

@@ -0,0 +1,351 @@
+/* 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 TickContractJson } from "../Tick.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+import * as types from "./types";
+
+// Custom types for the contract
+export namespace TickTypes {
+  export type Fields = {
+    parent: Address;
+    tick: bigint;
+    liquidityGross: bigint;
+    liquidityNet: bigint;
+    feeGrowthsOutside: [bigint, bigint, bigint];
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    update: {
+      params: CallContractParams<{
+        maxLiquidity: bigint;
+        liquidityDelta: bigint;
+        upper: boolean;
+      }>;
+      result: CallContractResult<boolean>;
+    };
+    feeGrowthBelow: {
+      params: CallContractParams<{
+        tickCurrent: bigint;
+        globalGrowths: [bigint, bigint, bigint];
+      }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    feeGrowthAbove: {
+      params: CallContractParams<{
+        tickCurrent: bigint;
+        globalGrowths: [bigint, bigint, bigint];
+      }>;
+      result: CallContractResult<[bigint, bigint, bigint]>;
+    };
+    clear: {
+      params: CallContractParams<{ payer: Address }>;
+      result: CallContractResult<null>;
+    };
+    cross: {
+      params: CallContractParams<{
+        globalGrowths: [bigint, bigint, bigint];
+        zeroForOne: boolean;
+        feeGrowthGlobalX128: bigint;
+      }>;
+      result: CallContractResult<bigint>;
+    };
+    getLiquidityNet: {
+      params: Omit<CallContractParams<{}>, "args">;
+      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 {
+    update: {
+      params: SignExecuteContractMethodParams<{
+        maxLiquidity: bigint;
+        liquidityDelta: bigint;
+        upper: boolean;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    feeGrowthBelow: {
+      params: SignExecuteContractMethodParams<{
+        tickCurrent: bigint;
+        globalGrowths: [bigint, bigint, bigint];
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    feeGrowthAbove: {
+      params: SignExecuteContractMethodParams<{
+        tickCurrent: bigint;
+        globalGrowths: [bigint, bigint, bigint];
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    clear: {
+      params: SignExecuteContractMethodParams<{ payer: Address }>;
+      result: SignExecuteScriptTxResult;
+    };
+    cross: {
+      params: SignExecuteContractMethodParams<{
+        globalGrowths: [bigint, bigint, bigint];
+        zeroForOne: boolean;
+        feeGrowthGlobalX128: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getLiquidityNet: {
+      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<TickInstance, TickTypes.Fields> {
+  encodeFields(fields: TickTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      types.AllStructs
+    );
+  }
+
+  consts = {
+    TickError: {
+      NotParent: BigInt("801"),
+      LO: BigInt("802"),
+      LS: BigInt("803"),
+    },
+  };
+
+  at(address: string): TickInstance {
+    return new TickInstance(address);
+  }
+
+  tests = {
+    update: async (
+      params: TestContractParamsWithoutMaps<
+        TickTypes.Fields,
+        { maxLiquidity: bigint; liquidityDelta: bigint; upper: boolean }
+      >
+    ): Promise<TestContractResultWithoutMaps<boolean>> => {
+      return testMethod(this, "update", params, getContractByCodeHash);
+    },
+    feeGrowthBelow: async (
+      params: TestContractParamsWithoutMaps<
+        TickTypes.Fields,
+        { tickCurrent: bigint; globalGrowths: [bigint, bigint, bigint] }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(this, "feeGrowthBelow", params, getContractByCodeHash);
+    },
+    feeGrowthAbove: async (
+      params: TestContractParamsWithoutMaps<
+        TickTypes.Fields,
+        { tickCurrent: bigint; globalGrowths: [bigint, bigint, bigint] }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint, bigint]>> => {
+      return testMethod(this, "feeGrowthAbove", params, getContractByCodeHash);
+    },
+    clear: async (
+      params: TestContractParamsWithoutMaps<
+        TickTypes.Fields,
+        { payer: Address }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "clear", params, getContractByCodeHash);
+    },
+    cross: async (
+      params: TestContractParamsWithoutMaps<
+        TickTypes.Fields,
+        {
+          globalGrowths: [bigint, bigint, bigint];
+          zeroForOne: boolean;
+          feeGrowthGlobalX128: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "cross", params, getContractByCodeHash);
+    },
+    getLiquidityNet: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<TickTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "getLiquidityNet", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(initFields: TickTypes.Fields, asset?: Asset, address?: string) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const Tick = new Factory(
+  Contract.fromJson(
+    TickContractJson,
+    "",
+    "1373551ca890d886980b8d33277d7ed7a2c9f7665d77a1e893a1f2554d10d4b1",
+    types.AllStructs
+  )
+);
+registerContract(Tick);
+
+// Use this class to interact with the blockchain
+export class TickInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<TickTypes.State> {
+    return fetchContractState(Tick, this);
+  }
+
+  view = {
+    update: async (
+      params: TickTypes.CallMethodParams<"update">
+    ): Promise<TickTypes.CallMethodResult<"update">> => {
+      return callMethod(Tick, this, "update", params, getContractByCodeHash);
+    },
+    feeGrowthBelow: async (
+      params: TickTypes.CallMethodParams<"feeGrowthBelow">
+    ): Promise<TickTypes.CallMethodResult<"feeGrowthBelow">> => {
+      return callMethod(
+        Tick,
+        this,
+        "feeGrowthBelow",
+        params,
+        getContractByCodeHash
+      );
+    },
+    feeGrowthAbove: async (
+      params: TickTypes.CallMethodParams<"feeGrowthAbove">
+    ): Promise<TickTypes.CallMethodResult<"feeGrowthAbove">> => {
+      return callMethod(
+        Tick,
+        this,
+        "feeGrowthAbove",
+        params,
+        getContractByCodeHash
+      );
+    },
+    clear: async (
+      params: TickTypes.CallMethodParams<"clear">
+    ): Promise<TickTypes.CallMethodResult<"clear">> => {
+      return callMethod(Tick, this, "clear", params, getContractByCodeHash);
+    },
+    cross: async (
+      params: TickTypes.CallMethodParams<"cross">
+    ): Promise<TickTypes.CallMethodResult<"cross">> => {
+      return callMethod(Tick, this, "cross", params, getContractByCodeHash);
+    },
+    getLiquidityNet: async (
+      params?: TickTypes.CallMethodParams<"getLiquidityNet">
+    ): Promise<TickTypes.CallMethodResult<"getLiquidityNet">> => {
+      return callMethod(
+        Tick,
+        this,
+        "getLiquidityNet",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    update: async (
+      params: TickTypes.SignExecuteMethodParams<"update">
+    ): Promise<TickTypes.SignExecuteMethodResult<"update">> => {
+      return signExecuteMethod(Tick, this, "update", params);
+    },
+    feeGrowthBelow: async (
+      params: TickTypes.SignExecuteMethodParams<"feeGrowthBelow">
+    ): Promise<TickTypes.SignExecuteMethodResult<"feeGrowthBelow">> => {
+      return signExecuteMethod(Tick, this, "feeGrowthBelow", params);
+    },
+    feeGrowthAbove: async (
+      params: TickTypes.SignExecuteMethodParams<"feeGrowthAbove">
+    ): Promise<TickTypes.SignExecuteMethodResult<"feeGrowthAbove">> => {
+      return signExecuteMethod(Tick, this, "feeGrowthAbove", params);
+    },
+    clear: async (
+      params: TickTypes.SignExecuteMethodParams<"clear">
+    ): Promise<TickTypes.SignExecuteMethodResult<"clear">> => {
+      return signExecuteMethod(Tick, this, "clear", params);
+    },
+    cross: async (
+      params: TickTypes.SignExecuteMethodParams<"cross">
+    ): Promise<TickTypes.SignExecuteMethodResult<"cross">> => {
+      return signExecuteMethod(Tick, this, "cross", params);
+    },
+    getLiquidityNet: async (
+      params: TickTypes.SignExecuteMethodParams<"getLiquidityNet">
+    ): Promise<TickTypes.SignExecuteMethodResult<"getLiquidityNet">> => {
+      return signExecuteMethod(Tick, this, "getLiquidityNet", params);
+    },
+  };
+
+  async multicall<Calls extends TickTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<TickTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends TickTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<TickTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends TickTypes.MultiCallParams | TickTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(Tick, this, callss, getContractByCodeHash);
+  }
+}