/* 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 "../DexAccount.ral.json";
import { getContractByCodeHash, registerContract } from "./contracts";
import * as types from "./types";

// 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,
      types.AllStructs
    );
  }

  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",
    types.AllStructs
  )
);
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
    );
  }
}