@alephium/powfi-sdk 0.0.1-rc.1

package/cpmm/artifacts/ts/TokenPairFactory.ts

@@ -0,0 +1,501 @@
+/* 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 TokenPairFactoryContractJson } from "../dex/TokenPairFactory.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+
+// Custom types for the contract
+export namespace TokenPairFactoryTypes {
+  export type Fields = {
+    pairTemplateId: HexString;
+    dexAccount0: HexString;
+    pairSize: bigint;
+    feeSetter: Address;
+    feeCollectorFactory: HexString;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export type PairCreatedEvent = ContractEvent<{
+    token0: HexString;
+    token1: HexString;
+    pair: HexString;
+    currentPairSize: bigint;
+  }>;
+
+  export interface CallMethodTable {
+    setFeeCollectorFactory: {
+      params: CallContractParams<{ factory: HexString }>;
+      result: CallContractResult<null>;
+    };
+    updateFeeSetter: {
+      params: CallContractParams<{ newFeeSetter: Address }>;
+      result: CallContractResult<null>;
+    };
+    getFeeSetter: {
+      params: Omit<CallContractParams<{}>, "args">;
+      result: CallContractResult<Address>;
+    };
+    enableFeeCollector: {
+      params: CallContractParams<{ tokenPair: HexString; alphAmount: bigint }>;
+      result: CallContractResult<null>;
+    };
+    updateFeeCollector: {
+      params: CallContractParams<{
+        tokenPair: HexString;
+        newFeeCollectorId: HexString;
+      }>;
+      result: CallContractResult<null>;
+    };
+    sortTokens: {
+      params: CallContractParams<{ tokenA: HexString; tokenB: HexString }>;
+      result: CallContractResult<[HexString, HexString]>;
+    };
+    createPair: {
+      params: CallContractParams<{
+        payer: Address;
+        alphAmount: bigint;
+        tokenAId: HexString;
+        tokenBId: HexString;
+      }>;
+      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 {
+    setFeeCollectorFactory: {
+      params: SignExecuteContractMethodParams<{ factory: HexString }>;
+      result: SignExecuteScriptTxResult;
+    };
+    updateFeeSetter: {
+      params: SignExecuteContractMethodParams<{ newFeeSetter: Address }>;
+      result: SignExecuteScriptTxResult;
+    };
+    getFeeSetter: {
+      params: Omit<SignExecuteContractMethodParams<{}>, "args">;
+      result: SignExecuteScriptTxResult;
+    };
+    enableFeeCollector: {
+      params: SignExecuteContractMethodParams<{
+        tokenPair: HexString;
+        alphAmount: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    updateFeeCollector: {
+      params: SignExecuteContractMethodParams<{
+        tokenPair: HexString;
+        newFeeCollectorId: HexString;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    sortTokens: {
+      params: SignExecuteContractMethodParams<{
+        tokenA: HexString;
+        tokenB: HexString;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    createPair: {
+      params: SignExecuteContractMethodParams<{
+        payer: Address;
+        alphAmount: bigint;
+        tokenAId: HexString;
+        tokenBId: 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<
+  TokenPairFactoryInstance,
+  TokenPairFactoryTypes.Fields
+> {
+  encodeFields(fields: TokenPairFactoryTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      []
+    );
+  }
+
+  eventIndex = { PairCreated: 0 };
+  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): TokenPairFactoryInstance {
+    return new TokenPairFactoryInstance(address);
+  }
+
+  tests = {
+    setFeeCollectorFactory: async (
+      params: TestContractParamsWithoutMaps<
+        TokenPairFactoryTypes.Fields,
+        { factory: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(
+        this,
+        "setFeeCollectorFactory",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateFeeSetter: async (
+      params: TestContractParamsWithoutMaps<
+        TokenPairFactoryTypes.Fields,
+        { newFeeSetter: Address }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "updateFeeSetter", params, getContractByCodeHash);
+    },
+    getFeeSetter: async (
+      params: Omit<
+        TestContractParamsWithoutMaps<TokenPairFactoryTypes.Fields, never>,
+        "args"
+      >
+    ): Promise<TestContractResultWithoutMaps<Address>> => {
+      return testMethod(this, "getFeeSetter", params, getContractByCodeHash);
+    },
+    enableFeeCollector: async (
+      params: TestContractParamsWithoutMaps<
+        TokenPairFactoryTypes.Fields,
+        { tokenPair: HexString; alphAmount: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(
+        this,
+        "enableFeeCollector",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateFeeCollector: async (
+      params: TestContractParamsWithoutMaps<
+        TokenPairFactoryTypes.Fields,
+        { tokenPair: HexString; newFeeCollectorId: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(
+        this,
+        "updateFeeCollector",
+        params,
+        getContractByCodeHash
+      );
+    },
+    sortTokens: async (
+      params: TestContractParamsWithoutMaps<
+        TokenPairFactoryTypes.Fields,
+        { tokenA: HexString; tokenB: HexString }
+      >
+    ): Promise<TestContractResultWithoutMaps<[HexString, HexString]>> => {
+      return testMethod(this, "sortTokens", params, getContractByCodeHash);
+    },
+    createPair: async (
+      params: TestContractParamsWithoutMaps<
+        TokenPairFactoryTypes.Fields,
+        {
+          payer: Address;
+          alphAmount: bigint;
+          tokenAId: HexString;
+          tokenBId: HexString;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "createPair", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: TokenPairFactoryTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const TokenPairFactory = new Factory(
+  Contract.fromJson(
+    TokenPairFactoryContractJson,
+    "",
+    "597644c0643972e3d6e7f5a681e2d9908de74775e9b4e205e15ba39397a9e48c",
+    []
+  )
+);
+registerContract(TokenPairFactory);
+
+// Use this class to interact with the blockchain
+export class TokenPairFactoryInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<TokenPairFactoryTypes.State> {
+    return fetchContractState(TokenPairFactory, this);
+  }
+
+  async getContractEventsCurrentCount(): Promise<number> {
+    return getContractEventsCurrentCount(this.address);
+  }
+
+  subscribePairCreatedEvent(
+    options: EventSubscribeOptions<TokenPairFactoryTypes.PairCreatedEvent>,
+    fromCount?: number
+  ): EventSubscription {
+    return subscribeContractEvent(
+      TokenPairFactory.contract,
+      this,
+      options,
+      "PairCreated",
+      fromCount
+    );
+  }
+
+  view = {
+    setFeeCollectorFactory: async (
+      params: TokenPairFactoryTypes.CallMethodParams<"setFeeCollectorFactory">
+    ): Promise<
+      TokenPairFactoryTypes.CallMethodResult<"setFeeCollectorFactory">
+    > => {
+      return callMethod(
+        TokenPairFactory,
+        this,
+        "setFeeCollectorFactory",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateFeeSetter: async (
+      params: TokenPairFactoryTypes.CallMethodParams<"updateFeeSetter">
+    ): Promise<TokenPairFactoryTypes.CallMethodResult<"updateFeeSetter">> => {
+      return callMethod(
+        TokenPairFactory,
+        this,
+        "updateFeeSetter",
+        params,
+        getContractByCodeHash
+      );
+    },
+    getFeeSetter: async (
+      params?: TokenPairFactoryTypes.CallMethodParams<"getFeeSetter">
+    ): Promise<TokenPairFactoryTypes.CallMethodResult<"getFeeSetter">> => {
+      return callMethod(
+        TokenPairFactory,
+        this,
+        "getFeeSetter",
+        params === undefined ? {} : params,
+        getContractByCodeHash
+      );
+    },
+    enableFeeCollector: async (
+      params: TokenPairFactoryTypes.CallMethodParams<"enableFeeCollector">
+    ): Promise<
+      TokenPairFactoryTypes.CallMethodResult<"enableFeeCollector">
+    > => {
+      return callMethod(
+        TokenPairFactory,
+        this,
+        "enableFeeCollector",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateFeeCollector: async (
+      params: TokenPairFactoryTypes.CallMethodParams<"updateFeeCollector">
+    ): Promise<
+      TokenPairFactoryTypes.CallMethodResult<"updateFeeCollector">
+    > => {
+      return callMethod(
+        TokenPairFactory,
+        this,
+        "updateFeeCollector",
+        params,
+        getContractByCodeHash
+      );
+    },
+    sortTokens: async (
+      params: TokenPairFactoryTypes.CallMethodParams<"sortTokens">
+    ): Promise<TokenPairFactoryTypes.CallMethodResult<"sortTokens">> => {
+      return callMethod(
+        TokenPairFactory,
+        this,
+        "sortTokens",
+        params,
+        getContractByCodeHash
+      );
+    },
+    createPair: async (
+      params: TokenPairFactoryTypes.CallMethodParams<"createPair">
+    ): Promise<TokenPairFactoryTypes.CallMethodResult<"createPair">> => {
+      return callMethod(
+        TokenPairFactory,
+        this,
+        "createPair",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    setFeeCollectorFactory: async (
+      params: TokenPairFactoryTypes.SignExecuteMethodParams<"setFeeCollectorFactory">
+    ): Promise<
+      TokenPairFactoryTypes.SignExecuteMethodResult<"setFeeCollectorFactory">
+    > => {
+      return signExecuteMethod(
+        TokenPairFactory,
+        this,
+        "setFeeCollectorFactory",
+        params
+      );
+    },
+    updateFeeSetter: async (
+      params: TokenPairFactoryTypes.SignExecuteMethodParams<"updateFeeSetter">
+    ): Promise<
+      TokenPairFactoryTypes.SignExecuteMethodResult<"updateFeeSetter">
+    > => {
+      return signExecuteMethod(
+        TokenPairFactory,
+        this,
+        "updateFeeSetter",
+        params
+      );
+    },
+    getFeeSetter: async (
+      params: TokenPairFactoryTypes.SignExecuteMethodParams<"getFeeSetter">
+    ): Promise<
+      TokenPairFactoryTypes.SignExecuteMethodResult<"getFeeSetter">
+    > => {
+      return signExecuteMethod(TokenPairFactory, this, "getFeeSetter", params);
+    },
+    enableFeeCollector: async (
+      params: TokenPairFactoryTypes.SignExecuteMethodParams<"enableFeeCollector">
+    ): Promise<
+      TokenPairFactoryTypes.SignExecuteMethodResult<"enableFeeCollector">
+    > => {
+      return signExecuteMethod(
+        TokenPairFactory,
+        this,
+        "enableFeeCollector",
+        params
+      );
+    },
+    updateFeeCollector: async (
+      params: TokenPairFactoryTypes.SignExecuteMethodParams<"updateFeeCollector">
+    ): Promise<
+      TokenPairFactoryTypes.SignExecuteMethodResult<"updateFeeCollector">
+    > => {
+      return signExecuteMethod(
+        TokenPairFactory,
+        this,
+        "updateFeeCollector",
+        params
+      );
+    },
+    sortTokens: async (
+      params: TokenPairFactoryTypes.SignExecuteMethodParams<"sortTokens">
+    ): Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"sortTokens">> => {
+      return signExecuteMethod(TokenPairFactory, this, "sortTokens", params);
+    },
+    createPair: async (
+      params: TokenPairFactoryTypes.SignExecuteMethodParams<"createPair">
+    ): Promise<TokenPairFactoryTypes.SignExecuteMethodResult<"createPair">> => {
+      return signExecuteMethod(TokenPairFactory, this, "createPair", params);
+    },
+  };
+
+  async multicall<Calls extends TokenPairFactoryTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<TokenPairFactoryTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends TokenPairFactoryTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<TokenPairFactoryTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | TokenPairFactoryTypes.MultiCallParams
+      | TokenPairFactoryTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      TokenPairFactory,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}

package/cpmm/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;
+}

package/cpmm/artifacts/ts/deployments.ts

@@ -0,0 +1,109 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+import {
+  RunScriptResult,
+  DeployContractExecutionResult,
+  NetworkId,
+} from "@alephium/web3";
+import {
+  TokenPair,
+  TokenPairInstance,
+  TokenPairFactory,
+  TokenPairFactoryInstance,
+  Router,
+  RouterInstance,
+  FeeCollectorPerTokenPairImpl,
+  FeeCollectorPerTokenPairImplInstance,
+  FeeCollectorFactoryImpl,
+  FeeCollectorFactoryImplInstance,
+} from ".";
+import { default as testnetDeployments } from "../../deployments/.deployments.testnet.json";
+import { default as devnetDeployments } from "../../deployments/.deployments.devnet.json";
+
+export type Deployments = {
+  deployerAddress: string;
+  contracts: {
+    TokenPair: DeployContractExecutionResult<TokenPairInstance>;
+    TokenPairFactory: DeployContractExecutionResult<TokenPairFactoryInstance>;
+    Router: DeployContractExecutionResult<RouterInstance>;
+    FeeCollectorPerTokenPairImpl: DeployContractExecutionResult<FeeCollectorPerTokenPairImplInstance>;
+    FeeCollectorFactoryImpl: DeployContractExecutionResult<FeeCollectorFactoryImplInstance>;
+  };
+};
+
+function toDeployments(json: any): Deployments {
+  const contracts = {
+    TokenPair: {
+      ...json.contracts["TokenPair"],
+      contractInstance: TokenPair.at(
+        json.contracts["TokenPair"].contractInstance.address
+      ),
+    },
+    TokenPairFactory: {
+      ...json.contracts["TokenPairFactory"],
+      contractInstance: TokenPairFactory.at(
+        json.contracts["TokenPairFactory"].contractInstance.address
+      ),
+    },
+    Router: {
+      ...json.contracts["Router"],
+      contractInstance: Router.at(
+        json.contracts["Router"].contractInstance.address
+      ),
+    },
+    FeeCollectorPerTokenPairImpl: {
+      ...json.contracts["FeeCollectorPerTokenPairImpl"],
+      contractInstance: FeeCollectorPerTokenPairImpl.at(
+        json.contracts["FeeCollectorPerTokenPairImpl"].contractInstance.address
+      ),
+    },
+    FeeCollectorFactoryImpl: {
+      ...json.contracts["FeeCollectorFactoryImpl"],
+      contractInstance: FeeCollectorFactoryImpl.at(
+        json.contracts["FeeCollectorFactoryImpl"].contractInstance.address
+      ),
+    },
+  };
+  return {
+    ...json,
+    contracts: contracts as Deployments["contracts"],
+  };
+}
+
+export function loadDeployments(
+  networkId: NetworkId,
+  deployerAddress?: string
+): Deployments {
+  const deployments =
+    networkId === "testnet"
+      ? testnetDeployments
+      : networkId === "devnet"
+      ? devnetDeployments
+      : undefined;
+  if (deployments === undefined) {
+    throw Error("The contract has not been deployed to the " + networkId);
+  }
+  const allDeployments: any[] = Array.isArray(deployments)
+    ? deployments
+    : [deployments];
+  if (deployerAddress === undefined) {
+    if (allDeployments.length > 1) {
+      throw Error(
+        "The contract has been deployed multiple times on " +
+          networkId +
+          ", please specify the deployer address"
+      );
+    } else {
+      return toDeployments(allDeployments[0]);
+    }
+  }
+  const result = allDeployments.find(
+    (d) => d.deployerAddress === deployerAddress
+  );
+  if (result === undefined) {
+    throw Error("The contract deployment result does not exist");
+  }
+  return toDeployments(result);
+}

package/cpmm/artifacts/ts/index.ts

@@ -0,0 +1,16 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+
+export * from "./DexAccount";
+export * from "./ExampleOracleSimple";
+export * from "./FeeCollectorFactoryImpl";
+export * from "./FeeCollectorPerTokenPairImpl";
+export * from "./FullMathTest";
+export * from "./MathTest";
+export * from "./Router";
+export * from "./TestToken";
+export * from "./TokenPair";
+export * from "./TokenPairFactory";
+export * from "./contracts";
+export * from "./scripts";