@alephium/powfi-sdk 0.0.1-rc.1

package/cpmm/artifacts/scripts/SwapMaxIn.ral.json

@@ -0,0 +1,46 @@
+{
+  "version": "v4.2.5",
+  "name": "SwapMaxIn",
+  "bytecodeTemplate": "0101030002001fb41700{0}160047cc17011601c5194c0516000d0c{0}d465b302f9{1}{4}{5}a3{3}{1}{4}{5}{6}{1}{7}13070c{2}0105",
+  "fieldsSig": {
+    "names": [
+      "dexAccount",
+      "sender",
+      "router",
+      "pair",
+      "tokenInId",
+      "amountInMax",
+      "amountOut",
+      "deadline"
+    ],
+    "types": [
+      "IDexAccount",
+      "Address",
+      "Router",
+      "TokenPair",
+      "ByteVec",
+      "U256",
+      "U256",
+      "U256"
+    ],
+    "isMutable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "functions": [
+    {
+      "name": "main",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": []
+    }
+  ]
+}

package/cpmm/artifacts/scripts/SwapMinOut.ral.json

@@ -0,0 +1,46 @@
+{
+  "version": "v4.2.5",
+  "name": "SwapMinOut",
+  "bytecodeTemplate": "0101030002001fb41700{0}160047cc17011601c5194c0516000d0c{0}d465b302f9{1}{4}{5}a3{3}{1}{4}{5}{6}{1}{7}13070c{2}0104",
+  "fieldsSig": {
+    "names": [
+      "dexAccount",
+      "sender",
+      "router",
+      "pair",
+      "tokenInId",
+      "amountIn",
+      "amountOutMin",
+      "deadline"
+    ],
+    "types": [
+      "IDexAccount",
+      "Address",
+      "Router",
+      "TokenPair",
+      "ByteVec",
+      "U256",
+      "U256",
+      "U256"
+    ],
+    "isMutable": [
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "functions": [
+    {
+      "name": "main",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": []
+    }
+  ]
+}

package/cpmm/artifacts/test/GetToken.ral.json

@@ -0,0 +1,31 @@
+{
+  "version": "v4.0.0",
+  "name": "GetToken",
+  "bytecodeTemplate": "01010300000006{1}{2}0e0c{0}0104",
+  "fieldsSig": {
+    "names": [
+      "token",
+      "sender",
+      "amount"
+    ],
+    "types": [
+      "TestToken",
+      "Address",
+      "U256"
+    ],
+    "isMutable": [
+      false,
+      false,
+      false
+    ]
+  },
+  "functions": [
+    {
+      "name": "main",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": []
+    }
+  ]
+}

package/cpmm/artifacts/test/MathTest.ral.json

@@ -0,0 +1,49 @@
+{
+  "version": "v4.0.0",
+  "name": "MathTest",
+  "bytecode": "0002174053010002020109d38c844efd16000d1340703b2c16012d0201000103014020d36ae1998016000f334c191600170116000e2d0d2a170216021601314c0b16021701160016022d16022a0e2d17024a311601020d02",
+  "codeHash": "732c8ff5b38eadaa96074453394619cb78ddf7371ff94ce7fb3dbe5fe332655c",
+  "fieldsSig": {
+    "names": [],
+    "types": [],
+    "isMutable": []
+  },
+  "eventsSig": [],
+  "functions": [
+    {
+      "name": "uqdiv",
+      "paramNames": [
+        "a",
+        "b"
+      ],
+      "paramTypes": [
+        "U256",
+        "U256"
+      ],
+      "paramIsMutable": [
+        false,
+        false
+      ],
+      "returnTypes": [
+        "U256"
+      ]
+    },
+    {
+      "name": "sqrt",
+      "paramNames": [
+        "y"
+      ],
+      "paramTypes": [
+        "U256"
+      ],
+      "paramIsMutable": [
+        false
+      ],
+      "returnTypes": [
+        "U256"
+      ]
+    }
+  ],
+  "constants": [],
+  "enums": []
+}

package/cpmm/artifacts/test/TestToken.ral.json

@@ -0,0 +1,87 @@
+{
+  "version": "v4.0.0",
+  "name": "TestToken",
+  "bytecode": "050509121b40244035010000000102ce0002010000000102ce0102010000000102ce0202010000000102ce0302010202020005d359e9ded71600b11601ab",
+  "codeHash": "f9dac4e7d0bf28a2bc019f43138339e23afadde322d50441cdfe029993bf35f3",
+  "fieldsSig": {
+    "names": [
+      "symbol",
+      "name",
+      "decimals",
+      "totalSupply",
+      "__stdInterfaceId"
+    ],
+    "types": [
+      "ByteVec",
+      "ByteVec",
+      "U256",
+      "U256",
+      "ByteVec"
+    ],
+    "isMutable": [
+      false,
+      false,
+      false,
+      false,
+      false
+    ]
+  },
+  "eventsSig": [],
+  "functions": [
+    {
+      "name": "getSymbol",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": [
+        "ByteVec"
+      ]
+    },
+    {
+      "name": "getName",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": [
+        "ByteVec"
+      ]
+    },
+    {
+      "name": "getDecimals",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": [
+        "U256"
+      ]
+    },
+    {
+      "name": "getTotalSupply",
+      "paramNames": [],
+      "paramTypes": [],
+      "paramIsMutable": [],
+      "returnTypes": [
+        "U256"
+      ]
+    },
+    {
+      "name": "getToken",
+      "paramNames": [
+        "sender",
+        "amount"
+      ],
+      "paramTypes": [
+        "Address",
+        "U256"
+      ],
+      "paramIsMutable": [
+        false,
+        false
+      ],
+      "returnTypes": []
+    }
+  ],
+  "constants": [],
+  "enums": [],
+  "stdInterfaceId": "0001"
+}

