@alephium/powfi-sdk 0.0.1-rc.1

package/cpmm/artifacts/ts/ExampleOracleSimple.ts

@@ -0,0 +1,383 @@
+/* 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 ExampleOracleSimpleContractJson } from "../examples/ExampleOracleSimple.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+
+// Custom types for the contract
+export namespace ExampleOracleSimpleTypes {
+  export type Fields = {
+    pair: HexString;
+    price0CumulativeLast: bigint;
+    price1CumulativeLast: bigint;
+    blockTimeStampLast: bigint;
+    price0Average: bigint;
+    price1Average: bigint;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    fullMul: {
+      params: CallContractParams<{ x: bigint; y: bigint }>;
+      result: CallContractResult<[bigint, bigint]>;
+    };
+    mulDiv: {
+      params: CallContractParams<{ a: bigint; b: bigint; denominator: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    fraction: {
+      params: CallContractParams<{ numerator: bigint; denominator: bigint }>;
+      result: CallContractResult<bigint>;
+    };
+    currentCumulativePrices: {
+      params: CallContractParams<{ currentBlockTimeStamp: bigint }>;
+      result: CallContractResult<[bigint, bigint]>;
+    };
+    update: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<null>;
+    };
+    consult: {
+      params: CallContractParams<{ tokenId: HexString; amountIn: 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 {
+    fullMul: {
+      params: SignExecuteContractMethodParams<{ x: bigint; y: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    mulDiv: {
+      params: SignExecuteContractMethodParams<{
+        a: bigint;
+        b: bigint;
+        denominator: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    fraction: {
+      params: SignExecuteContractMethodParams<{
+        numerator: bigint;
+        denominator: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    currentCumulativePrices: {
+      params: SignExecuteContractMethodParams<{
+        currentBlockTimeStamp: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    update: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    consult: {
+      params: SignExecuteContractMethodParams<{
+        tokenId: HexString;
+        amountIn: 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<
+  ExampleOracleSimpleInstance,
+  ExampleOracleSimpleTypes.Fields
+> {
+  encodeFields(fields: ExampleOracleSimpleTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      []
+    );
+  }
+
+  consts = {
+    Resolution: BigInt("112"),
+    Period: BigInt("86400"),
+    ErrorCodes: {
+      FullDivOverflow: BigInt("0"),
+      DivByZero: BigInt("1"),
+      FractionOverflow: BigInt("2"),
+      PeriodNotElapsed: BigInt("3"),
+      InvalidToken: BigInt("4"),
+    },
+  };
+
+  at(address: string): ExampleOracleSimpleInstance {
+    return new ExampleOracleSimpleInstance(address);
+  }
+
+  tests = {
+    fullMul: async (
+      params: TestContractParamsWithoutMaps<
+        ExampleOracleSimpleTypes.Fields,
+        { x: bigint; y: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
+      return testMethod(this, "fullMul", params, getContractByCodeHash);
+    },
+    mulDiv: async (
+      params: TestContractParamsWithoutMaps<
+        ExampleOracleSimpleTypes.Fields,
+        { a: bigint; b: bigint; denominator: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "mulDiv", params, getContractByCodeHash);
+    },
+    fraction: async (
+      params: TestContractParamsWithoutMaps<
+        ExampleOracleSimpleTypes.Fields,
+        { numerator: bigint; denominator: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "fraction", params, getContractByCodeHash);
+    },
+    currentCumulativePrices: async (
+      params: TestContractParamsWithoutMaps<
+        ExampleOracleSimpleTypes.Fields,
+        { currentBlockTimeStamp: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<[bigint, bigint]>> => {
+      return testMethod(
+        this,
+        "currentCumulativePrices",
+        params,
+        getContractByCodeHash
+      );
+    },
+    update: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<ExampleOracleSimpleTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "update", params, getContractByCodeHash);
+    },
+    consult: async (
+      params: TestContractParamsWithoutMaps<
+        ExampleOracleSimpleTypes.Fields,
+        { tokenId: HexString; amountIn: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<bigint>> => {
+      return testMethod(this, "consult", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: ExampleOracleSimpleTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const ExampleOracleSimple = new Factory(
+  Contract.fromJson(
+    ExampleOracleSimpleContractJson,
+    "",
+    "c96ea41f2579f435d70c7801c2ec158031575b7571d8e8bbb2e460a8814cfbdf",
+    []
+  )
+);
+registerContract(ExampleOracleSimple);
+
+// Use this class to interact with the blockchain
+export class ExampleOracleSimpleInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<ExampleOracleSimpleTypes.State> {
+    return fetchContractState(ExampleOracleSimple, this);
+  }
+
+  view = {
+    fullMul: async (
+      params: ExampleOracleSimpleTypes.CallMethodParams<"fullMul">
+    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"fullMul">> => {
+      return callMethod(
+        ExampleOracleSimple,
+        this,
+        "fullMul",
+        params,
+        getContractByCodeHash
+      );
+    },
+    mulDiv: async (
+      params: ExampleOracleSimpleTypes.CallMethodParams<"mulDiv">
+    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"mulDiv">> => {
+      return callMethod(
+        ExampleOracleSimple,
+        this,
+        "mulDiv",
+        params,
+        getContractByCodeHash
+      );
+    },
+    fraction: async (
+      params: ExampleOracleSimpleTypes.CallMethodParams<"fraction">
+    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"fraction">> => {
+      return callMethod(
+        ExampleOracleSimple,
+        this,
+        "fraction",
+        params,
+        getContractByCodeHash
+      );
+    },
+    currentCumulativePrices: async (
+      params: ExampleOracleSimpleTypes.CallMethodParams<"currentCumulativePrices">
+    ): Promise<
+      ExampleOracleSimpleTypes.CallMethodResult<"currentCumulativePrices">
+    > => {
+      return callMethod(
+        ExampleOracleSimple,
+        this,
+        "currentCumulativePrices",
+        params,
+        getContractByCodeHash
+      );
+    },
+    update: async (
+      params?: ExampleOracleSimpleTypes.CallMethodParams<"update">
+    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"update">> => {
+      return callMethod(
+        ExampleOracleSimple,
+        this,
+        "update",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    consult: async (
+      params: ExampleOracleSimpleTypes.CallMethodParams<"consult">
+    ): Promise<ExampleOracleSimpleTypes.CallMethodResult<"consult">> => {
+      return callMethod(
+        ExampleOracleSimple,
+        this,
+        "consult",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    fullMul: async (
+      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"fullMul">
+    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"fullMul">> => {
+      return signExecuteMethod(ExampleOracleSimple, this, "fullMul", params);
+    },
+    mulDiv: async (
+      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"mulDiv">
+    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"mulDiv">> => {
+      return signExecuteMethod(ExampleOracleSimple, this, "mulDiv", params);
+    },
+    fraction: async (
+      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"fraction">
+    ): Promise<
+      ExampleOracleSimpleTypes.SignExecuteMethodResult<"fraction">
+    > => {
+      return signExecuteMethod(ExampleOracleSimple, this, "fraction", params);
+    },
+    currentCumulativePrices: async (
+      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"currentCumulativePrices">
+    ): Promise<
+      ExampleOracleSimpleTypes.SignExecuteMethodResult<"currentCumulativePrices">
+    > => {
+      return signExecuteMethod(
+        ExampleOracleSimple,
+        this,
+        "currentCumulativePrices",
+        params
+      );
+    },
+    update: async (
+      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"update">
+    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"update">> => {
+      return signExecuteMethod(ExampleOracleSimple, this, "update", params);
+    },
+    consult: async (
+      params: ExampleOracleSimpleTypes.SignExecuteMethodParams<"consult">
+    ): Promise<ExampleOracleSimpleTypes.SignExecuteMethodResult<"consult">> => {
+      return signExecuteMethod(ExampleOracleSimple, this, "consult", params);
+    },
+  };
+
+  async multicall<Calls extends ExampleOracleSimpleTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<ExampleOracleSimpleTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends ExampleOracleSimpleTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<ExampleOracleSimpleTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | ExampleOracleSimpleTypes.MultiCallParams
+      | ExampleOracleSimpleTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      ExampleOracleSimple,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}

package/cpmm/artifacts/ts/FeeCollectorFactoryImpl.ts

@@ -0,0 +1,227 @@
+/* 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 FeeCollectorFactoryImplContractJson } from "../examples/FeeCollectorFactoryImpl.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+
+// Custom types for the contract
+export namespace FeeCollectorFactoryImplTypes {
+  export type Fields = {
+    feeCollectorPerTokenPairTemplateId: HexString;
+    tokenPairFactory: HexString;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    createFeeCollector: {
+      params: CallContractParams<{
+        caller: Address;
+        alphAmount: bigint;
+        tokenPair: HexString;
+      }>;
+      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 {
+    createFeeCollector: {
+      params: SignExecuteContractMethodParams<{
+        caller: Address;
+        alphAmount: bigint;
+        tokenPair: 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<
+  FeeCollectorFactoryImplInstance,
+  FeeCollectorFactoryImplTypes.Fields
+> {
+  encodeFields(fields: FeeCollectorFactoryImplTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      []
+    );
+  }
+
+  consts = {
+    ErrorCodes: {
+      ReserveOverflow: BigInt("0"),
+      InsufficientInitLiquidity: BigInt("1"),
+      InsufficientLiquidityMinted: BigInt("2"),
+      InsufficientLiquidityBurned: BigInt("3"),
+      InvalidToAddress: BigInt("4"),
+      InsufficientLiquidity: BigInt("5"),
+      InvalidTokenInId: BigInt("6"),
+      InvalidCalleeId: BigInt("7"),
+      InvalidK: BigInt("8"),
+      InsufficientOutputAmount: BigInt("9"),
+      InsufficientInputAmount: BigInt("10"),
+      IdenticalTokenIds: BigInt("11"),
+      Expired: BigInt("12"),
+      InsufficientToken0Amount: BigInt("13"),
+      InsufficientToken1Amount: BigInt("14"),
+      TokenNotExist: BigInt("15"),
+      InvalidCaller: BigInt("16"),
+      FeeCollectorNotEnabled: BigInt("17"),
+      InvalidAccount: BigInt("18"),
+    },
+  };
+
+  at(address: string): FeeCollectorFactoryImplInstance {
+    return new FeeCollectorFactoryImplInstance(address);
+  }
+
+  tests = {
+    createFeeCollector: async (
+      params: TestContractParamsWithoutMaps<
+        FeeCollectorFactoryImplTypes.Fields,
+        { caller: Address; alphAmount: bigint; tokenPair: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<HexString>> => {
+      return testMethod(
+        this,
+        "createFeeCollector",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  stateForTest(
+    initFields: FeeCollectorFactoryImplTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const FeeCollectorFactoryImpl = new Factory(
+  Contract.fromJson(
+    FeeCollectorFactoryImplContractJson,
+    "",
+    "966f75cddefe774a87dbf778012f4f3f494b3a860f4c975d0c5262a1be185d49",
+    []
+  )
+);
+registerContract(FeeCollectorFactoryImpl);
+
+// Use this class to interact with the blockchain
+export class FeeCollectorFactoryImplInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<FeeCollectorFactoryImplTypes.State> {
+    return fetchContractState(FeeCollectorFactoryImpl, this);
+  }
+
+  view = {
+    createFeeCollector: async (
+      params: FeeCollectorFactoryImplTypes.CallMethodParams<"createFeeCollector">
+    ): Promise<
+      FeeCollectorFactoryImplTypes.CallMethodResult<"createFeeCollector">
+    > => {
+      return callMethod(
+        FeeCollectorFactoryImpl,
+        this,
+        "createFeeCollector",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    createFeeCollector: async (
+      params: FeeCollectorFactoryImplTypes.SignExecuteMethodParams<"createFeeCollector">
+    ): Promise<
+      FeeCollectorFactoryImplTypes.SignExecuteMethodResult<"createFeeCollector">
+    > => {
+      return signExecuteMethod(
+        FeeCollectorFactoryImpl,
+        this,
+        "createFeeCollector",
+        params
+      );
+    },
+  };
+
+  async multicall<Calls extends FeeCollectorFactoryImplTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<FeeCollectorFactoryImplTypes.MultiCallResults<Calls>>;
+  async multicall<
+    Callss extends FeeCollectorFactoryImplTypes.MultiCallParams[]
+  >(
+    callss: Narrow<Callss>
+  ): Promise<FeeCollectorFactoryImplTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | FeeCollectorFactoryImplTypes.MultiCallParams
+      | FeeCollectorFactoryImplTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      FeeCollectorFactoryImpl,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}