package/cpmm/artifacts/ts/DexAccount.ts

@@ -0,0 +1,329 @@
+/* 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 DexAccountContractJson } from "../dex/DexAccount.ral.json";
+import { getContractByCodeHash, registerContract } from "./contracts";
+
+// Custom types for the contract
+export namespace DexAccountTypes {
+  export type Fields = {
+    parents: [HexString, HexString];
+    owner: Address;
+    refferer: Address;
+    counter: bigint;
+  };
+
+  export type State = ContractState<Fields>;
+
+  export interface CallMethodTable {
+    deposit: {
+      params: CallContractParams<{
+        payer: Address;
+        tokenId: HexString;
+        amount: bigint;
+        path: HexString;
+        at: bigint;
+      }>;
+      result: CallContractResult<null>;
+    };
+    createAccount: {
+      params: CallContractParams<{ ref: Address }>;
+      result: CallContractResult<null>;
+    };
+    asRef: {
+      params: CallContractParams<{ defaultRef: Address }>;
+      result: CallContractResult<Address>;
+    };
+    updateCounter: {
+      params: CallContractParams<{ newCounter: bigint }>;
+      result: CallContractResult<null>;
+    };
+    setParents: {
+      params: CallContractParams<{ newParents: [HexString, 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 {
+    deposit: {
+      params: SignExecuteContractMethodParams<{
+        payer: Address;
+        tokenId: HexString;
+        amount: bigint;
+        path: HexString;
+        at: bigint;
+      }>;
+      result: SignExecuteScriptTxResult;
+    };
+    createAccount: {
+      params: SignExecuteContractMethodParams<{ ref: Address }>;
+      result: SignExecuteScriptTxResult;
+    };
+    asRef: {
+      params: SignExecuteContractMethodParams<{ defaultRef: Address }>;
+      result: SignExecuteScriptTxResult;
+    };
+    updateCounter: {
+      params: SignExecuteContractMethodParams<{ newCounter: bigint }>;
+      result: SignExecuteScriptTxResult;
+    };
+    setParents: {
+      params: SignExecuteContractMethodParams<{
+        newParents: [HexString, 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<
+  DexAccountInstance,
+  DexAccountTypes.Fields
+> {
+  encodeFields(fields: DexAccountTypes.Fields) {
+    return encodeContractFields(
+      addStdIdToFields(this.contract, fields),
+      this.contract.fieldsSig,
+      []
+    );
+  }
+
+  at(address: string): DexAccountInstance {
+    return new DexAccountInstance(address);
+  }
+
+  tests = {
+    deposit: async (
+      params: TestContractParamsWithoutMaps<
+        DexAccountTypes.Fields,
+        {
+          payer: Address;
+          tokenId: HexString;
+          amount: bigint;
+          path: HexString;
+          at: bigint;
+        }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "deposit", params, getContractByCodeHash);
+    },
+    createAccount: async (
+      params: TestContractParamsWithoutMaps<
+        DexAccountTypes.Fields,
+        { ref: Address }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "createAccount", params, getContractByCodeHash);
+    },
+    asRef: async (
+      params: TestContractParamsWithoutMaps<
+        DexAccountTypes.Fields,
+        { defaultRef: Address }
+      >
+    ): Promise<TestContractResultWithoutMaps<Address>> => {
+      return testMethod(this, "asRef", params, getContractByCodeHash);
+    },
+    updateCounter: async (
+      params: TestContractParamsWithoutMaps<
+        DexAccountTypes.Fields,
+        { newCounter: bigint }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "updateCounter", params, getContractByCodeHash);
+    },
+    setParents: async (
+      params: TestContractParamsWithoutMaps<
+        DexAccountTypes.Fields,
+        { newParents: [HexString, HexString] }
+      >
+    ): Promise<TestContractResultWithoutMaps<null>> => {
+      return testMethod(this, "setParents", params, getContractByCodeHash);
+    },
+  };
+
+  stateForTest(
+    initFields: DexAccountTypes.Fields,
+    asset?: Asset,
+    address?: string
+  ) {
+    return this.stateForTest_(initFields, asset, address, undefined);
+  }
+}
+
+// Use this object to test and deploy the contract
+export const DexAccount = new Factory(
+  Contract.fromJson(
+    DexAccountContractJson,
+    "",
+    "66c27c91033d54a2d3edc97dbc36b35022274ddd8a7b84b724631ac37586ed48",
+    []
+  )
+);
+registerContract(DexAccount);
+
+// Use this class to interact with the blockchain
+export class DexAccountInstance extends ContractInstance {
+  constructor(address: Address) {
+    super(address);
+  }
+
+  async fetchState(): Promise<DexAccountTypes.State> {
+    return fetchContractState(DexAccount, this);
+  }
+
+  view = {
+    deposit: async (
+      params: DexAccountTypes.CallMethodParams<"deposit">
+    ): Promise<DexAccountTypes.CallMethodResult<"deposit">> => {
+      return callMethod(
+        DexAccount,
+        this,
+        "deposit",
+        params,
+        getContractByCodeHash
+      );
+    },
+    createAccount: async (
+      params: DexAccountTypes.CallMethodParams<"createAccount">
+    ): Promise<DexAccountTypes.CallMethodResult<"createAccount">> => {
+      return callMethod(
+        DexAccount,
+        this,
+        "createAccount",
+        params,
+        getContractByCodeHash
+      );
+    },
+    asRef: async (
+      params: DexAccountTypes.CallMethodParams<"asRef">
+    ): Promise<DexAccountTypes.CallMethodResult<"asRef">> => {
+      return callMethod(
+        DexAccount,
+        this,
+        "asRef",
+        params,
+        getContractByCodeHash
+      );
+    },
+    updateCounter: async (
+      params: DexAccountTypes.CallMethodParams<"updateCounter">
+    ): Promise<DexAccountTypes.CallMethodResult<"updateCounter">> => {
+      return callMethod(
+        DexAccount,
+        this,
+        "updateCounter",
+        params,
+        getContractByCodeHash
+      );
+    },
+    setParents: async (
+      params: DexAccountTypes.CallMethodParams<"setParents">
+    ): Promise<DexAccountTypes.CallMethodResult<"setParents">> => {
+      return callMethod(
+        DexAccount,
+        this,
+        "setParents",
+        params,
+        getContractByCodeHash
+      );
+    },
+  };
+
+  transact = {
+    deposit: async (
+      params: DexAccountTypes.SignExecuteMethodParams<"deposit">
+    ): Promise<DexAccountTypes.SignExecuteMethodResult<"deposit">> => {
+      return signExecuteMethod(DexAccount, this, "deposit", params);
+    },
+    createAccount: async (
+      params: DexAccountTypes.SignExecuteMethodParams<"createAccount">
+    ): Promise<DexAccountTypes.SignExecuteMethodResult<"createAccount">> => {
+      return signExecuteMethod(DexAccount, this, "createAccount", params);
+    },
+    asRef: async (
+      params: DexAccountTypes.SignExecuteMethodParams<"asRef">
+    ): Promise<DexAccountTypes.SignExecuteMethodResult<"asRef">> => {
+      return signExecuteMethod(DexAccount, this, "asRef", params);
+    },
+    updateCounter: async (
+      params: DexAccountTypes.SignExecuteMethodParams<"updateCounter">
+    ): Promise<DexAccountTypes.SignExecuteMethodResult<"updateCounter">> => {
+      return signExecuteMethod(DexAccount, this, "updateCounter", params);
+    },
+    setParents: async (
+      params: DexAccountTypes.SignExecuteMethodParams<"setParents">
+    ): Promise<DexAccountTypes.SignExecuteMethodResult<"setParents">> => {
+      return signExecuteMethod(DexAccount, this, "setParents", params);
+    },
+  };
+
+  async multicall<Calls extends DexAccountTypes.MultiCallParams>(
+    calls: Calls
+  ): Promise<DexAccountTypes.MultiCallResults<Calls>>;
+  async multicall<Callss extends DexAccountTypes.MultiCallParams[]>(
+    callss: Narrow<Callss>
+  ): Promise<DexAccountTypes.MulticallReturnType<Callss>>;
+  async multicall<
+    Callss extends
+      | DexAccountTypes.MultiCallParams
+      | DexAccountTypes.MultiCallParams[]
+  >(callss: Callss): Promise<unknown> {
+    return await multicallMethods(
+      DexAccount,
+      this,
+      callss,
+      getContractByCodeHash
+    );
+  }
+}