/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */

/* Generated types for 0x1, original address 0x1 */

import { CallFilter, MoveFetchConfig, EventFilter } from "@sentio/sdk/move";
import { HandlerOptions } from "@sentio/sdk";
import {
  AptosBindOptions,
  AptosBaseProcessor,
  AptosNetwork,
  TypedFunctionPayload,
  AptosContext,
} from "@sentio/sdk/aptos";

import { TypeDescriptor, ANY_TYPE } from "@typemove/move";
import { MoveCoder, TypedEventInstance } from "@typemove/aptos";

import { defaultMoveCoder, defaultMoveCoderForClient } from "@sentio/sdk/aptos";
import {
  Aptos,
  Account as AptosAccount,
  MoveAddressType,
  PendingTransactionResponse,
  InputGenerateTransactionOptions,
  MoveStructId,
  InputViewFunctionData,
  InputViewFunctionJsonData,
} from "@aptos-labs/ts-sdk";

export namespace acl {
  export interface ACL {
    list: MoveAddressType[];
  }

  export namespace ACL {
    export const TYPE_QNAME = "0x1::acl::ACL";

    const TYPE = new TypeDescriptor<ACL>(ACL.TYPE_QNAME);

    export function type(): TypeDescriptor<ACL> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class any$ extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("any", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): any$ {
    return new any$({ ...any$.DEFAULT_OPTIONS, ...options });
  }

  onEventAny(
    func: (event: any$.AnyInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, any$.AnyInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): any$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "any::Any" },
      handlerOptions,
    );
    return this;
  }
}

export namespace any$ {
  export interface Any {
    type_name: string;
    data: string;
  }

  export namespace Any {
    export const TYPE_QNAME = "0x1::any::Any";

    const TYPE = new TypeDescriptor<Any>(Any.TYPE_QNAME);

    export function type(): TypeDescriptor<Any> {
      return TYPE.apply();
    }
  }

  export type AnyInstance = TypedEventInstance<Any> & {
    data_decoded: Any;
    type_arguments: [];
  };

  export namespace entry {}
  export namespace view {}
}

export namespace bcs {
  export namespace entry {}
  export namespace view {}
}

export namespace cmp {
  export interface Ordering {}

  export namespace Ordering {
    export const TYPE_QNAME = "0x1::cmp::Ordering";

    const TYPE = new TypeDescriptor<Ordering>(Ordering.TYPE_QNAME);

    export function type(): TypeDescriptor<Ordering> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class dkg extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("dkg", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): dkg {
    return new dkg({ ...dkg.DEFAULT_OPTIONS, ...options });
  }

  onEventDKGStartEvent(
    func: (event: dkg.DKGStartEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, dkg.DKGStartEventInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): dkg {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "dkg::DKGStartEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace dkg {
  export interface DKGSessionMetadata {
    dealer_epoch: bigint;
    randomness_config: randomness_config.RandomnessConfig;
    dealer_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
    target_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
  }

  export namespace DKGSessionMetadata {
    export const TYPE_QNAME = "0x1::dkg::DKGSessionMetadata";

    const TYPE = new TypeDescriptor<DKGSessionMetadata>(
      DKGSessionMetadata.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DKGSessionMetadata> {
      return TYPE.apply();
    }
  }

  export interface DKGSessionState {
    metadata: dkg.DKGSessionMetadata;
    start_time_us: bigint;
    transcript: string;
  }

  export namespace DKGSessionState {
    export const TYPE_QNAME = "0x1::dkg::DKGSessionState";

    const TYPE = new TypeDescriptor<DKGSessionState>(
      DKGSessionState.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DKGSessionState> {
      return TYPE.apply();
    }
  }

  export interface DKGStartEvent {
    session_metadata: dkg.DKGSessionMetadata;
    start_time_us: bigint;
  }

  export namespace DKGStartEvent {
    export const TYPE_QNAME = "0x1::dkg::DKGStartEvent";

    const TYPE = new TypeDescriptor<DKGStartEvent>(DKGStartEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<DKGStartEvent> {
      return TYPE.apply();
    }
  }

  export type DKGStartEventInstance = TypedEventInstance<DKGStartEvent> & {
    data_decoded: DKGStartEvent;
    type_arguments: [];
  };

  export interface DKGState {
    last_completed: option.Option<dkg.DKGSessionState>;
    in_progress: option.Option<dkg.DKGSessionState>;
  }

  export namespace DKGState {
    export const TYPE_QNAME = "0x1::dkg::DKGState";

    const TYPE = new TypeDescriptor<DKGState>(DKGState.TYPE_QNAME);

    export function type(): TypeDescriptor<DKGState> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace mem {
  export namespace entry {}
  export namespace view {}
}

export class code extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("code", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): code {
    return new code({ ...code.DEFAULT_OPTIONS, ...options });
  }

  onEntryPublishPackageTxn(
    func: (call: code.PublishPackageTxnPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      code.PublishPackageTxnPayload
    >,
  ): code {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "code::publish_package_txn",
      },
      handlerOptions,
    );
    return this;
  }

  onEventPublishPackage(
    func: (event: code.PublishPackageInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      code.PublishPackageInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): code {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "code::PublishPackage" },
      handlerOptions,
    );
    return this;
  }
}

export namespace code {
  export interface AllowedDep {
    account: MoveAddressType;
    module_name: string;
  }

  export namespace AllowedDep {
    export const TYPE_QNAME = "0x1::code::AllowedDep";

    const TYPE = new TypeDescriptor<AllowedDep>(AllowedDep.TYPE_QNAME);

    export function type(): TypeDescriptor<AllowedDep> {
      return TYPE.apply();
    }
  }

  export interface CodePublishingPermission {
    dummy_field: boolean;
  }

  export namespace CodePublishingPermission {
    export const TYPE_QNAME = "0x1::code::CodePublishingPermission";

    const TYPE = new TypeDescriptor<CodePublishingPermission>(
      CodePublishingPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CodePublishingPermission> {
      return TYPE.apply();
    }
  }

  export interface ModuleMetadata {
    name: string;
    source: string;
    source_map: string;
    extension: option.Option<copyable_any.Any>;
  }

  export namespace ModuleMetadata {
    export const TYPE_QNAME = "0x1::code::ModuleMetadata";

    const TYPE = new TypeDescriptor<ModuleMetadata>(ModuleMetadata.TYPE_QNAME);

    export function type(): TypeDescriptor<ModuleMetadata> {
      return TYPE.apply();
    }
  }

  export interface PackageDep {
    account: MoveAddressType;
    package_name: string;
  }

  export namespace PackageDep {
    export const TYPE_QNAME = "0x1::code::PackageDep";

    const TYPE = new TypeDescriptor<PackageDep>(PackageDep.TYPE_QNAME);

    export function type(): TypeDescriptor<PackageDep> {
      return TYPE.apply();
    }
  }

  export interface PackageMetadata {
    name: string;
    upgrade_policy: code.UpgradePolicy;
    upgrade_number: bigint;
    source_digest: string;
    manifest: string;
    modules: code.ModuleMetadata[];
    deps: code.PackageDep[];
    extension: option.Option<copyable_any.Any>;
  }

  export namespace PackageMetadata {
    export const TYPE_QNAME = "0x1::code::PackageMetadata";

    const TYPE = new TypeDescriptor<PackageMetadata>(
      PackageMetadata.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PackageMetadata> {
      return TYPE.apply();
    }
  }

  export interface PackageRegistry {
    packages: code.PackageMetadata[];
  }

  export namespace PackageRegistry {
    export const TYPE_QNAME = "0x1::code::PackageRegistry";

    const TYPE = new TypeDescriptor<PackageRegistry>(
      PackageRegistry.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PackageRegistry> {
      return TYPE.apply();
    }
  }

  export interface PublishPackage {
    code_address: MoveAddressType;
    is_upgrade: boolean;
  }

  export namespace PublishPackage {
    export const TYPE_QNAME = "0x1::code::PublishPackage";

    const TYPE = new TypeDescriptor<PublishPackage>(PublishPackage.TYPE_QNAME);

    export function type(): TypeDescriptor<PublishPackage> {
      return TYPE.apply();
    }
  }

  export type PublishPackageInstance = TypedEventInstance<PublishPackage> & {
    data_decoded: PublishPackage;
    type_arguments: [];
  };

  export interface UpgradePolicy {
    policy: number;
  }

  export namespace UpgradePolicy {
    export const TYPE_QNAME = "0x1::code::UpgradePolicy";

    const TYPE = new TypeDescriptor<UpgradePolicy>(UpgradePolicy.TYPE_QNAME);

    export function type(): TypeDescriptor<UpgradePolicy> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function publishPackageTxn(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::code::publish_package_txn",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface PublishPackageTxnPayload
    extends TypedFunctionPayload<[string, string[]]> {
    arguments_decoded: [string, string[]];
    type_arguments: [];
  }
}

export class coin extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("coin", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): coin {
    return new coin({ ...coin.DEFAULT_OPTIONS, ...options });
  }

  onEntryTransfer(
    func: (call: coin.TransferPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, coin.TransferPayload>,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateCoinConversionMap(
    func: (
      call: coin.CreateCoinConversionMapPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.CreateCoinConversionMapPayload
    >,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::create_coin_conversion_map",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreatePairing(
    func: (call: coin.CreatePairingPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, coin.CreatePairingPayload>,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::create_pairing",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryFreezeCoinStore(
    func: (call: coin.FreezeCoinStorePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.FreezeCoinStorePayload
    >,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::freeze_coin_store",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryMigrateCoinStoreToFungibleStore(
    func: (
      call: coin.MigrateCoinStoreToFungibleStorePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.MigrateCoinStoreToFungibleStorePayload
    >,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::migrate_coin_store_to_fungible_store",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryMigrateToFungibleStore(
    func: (call: coin.MigrateToFungibleStorePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.MigrateToFungibleStorePayload
    >,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::migrate_to_fungible_store",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnfreezeCoinStore(
    func: (call: coin.UnfreezeCoinStorePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.UnfreezeCoinStorePayload
    >,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::unfreeze_coin_store",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpgradeSupply(
    func: (call: coin.UpgradeSupplyPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, coin.UpgradeSupplyPayload>,
  ): coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "coin::upgrade_supply",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDepositEvent(
    func: (event: coin.DepositEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, coin.DepositEventInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): coin {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "coin::DepositEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawEvent(
    func: (event: coin.WithdrawEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.WithdrawEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): coin {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "coin::WithdrawEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventCoinDeposit(
    func: (event: coin.CoinDepositInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, coin.CoinDepositInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): coin {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "coin::CoinDeposit" },
      handlerOptions,
    );
    return this;
  }

  onEventCoinEventHandleDeletion(
    func: (
      event: coin.CoinEventHandleDeletionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.CoinEventHandleDeletionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): coin {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "coin::CoinEventHandleDeletion" },
      handlerOptions,
    );
    return this;
  }

  onEventCoinStoreDeletion(
    func: (event: coin.CoinStoreDeletionInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      coin.CoinStoreDeletionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): coin {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "coin::CoinStoreDeletion" },
      handlerOptions,
    );
    return this;
  }

  onEventCoinWithdraw(
    func: (event: coin.CoinWithdrawInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, coin.CoinWithdrawInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): coin {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "coin::CoinWithdraw" },
      handlerOptions,
    );
    return this;
  }

  onEventPairCreation(
    func: (event: coin.PairCreationInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, coin.PairCreationInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): coin {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "coin::PairCreation" },
      handlerOptions,
    );
    return this;
  }
}

export namespace coin {
  export interface Deposit<T0> {
    account: MoveAddressType;
    amount: bigint;
  }

  export namespace Deposit {
    export const TYPE_QNAME = "0x1::coin::Deposit";

    const TYPE = new TypeDescriptor<Deposit<any>>(Deposit.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Deposit<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface DepositEvent {
    amount: bigint;
  }

  export namespace DepositEvent {
    export const TYPE_QNAME = "0x1::coin::DepositEvent";

    const TYPE = new TypeDescriptor<DepositEvent>(DepositEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<DepositEvent> {
      return TYPE.apply();
    }
  }

  export type DepositEventInstance = TypedEventInstance<DepositEvent> & {
    data_decoded: DepositEvent;
    type_arguments: [];
  };

  export interface Withdraw<T0> {
    account: MoveAddressType;
    amount: bigint;
  }

  export namespace Withdraw {
    export const TYPE_QNAME = "0x1::coin::Withdraw";

    const TYPE = new TypeDescriptor<Withdraw<any>>(Withdraw.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Withdraw<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface WithdrawEvent {
    amount: bigint;
  }

  export namespace WithdrawEvent {
    export const TYPE_QNAME = "0x1::coin::WithdrawEvent";

    const TYPE = new TypeDescriptor<WithdrawEvent>(WithdrawEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<WithdrawEvent> {
      return TYPE.apply();
    }
  }

  export type WithdrawEventInstance = TypedEventInstance<WithdrawEvent> & {
    data_decoded: WithdrawEvent;
    type_arguments: [];
  };

  export interface AggregatableCoin<T0> {
    value: aggregator.Aggregator;
  }

  export namespace AggregatableCoin {
    export const TYPE_QNAME = "0x1::coin::AggregatableCoin";

    const TYPE = new TypeDescriptor<AggregatableCoin<any>>(
      AggregatableCoin.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<AggregatableCoin<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface BurnCapability<T0> {
    dummy_field: boolean;
  }

  export namespace BurnCapability {
    export const TYPE_QNAME = "0x1::coin::BurnCapability";

    const TYPE = new TypeDescriptor<BurnCapability<any>>(
      BurnCapability.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<BurnCapability<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface BurnRefReceipt {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace BurnRefReceipt {
    export const TYPE_QNAME = "0x1::coin::BurnRefReceipt";

    const TYPE = new TypeDescriptor<BurnRefReceipt>(BurnRefReceipt.TYPE_QNAME);

    export function type(): TypeDescriptor<BurnRefReceipt> {
      return TYPE.apply();
    }
  }

  export interface Coin<T0> {
    value: bigint;
  }

  export namespace Coin {
    export const TYPE_QNAME = "0x1::coin::Coin";

    const TYPE = new TypeDescriptor<Coin<any>>(Coin.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Coin<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface CoinConversionMap {
    coin_to_fungible_asset_map: table.Table<
      type_info.TypeInfo,
      object$.Object<fungible_asset.Metadata>
    >;
  }

  export namespace CoinConversionMap {
    export const TYPE_QNAME = "0x1::coin::CoinConversionMap";

    const TYPE = new TypeDescriptor<CoinConversionMap>(
      CoinConversionMap.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CoinConversionMap> {
      return TYPE.apply();
    }
  }

  export interface CoinDeposit {
    coin_type: string;
    account: MoveAddressType;
    amount: bigint;
  }

  export namespace CoinDeposit {
    export const TYPE_QNAME = "0x1::coin::CoinDeposit";

    const TYPE = new TypeDescriptor<CoinDeposit>(CoinDeposit.TYPE_QNAME);

    export function type(): TypeDescriptor<CoinDeposit> {
      return TYPE.apply();
    }
  }

  export type CoinDepositInstance = TypedEventInstance<CoinDeposit> & {
    data_decoded: CoinDeposit;
    type_arguments: [];
  };

  export interface CoinEventHandleDeletion {
    event_handle_creation_address: MoveAddressType;
    deleted_deposit_event_handle_creation_number: bigint;
    deleted_withdraw_event_handle_creation_number: bigint;
  }

  export namespace CoinEventHandleDeletion {
    export const TYPE_QNAME = "0x1::coin::CoinEventHandleDeletion";

    const TYPE = new TypeDescriptor<CoinEventHandleDeletion>(
      CoinEventHandleDeletion.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CoinEventHandleDeletion> {
      return TYPE.apply();
    }
  }

  export type CoinEventHandleDeletionInstance =
    TypedEventInstance<CoinEventHandleDeletion> & {
      data_decoded: CoinEventHandleDeletion;
      type_arguments: [];
    };

  export interface CoinInfo<T0> {
    name: string;
    symbol: string;
    decimals: number;
    supply: option.Option<optional_aggregator.OptionalAggregator>;
  }

  export namespace CoinInfo {
    export const TYPE_QNAME = "0x1::coin::CoinInfo";

    const TYPE = new TypeDescriptor<CoinInfo<any>>(CoinInfo.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<CoinInfo<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface CoinStore<T0> {
    coin: coin.Coin<T0>;
    frozen: boolean;
    deposit_events: event.EventHandle<coin.DepositEvent>;
    withdraw_events: event.EventHandle<coin.WithdrawEvent>;
  }

  export namespace CoinStore {
    export const TYPE_QNAME = "0x1::coin::CoinStore";

    const TYPE = new TypeDescriptor<CoinStore<any>>(CoinStore.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<CoinStore<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface CoinStoreDeletion {
    coin_type: string;
    event_handle_creation_address: MoveAddressType;
    deleted_deposit_event_handle_creation_number: bigint;
    deleted_withdraw_event_handle_creation_number: bigint;
  }

  export namespace CoinStoreDeletion {
    export const TYPE_QNAME = "0x1::coin::CoinStoreDeletion";

    const TYPE = new TypeDescriptor<CoinStoreDeletion>(
      CoinStoreDeletion.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CoinStoreDeletion> {
      return TYPE.apply();
    }
  }

  export type CoinStoreDeletionInstance =
    TypedEventInstance<CoinStoreDeletion> & {
      data_decoded: CoinStoreDeletion;
      type_arguments: [];
    };

  export interface CoinWithdraw {
    coin_type: string;
    account: MoveAddressType;
    amount: bigint;
  }

  export namespace CoinWithdraw {
    export const TYPE_QNAME = "0x1::coin::CoinWithdraw";

    const TYPE = new TypeDescriptor<CoinWithdraw>(CoinWithdraw.TYPE_QNAME);

    export function type(): TypeDescriptor<CoinWithdraw> {
      return TYPE.apply();
    }
  }

  export type CoinWithdrawInstance = TypedEventInstance<CoinWithdraw> & {
    data_decoded: CoinWithdraw;
    type_arguments: [];
  };

  export interface FreezeCapability<T0> {
    dummy_field: boolean;
  }

  export namespace FreezeCapability {
    export const TYPE_QNAME = "0x1::coin::FreezeCapability";

    const TYPE = new TypeDescriptor<FreezeCapability<any>>(
      FreezeCapability.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<FreezeCapability<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface MigrationFlag {
    dummy_field: boolean;
  }

  export namespace MigrationFlag {
    export const TYPE_QNAME = "0x1::coin::MigrationFlag";

    const TYPE = new TypeDescriptor<MigrationFlag>(MigrationFlag.TYPE_QNAME);

    export function type(): TypeDescriptor<MigrationFlag> {
      return TYPE.apply();
    }
  }

  export interface MintCapability<T0> {
    dummy_field: boolean;
  }

  export namespace MintCapability {
    export const TYPE_QNAME = "0x1::coin::MintCapability";

    const TYPE = new TypeDescriptor<MintCapability<any>>(
      MintCapability.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<MintCapability<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface MintRefReceipt {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace MintRefReceipt {
    export const TYPE_QNAME = "0x1::coin::MintRefReceipt";

    const TYPE = new TypeDescriptor<MintRefReceipt>(MintRefReceipt.TYPE_QNAME);

    export function type(): TypeDescriptor<MintRefReceipt> {
      return TYPE.apply();
    }
  }

  export interface PairCreation {
    coin_type: type_info.TypeInfo;
    fungible_asset_metadata_address: MoveAddressType;
  }

  export namespace PairCreation {
    export const TYPE_QNAME = "0x1::coin::PairCreation";

    const TYPE = new TypeDescriptor<PairCreation>(PairCreation.TYPE_QNAME);

    export function type(): TypeDescriptor<PairCreation> {
      return TYPE.apply();
    }
  }

  export type PairCreationInstance = TypedEventInstance<PairCreation> & {
    data_decoded: PairCreation;
    type_arguments: [];
  };

  export interface PairedCoinType {
    type: type_info.TypeInfo;
  }

  export namespace PairedCoinType {
    export const TYPE_QNAME = "0x1::coin::PairedCoinType";

    const TYPE = new TypeDescriptor<PairedCoinType>(PairedCoinType.TYPE_QNAME);

    export function type(): TypeDescriptor<PairedCoinType> {
      return TYPE.apply();
    }
  }

  export interface PairedFungibleAssetRefs {
    mint_ref_opt: option.Option<fungible_asset.MintRef>;
    transfer_ref_opt: option.Option<fungible_asset.TransferRef>;
    burn_ref_opt: option.Option<fungible_asset.BurnRef>;
  }

  export namespace PairedFungibleAssetRefs {
    export const TYPE_QNAME = "0x1::coin::PairedFungibleAssetRefs";

    const TYPE = new TypeDescriptor<PairedFungibleAssetRefs>(
      PairedFungibleAssetRefs.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PairedFungibleAssetRefs> {
      return TYPE.apply();
    }
  }

  export interface SupplyConfig {
    allow_upgrades: boolean;
  }

  export namespace SupplyConfig {
    export const TYPE_QNAME = "0x1::coin::SupplyConfig";

    const TYPE = new TypeDescriptor<SupplyConfig>(SupplyConfig.TYPE_QNAME);

    export function type(): TypeDescriptor<SupplyConfig> {
      return TYPE.apply();
    }
  }

  export interface TransferRefReceipt {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace TransferRefReceipt {
    export const TYPE_QNAME = "0x1::coin::TransferRefReceipt";

    const TYPE = new TypeDescriptor<TransferRefReceipt>(
      TransferRefReceipt.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransferRefReceipt> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function transfer<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function createCoinConversionMap(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::create_coin_conversion_map",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createPairing<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::create_pairing",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function freezeCoinStore<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::freeze_coin_store",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function migrateCoinStoreToFungibleStore<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::migrate_coin_store_to_fungible_store",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function migrateToFungibleStore<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::migrate_to_fungible_store",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function unfreezeCoinStore<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::unfreeze_coin_store",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function upgradeSupply<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::coin::upgrade_supply",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function name<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::name",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::name");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function symbol$<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::symbol",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::symbol");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function decimals<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[number]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::decimals",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::decimals");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function balance<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::balance",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::balance");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isBalanceAtLeast<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::is_balance_at_least",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::coin::is_balance_at_least",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function supply<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[option.Option<bigint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::supply",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::supply");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function coinSupply<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[option.Option<bigint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::coin_supply",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::coin_supply");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isAccountRegistered<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::is_account_registered",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::coin::is_account_registered",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isCoinInitialized<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::is_coin_initialized",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::coin::is_coin_initialized",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isCoinStoreFrozen<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::is_coin_store_frozen",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::coin::is_coin_store_frozen",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function pairedBurnRefExists<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::paired_burn_ref_exists",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::coin::paired_burn_ref_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function pairedCoin(
      client: Aptos,
      request: {
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      version?: bigint,
    ): Promise<[option.Option<type_info.TypeInfo>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::paired_coin",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::paired_coin");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function pairedMetadata<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[option.Option<object$.Object<fungible_asset.Metadata>>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::paired_metadata",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::coin::paired_metadata");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function pairedMintRefExists<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::paired_mint_ref_exists",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::coin::paired_mint_ref_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function pairedTransferRefExists<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::coin::paired_transfer_ref_exists",
        functionArguments: [],
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::coin::paired_transfer_ref_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface TransferPayload<T0 = any>
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [string];
  }

  export interface CreateCoinConversionMapPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface CreatePairingPayload<T0 = any>
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [string];
  }

  export interface FreezeCoinStorePayload<T0 = any>
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [string];
  }

  export interface MigrateCoinStoreToFungibleStorePayload<T0 = any>
    extends TypedFunctionPayload<[MoveAddressType[]]> {
    arguments_decoded: [MoveAddressType[]];
    type_arguments: [string];
  }

  export interface MigrateToFungibleStorePayload<T0 = any>
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [string];
  }

  export interface UnfreezeCoinStorePayload<T0 = any>
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [string];
  }

  export interface UpgradeSupplyPayload<T0 = any>
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [string];
  }
}

export class guid extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("guid", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): guid {
    return new guid({ ...guid.DEFAULT_OPTIONS, ...options });
  }

  onEventGUID(
    func: (event: guid.GUIDInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, guid.GUIDInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): guid {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "guid::GUID" },
      handlerOptions,
    );
    return this;
  }
}

export namespace guid {
  export interface GUID {
    id: guid.ID;
  }

  export namespace GUID {
    export const TYPE_QNAME = "0x1::guid::GUID";

    const TYPE = new TypeDescriptor<GUID>(GUID.TYPE_QNAME);

    export function type(): TypeDescriptor<GUID> {
      return TYPE.apply();
    }
  }

  export type GUIDInstance = TypedEventInstance<GUID> & {
    data_decoded: GUID;
    type_arguments: [];
  };

  export interface ID {
    creation_num: bigint;
    addr: MoveAddressType;
  }

  export namespace ID {
    export const TYPE_QNAME = "0x1::guid::ID";

    const TYPE = new TypeDescriptor<ID>(ID.TYPE_QNAME);

    export function type(): TypeDescriptor<ID> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace hash {
  export namespace entry {}
  export namespace view {}
}

export class jwks extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("jwks", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): jwks {
    return new jwks({ ...jwks.DEFAULT_OPTIONS, ...options });
  }

  onEntryUpdateFederatedJwkSet(
    func: (call: jwks.UpdateFederatedJwkSetPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      jwks.UpdateFederatedJwkSetPayload
    >,
  ): jwks {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "jwks::update_federated_jwk_set",
      },
      handlerOptions,
    );
    return this;
  }

  onEventObservedJWKsUpdated(
    func: (event: jwks.ObservedJWKsUpdatedInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      jwks.ObservedJWKsUpdatedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): jwks {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "jwks::ObservedJWKsUpdated" },
      handlerOptions,
    );
    return this;
  }
}

export namespace jwks {
  export interface AllProvidersJWKs {
    entries: jwks.ProviderJWKs[];
  }

  export namespace AllProvidersJWKs {
    export const TYPE_QNAME = "0x1::jwks::AllProvidersJWKs";

    const TYPE = new TypeDescriptor<AllProvidersJWKs>(
      AllProvidersJWKs.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AllProvidersJWKs> {
      return TYPE.apply();
    }
  }

  export interface FederatedJWKs {
    jwks: jwks.AllProvidersJWKs;
  }

  export namespace FederatedJWKs {
    export const TYPE_QNAME = "0x1::jwks::FederatedJWKs";

    const TYPE = new TypeDescriptor<FederatedJWKs>(FederatedJWKs.TYPE_QNAME);

    export function type(): TypeDescriptor<FederatedJWKs> {
      return TYPE.apply();
    }
  }

  export interface JWK {
    variant: copyable_any.Any;
  }

  export namespace JWK {
    export const TYPE_QNAME = "0x1::jwks::JWK";

    const TYPE = new TypeDescriptor<JWK>(JWK.TYPE_QNAME);

    export function type(): TypeDescriptor<JWK> {
      return TYPE.apply();
    }
  }

  export interface OIDCProvider {
    name: string;
    config_url: string;
  }

  export namespace OIDCProvider {
    export const TYPE_QNAME = "0x1::jwks::OIDCProvider";

    const TYPE = new TypeDescriptor<OIDCProvider>(OIDCProvider.TYPE_QNAME);

    export function type(): TypeDescriptor<OIDCProvider> {
      return TYPE.apply();
    }
  }

  export interface ObservedJWKs {
    jwks: jwks.AllProvidersJWKs;
  }

  export namespace ObservedJWKs {
    export const TYPE_QNAME = "0x1::jwks::ObservedJWKs";

    const TYPE = new TypeDescriptor<ObservedJWKs>(ObservedJWKs.TYPE_QNAME);

    export function type(): TypeDescriptor<ObservedJWKs> {
      return TYPE.apply();
    }
  }

  export interface ObservedJWKsUpdated {
    epoch: bigint;
    jwks: jwks.AllProvidersJWKs;
  }

  export namespace ObservedJWKsUpdated {
    export const TYPE_QNAME = "0x1::jwks::ObservedJWKsUpdated";

    const TYPE = new TypeDescriptor<ObservedJWKsUpdated>(
      ObservedJWKsUpdated.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ObservedJWKsUpdated> {
      return TYPE.apply();
    }
  }

  export type ObservedJWKsUpdatedInstance =
    TypedEventInstance<ObservedJWKsUpdated> & {
      data_decoded: ObservedJWKsUpdated;
      type_arguments: [];
    };

  export interface Patch {
    variant: copyable_any.Any;
  }

  export namespace Patch {
    export const TYPE_QNAME = "0x1::jwks::Patch";

    const TYPE = new TypeDescriptor<Patch>(Patch.TYPE_QNAME);

    export function type(): TypeDescriptor<Patch> {
      return TYPE.apply();
    }
  }

  export interface PatchRemoveAll {
    dummy_field: boolean;
  }

  export namespace PatchRemoveAll {
    export const TYPE_QNAME = "0x1::jwks::PatchRemoveAll";

    const TYPE = new TypeDescriptor<PatchRemoveAll>(PatchRemoveAll.TYPE_QNAME);

    export function type(): TypeDescriptor<PatchRemoveAll> {
      return TYPE.apply();
    }
  }

  export interface PatchRemoveIssuer {
    issuer: string;
  }

  export namespace PatchRemoveIssuer {
    export const TYPE_QNAME = "0x1::jwks::PatchRemoveIssuer";

    const TYPE = new TypeDescriptor<PatchRemoveIssuer>(
      PatchRemoveIssuer.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PatchRemoveIssuer> {
      return TYPE.apply();
    }
  }

  export interface PatchRemoveJWK {
    issuer: string;
    jwk_id: string;
  }

  export namespace PatchRemoveJWK {
    export const TYPE_QNAME = "0x1::jwks::PatchRemoveJWK";

    const TYPE = new TypeDescriptor<PatchRemoveJWK>(PatchRemoveJWK.TYPE_QNAME);

    export function type(): TypeDescriptor<PatchRemoveJWK> {
      return TYPE.apply();
    }
  }

  export interface PatchUpsertJWK {
    issuer: string;
    jwk: jwks.JWK;
  }

  export namespace PatchUpsertJWK {
    export const TYPE_QNAME = "0x1::jwks::PatchUpsertJWK";

    const TYPE = new TypeDescriptor<PatchUpsertJWK>(PatchUpsertJWK.TYPE_QNAME);

    export function type(): TypeDescriptor<PatchUpsertJWK> {
      return TYPE.apply();
    }
  }

  export interface PatchedJWKs {
    jwks: jwks.AllProvidersJWKs;
  }

  export namespace PatchedJWKs {
    export const TYPE_QNAME = "0x1::jwks::PatchedJWKs";

    const TYPE = new TypeDescriptor<PatchedJWKs>(PatchedJWKs.TYPE_QNAME);

    export function type(): TypeDescriptor<PatchedJWKs> {
      return TYPE.apply();
    }
  }

  export interface Patches {
    patches: jwks.Patch[];
  }

  export namespace Patches {
    export const TYPE_QNAME = "0x1::jwks::Patches";

    const TYPE = new TypeDescriptor<Patches>(Patches.TYPE_QNAME);

    export function type(): TypeDescriptor<Patches> {
      return TYPE.apply();
    }
  }

  export interface ProviderJWKs {
    issuer: string;
    version: bigint;
    jwks: jwks.JWK[];
  }

  export namespace ProviderJWKs {
    export const TYPE_QNAME = "0x1::jwks::ProviderJWKs";

    const TYPE = new TypeDescriptor<ProviderJWKs>(ProviderJWKs.TYPE_QNAME);

    export function type(): TypeDescriptor<ProviderJWKs> {
      return TYPE.apply();
    }
  }

  export interface RSA_JWK {
    kid: string;
    kty: string;
    alg: string;
    e: string;
    n: string;
  }

  export namespace RSA_JWK {
    export const TYPE_QNAME = "0x1::jwks::RSA_JWK";

    const TYPE = new TypeDescriptor<RSA_JWK>(RSA_JWK.TYPE_QNAME);

    export function type(): TypeDescriptor<RSA_JWK> {
      return TYPE.apply();
    }
  }

  export interface SupportedOIDCProviders {
    providers: jwks.OIDCProvider[];
  }

  export namespace SupportedOIDCProviders {
    export const TYPE_QNAME = "0x1::jwks::SupportedOIDCProviders";

    const TYPE = new TypeDescriptor<SupportedOIDCProviders>(
      SupportedOIDCProviders.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SupportedOIDCProviders> {
      return TYPE.apply();
    }
  }

  export interface UnsupportedJWK {
    id: string;
    payload: string;
  }

  export namespace UnsupportedJWK {
    export const TYPE_QNAME = "0x1::jwks::UnsupportedJWK";

    const TYPE = new TypeDescriptor<UnsupportedJWK>(UnsupportedJWK.TYPE_QNAME);

    export function type(): TypeDescriptor<UnsupportedJWK> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function updateFederatedJwkSet(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string[], string[], string[], string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::jwks::update_federated_jwk_set",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface UpdateFederatedJwkSetPayload
    extends TypedFunctionPayload<
      [string, string[], string[], string[], string[]]
    > {
    arguments_decoded: [string, string[], string[], string[], string[]];
    type_arguments: [];
  }
}

export namespace util {
  export namespace entry {}
  export namespace view {}
}

export class block extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("block", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): block {
    return new block({ ...block.DEFAULT_OPTIONS, ...options });
  }

  onEventNewBlock(
    func: (event: block.NewBlockInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, block.NewBlockInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): block {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "block::NewBlock" },
      handlerOptions,
    );
    return this;
  }

  onEventNewBlockEvent(
    func: (event: block.NewBlockEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      block.NewBlockEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): block {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "block::NewBlockEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateEpochInterval(
    func: (event: block.UpdateEpochIntervalInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      block.UpdateEpochIntervalInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): block {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "block::UpdateEpochInterval" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateEpochIntervalEvent(
    func: (
      event: block.UpdateEpochIntervalEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      block.UpdateEpochIntervalEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): block {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "block::UpdateEpochIntervalEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace block {
  export interface BlockResource {
    height: bigint;
    epoch_interval: bigint;
    new_block_events: event.EventHandle<block.NewBlockEvent>;
    update_epoch_interval_events: event.EventHandle<block.UpdateEpochIntervalEvent>;
  }

  export namespace BlockResource {
    export const TYPE_QNAME = "0x1::block::BlockResource";

    const TYPE = new TypeDescriptor<BlockResource>(BlockResource.TYPE_QNAME);

    export function type(): TypeDescriptor<BlockResource> {
      return TYPE.apply();
    }
  }

  export interface CommitHistory {
    max_capacity: number;
    next_idx: number;
    table: table_with_length.TableWithLength<number, block.NewBlockEvent>;
  }

  export namespace CommitHistory {
    export const TYPE_QNAME = "0x1::block::CommitHistory";

    const TYPE = new TypeDescriptor<CommitHistory>(CommitHistory.TYPE_QNAME);

    export function type(): TypeDescriptor<CommitHistory> {
      return TYPE.apply();
    }
  }

  export interface NewBlock {
    hash: MoveAddressType;
    epoch: bigint;
    round: bigint;
    height: bigint;
    previous_block_votes_bitvec: string;
    proposer: MoveAddressType;
    failed_proposer_indices: bigint[];
    time_microseconds: bigint;
  }

  export namespace NewBlock {
    export const TYPE_QNAME = "0x1::block::NewBlock";

    const TYPE = new TypeDescriptor<NewBlock>(NewBlock.TYPE_QNAME);

    export function type(): TypeDescriptor<NewBlock> {
      return TYPE.apply();
    }
  }

  export type NewBlockInstance = TypedEventInstance<NewBlock> & {
    data_decoded: NewBlock;
    type_arguments: [];
  };

  export interface NewBlockEvent {
    hash: MoveAddressType;
    epoch: bigint;
    round: bigint;
    height: bigint;
    previous_block_votes_bitvec: string;
    proposer: MoveAddressType;
    failed_proposer_indices: bigint[];
    time_microseconds: bigint;
  }

  export namespace NewBlockEvent {
    export const TYPE_QNAME = "0x1::block::NewBlockEvent";

    const TYPE = new TypeDescriptor<NewBlockEvent>(NewBlockEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<NewBlockEvent> {
      return TYPE.apply();
    }
  }

  export type NewBlockEventInstance = TypedEventInstance<NewBlockEvent> & {
    data_decoded: NewBlockEvent;
    type_arguments: [];
  };

  export interface UpdateEpochInterval {
    old_epoch_interval: bigint;
    new_epoch_interval: bigint;
  }

  export namespace UpdateEpochInterval {
    export const TYPE_QNAME = "0x1::block::UpdateEpochInterval";

    const TYPE = new TypeDescriptor<UpdateEpochInterval>(
      UpdateEpochInterval.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateEpochInterval> {
      return TYPE.apply();
    }
  }

  export type UpdateEpochIntervalInstance =
    TypedEventInstance<UpdateEpochInterval> & {
      data_decoded: UpdateEpochInterval;
      type_arguments: [];
    };

  export interface UpdateEpochIntervalEvent {
    old_epoch_interval: bigint;
    new_epoch_interval: bigint;
  }

  export namespace UpdateEpochIntervalEvent {
    export const TYPE_QNAME = "0x1::block::UpdateEpochIntervalEvent";

    const TYPE = new TypeDescriptor<UpdateEpochIntervalEvent>(
      UpdateEpochIntervalEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateEpochIntervalEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateEpochIntervalEventInstance =
    TypedEventInstance<UpdateEpochIntervalEvent> & {
      data_decoded: UpdateEpochIntervalEvent;
      type_arguments: [];
    };

  export namespace entry {}
  export namespace view {
    export async function getCurrentBlockHeight(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::block::get_current_block_height",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::block::get_current_block_height",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getEpochIntervalSecs(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::block::get_epoch_interval_secs",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::block::get_epoch_interval_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace debug {
  export namespace entry {}
  export namespace view {}
}

export namespace error {
  export namespace entry {}
  export namespace view {}
}

export namespace event {
  export interface EventHandle<T0> {
    counter: bigint;
    guid: guid.GUID;
  }

  export namespace EventHandle {
    export const TYPE_QNAME = "0x1::event::EventHandle";

    const TYPE = new TypeDescriptor<EventHandle<any>>(EventHandle.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<EventHandle<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class stake extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("stake", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): stake {
    return new stake({ ...stake.DEFAULT_OPTIONS, ...options });
  }

  onEntryWithdraw(
    func: (call: stake.WithdrawPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, stake.WithdrawPayload>,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::withdraw",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddStake(
    func: (call: stake.AddStakePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, stake.AddStakePayload>,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::add_stake",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryIncreaseLockup(
    func: (call: stake.IncreaseLockupPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.IncreaseLockupPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::increase_lockup",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryInitializeStakeOwner(
    func: (call: stake.InitializeStakeOwnerPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.InitializeStakeOwnerPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::initialize_stake_owner",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryInitializeValidator(
    func: (call: stake.InitializeValidatorPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.InitializeValidatorPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::initialize_validator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryJoinValidatorSet(
    func: (call: stake.JoinValidatorSetPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.JoinValidatorSetPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::join_validator_set",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryLeaveValidatorSet(
    func: (call: stake.LeaveValidatorSetPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.LeaveValidatorSetPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::leave_validator_set",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryReactivateStake(
    func: (call: stake.ReactivateStakePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.ReactivateStakePayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::reactivate_stake",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRotateConsensusKey(
    func: (call: stake.RotateConsensusKeyPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.RotateConsensusKeyPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::rotate_consensus_key",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetDelegatedVoter(
    func: (call: stake.SetDelegatedVoterPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.SetDelegatedVoterPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::set_delegated_voter",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetOperator(
    func: (call: stake.SetOperatorPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, stake.SetOperatorPayload>,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::set_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnlock(
    func: (call: stake.UnlockPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, stake.UnlockPayload>,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::unlock",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateNetworkAndFullnodeAddresses(
    func: (
      call: stake.UpdateNetworkAndFullnodeAddressesPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.UpdateNetworkAndFullnodeAddressesPayload
    >,
  ): stake {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "stake::update_network_and_fullnode_addresses",
      },
      handlerOptions,
    );
    return this;
  }

  onEventAddStake(
    func: (event: stake.AddStakeInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, stake.AddStakeInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::AddStake" },
      handlerOptions,
    );
    return this;
  }

  onEventAddStakeEvent(
    func: (event: stake.AddStakeEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.AddStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::AddStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventDistributeRewards(
    func: (event: stake.DistributeRewardsInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.DistributeRewardsInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::DistributeRewards" },
      handlerOptions,
    );
    return this;
  }

  onEventDistributeRewardsEvent(
    func: (
      event: stake.DistributeRewardsEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.DistributeRewardsEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::DistributeRewardsEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventDistributeTransactionFee(
    func: (
      event: stake.DistributeTransactionFeeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.DistributeTransactionFeeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::DistributeTransactionFee" },
      handlerOptions,
    );
    return this;
  }

  onEventIncreaseLockup(
    func: (event: stake.IncreaseLockupInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.IncreaseLockupInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::IncreaseLockup" },
      handlerOptions,
    );
    return this;
  }

  onEventIncreaseLockupEvent(
    func: (event: stake.IncreaseLockupEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.IncreaseLockupEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::IncreaseLockupEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventIndividualValidatorPerformance(
    func: (
      event: stake.IndividualValidatorPerformanceInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.IndividualValidatorPerformanceInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::IndividualValidatorPerformance" },
      handlerOptions,
    );
    return this;
  }

  onEventJoinValidatorSet(
    func: (event: stake.JoinValidatorSetInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.JoinValidatorSetInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::JoinValidatorSet" },
      handlerOptions,
    );
    return this;
  }

  onEventJoinValidatorSetEvent(
    func: (
      event: stake.JoinValidatorSetEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.JoinValidatorSetEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::JoinValidatorSetEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventLeaveValidatorSet(
    func: (event: stake.LeaveValidatorSetInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.LeaveValidatorSetInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::LeaveValidatorSet" },
      handlerOptions,
    );
    return this;
  }

  onEventLeaveValidatorSetEvent(
    func: (
      event: stake.LeaveValidatorSetEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.LeaveValidatorSetEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::LeaveValidatorSetEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventReactivateStake(
    func: (event: stake.ReactivateStakeInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.ReactivateStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::ReactivateStake" },
      handlerOptions,
    );
    return this;
  }

  onEventReactivateStakeEvent(
    func: (
      event: stake.ReactivateStakeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.ReactivateStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::ReactivateStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventRegisterValidatorCandidate(
    func: (
      event: stake.RegisterValidatorCandidateInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.RegisterValidatorCandidateInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::RegisterValidatorCandidate" },
      handlerOptions,
    );
    return this;
  }

  onEventRegisterValidatorCandidateEvent(
    func: (
      event: stake.RegisterValidatorCandidateEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.RegisterValidatorCandidateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "stake::RegisterValidatorCandidateEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventRotateConsensusKey(
    func: (event: stake.RotateConsensusKeyInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.RotateConsensusKeyInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::RotateConsensusKey" },
      handlerOptions,
    );
    return this;
  }

  onEventRotateConsensusKeyEvent(
    func: (
      event: stake.RotateConsensusKeyEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.RotateConsensusKeyEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::RotateConsensusKeyEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventSetOperator(
    func: (event: stake.SetOperatorInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, stake.SetOperatorInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::SetOperator" },
      handlerOptions,
    );
    return this;
  }

  onEventSetOperatorEvent(
    func: (event: stake.SetOperatorEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.SetOperatorEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::SetOperatorEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockStake(
    func: (event: stake.UnlockStakeInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, stake.UnlockStakeInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::UnlockStake" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockStakeEvent(
    func: (event: stake.UnlockStakeEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.UnlockStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::UnlockStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateNetworkAndFullnodeAddresses(
    func: (
      event: stake.UpdateNetworkAndFullnodeAddressesInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.UpdateNetworkAndFullnodeAddressesInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "stake::UpdateNetworkAndFullnodeAddresses",
      },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateNetworkAndFullnodeAddressesEvent(
    func: (
      event: stake.UpdateNetworkAndFullnodeAddressesEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.UpdateNetworkAndFullnodeAddressesEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "stake::UpdateNetworkAndFullnodeAddressesEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventValidatorSetLivenessFallback(
    func: (
      event: stake.ValidatorSetLivenessFallbackInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.ValidatorSetLivenessFallbackInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::ValidatorSetLivenessFallback" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawStake(
    func: (event: stake.WithdrawStakeInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.WithdrawStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::WithdrawStake" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawStakeEvent(
    func: (event: stake.WithdrawStakeEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      stake.WithdrawStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): stake {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "stake::WithdrawStakeEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace stake {
  export interface AddStake {
    pool_address: MoveAddressType;
    amount_added: bigint;
  }

  export namespace AddStake {
    export const TYPE_QNAME = "0x1::stake::AddStake";

    const TYPE = new TypeDescriptor<AddStake>(AddStake.TYPE_QNAME);

    export function type(): TypeDescriptor<AddStake> {
      return TYPE.apply();
    }
  }

  export type AddStakeInstance = TypedEventInstance<AddStake> & {
    data_decoded: AddStake;
    type_arguments: [];
  };

  export interface AddStakeEvent {
    pool_address: MoveAddressType;
    amount_added: bigint;
  }

  export namespace AddStakeEvent {
    export const TYPE_QNAME = "0x1::stake::AddStakeEvent";

    const TYPE = new TypeDescriptor<AddStakeEvent>(AddStakeEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<AddStakeEvent> {
      return TYPE.apply();
    }
  }

  export type AddStakeEventInstance = TypedEventInstance<AddStakeEvent> & {
    data_decoded: AddStakeEvent;
    type_arguments: [];
  };

  export interface AllowedValidators {
    accounts: MoveAddressType[];
  }

  export namespace AllowedValidators {
    export const TYPE_QNAME = "0x1::stake::AllowedValidators";

    const TYPE = new TypeDescriptor<AllowedValidators>(
      AllowedValidators.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AllowedValidators> {
      return TYPE.apply();
    }
  }

  export interface AptosCoinCapabilities {
    mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
  }

  export namespace AptosCoinCapabilities {
    export const TYPE_QNAME = "0x1::stake::AptosCoinCapabilities";

    const TYPE = new TypeDescriptor<AptosCoinCapabilities>(
      AptosCoinCapabilities.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AptosCoinCapabilities> {
      return TYPE.apply();
    }
  }

  export interface DistributeRewards {
    pool_address: MoveAddressType;
    rewards_amount: bigint;
  }

  export namespace DistributeRewards {
    export const TYPE_QNAME = "0x1::stake::DistributeRewards";

    const TYPE = new TypeDescriptor<DistributeRewards>(
      DistributeRewards.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DistributeRewards> {
      return TYPE.apply();
    }
  }

  export type DistributeRewardsInstance =
    TypedEventInstance<DistributeRewards> & {
      data_decoded: DistributeRewards;
      type_arguments: [];
    };

  export interface DistributeRewardsEvent {
    pool_address: MoveAddressType;
    rewards_amount: bigint;
  }

  export namespace DistributeRewardsEvent {
    export const TYPE_QNAME = "0x1::stake::DistributeRewardsEvent";

    const TYPE = new TypeDescriptor<DistributeRewardsEvent>(
      DistributeRewardsEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DistributeRewardsEvent> {
      return TYPE.apply();
    }
  }

  export type DistributeRewardsEventInstance =
    TypedEventInstance<DistributeRewardsEvent> & {
      data_decoded: DistributeRewardsEvent;
      type_arguments: [];
    };

  export interface DistributeTransactionFee {
    pool_address: MoveAddressType;
    fee_amount: bigint;
  }

  export namespace DistributeTransactionFee {
    export const TYPE_QNAME = "0x1::stake::DistributeTransactionFee";

    const TYPE = new TypeDescriptor<DistributeTransactionFee>(
      DistributeTransactionFee.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DistributeTransactionFee> {
      return TYPE.apply();
    }
  }

  export type DistributeTransactionFeeInstance =
    TypedEventInstance<DistributeTransactionFee> & {
      data_decoded: DistributeTransactionFee;
      type_arguments: [];
    };

  export interface IncreaseLockup {
    pool_address: MoveAddressType;
    old_locked_until_secs: bigint;
    new_locked_until_secs: bigint;
  }

  export namespace IncreaseLockup {
    export const TYPE_QNAME = "0x1::stake::IncreaseLockup";

    const TYPE = new TypeDescriptor<IncreaseLockup>(IncreaseLockup.TYPE_QNAME);

    export function type(): TypeDescriptor<IncreaseLockup> {
      return TYPE.apply();
    }
  }

  export type IncreaseLockupInstance = TypedEventInstance<IncreaseLockup> & {
    data_decoded: IncreaseLockup;
    type_arguments: [];
  };

  export interface IncreaseLockupEvent {
    pool_address: MoveAddressType;
    old_locked_until_secs: bigint;
    new_locked_until_secs: bigint;
  }

  export namespace IncreaseLockupEvent {
    export const TYPE_QNAME = "0x1::stake::IncreaseLockupEvent";

    const TYPE = new TypeDescriptor<IncreaseLockupEvent>(
      IncreaseLockupEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<IncreaseLockupEvent> {
      return TYPE.apply();
    }
  }

  export type IncreaseLockupEventInstance =
    TypedEventInstance<IncreaseLockupEvent> & {
      data_decoded: IncreaseLockupEvent;
      type_arguments: [];
    };

  export interface IndividualValidatorPerformance {
    successful_proposals: bigint;
    failed_proposals: bigint;
  }

  export namespace IndividualValidatorPerformance {
    export const TYPE_QNAME = "0x1::stake::IndividualValidatorPerformance";

    const TYPE = new TypeDescriptor<IndividualValidatorPerformance>(
      IndividualValidatorPerformance.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<IndividualValidatorPerformance> {
      return TYPE.apply();
    }
  }

  export type IndividualValidatorPerformanceInstance =
    TypedEventInstance<IndividualValidatorPerformance> & {
      data_decoded: IndividualValidatorPerformance;
      type_arguments: [];
    };

  export interface JoinValidatorSet {
    pool_address: MoveAddressType;
  }

  export namespace JoinValidatorSet {
    export const TYPE_QNAME = "0x1::stake::JoinValidatorSet";

    const TYPE = new TypeDescriptor<JoinValidatorSet>(
      JoinValidatorSet.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<JoinValidatorSet> {
      return TYPE.apply();
    }
  }

  export type JoinValidatorSetInstance =
    TypedEventInstance<JoinValidatorSet> & {
      data_decoded: JoinValidatorSet;
      type_arguments: [];
    };

  export interface JoinValidatorSetEvent {
    pool_address: MoveAddressType;
  }

  export namespace JoinValidatorSetEvent {
    export const TYPE_QNAME = "0x1::stake::JoinValidatorSetEvent";

    const TYPE = new TypeDescriptor<JoinValidatorSetEvent>(
      JoinValidatorSetEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<JoinValidatorSetEvent> {
      return TYPE.apply();
    }
  }

  export type JoinValidatorSetEventInstance =
    TypedEventInstance<JoinValidatorSetEvent> & {
      data_decoded: JoinValidatorSetEvent;
      type_arguments: [];
    };

  export interface LeaveValidatorSet {
    pool_address: MoveAddressType;
  }

  export namespace LeaveValidatorSet {
    export const TYPE_QNAME = "0x1::stake::LeaveValidatorSet";

    const TYPE = new TypeDescriptor<LeaveValidatorSet>(
      LeaveValidatorSet.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<LeaveValidatorSet> {
      return TYPE.apply();
    }
  }

  export type LeaveValidatorSetInstance =
    TypedEventInstance<LeaveValidatorSet> & {
      data_decoded: LeaveValidatorSet;
      type_arguments: [];
    };

  export interface LeaveValidatorSetEvent {
    pool_address: MoveAddressType;
  }

  export namespace LeaveValidatorSetEvent {
    export const TYPE_QNAME = "0x1::stake::LeaveValidatorSetEvent";

    const TYPE = new TypeDescriptor<LeaveValidatorSetEvent>(
      LeaveValidatorSetEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<LeaveValidatorSetEvent> {
      return TYPE.apply();
    }
  }

  export type LeaveValidatorSetEventInstance =
    TypedEventInstance<LeaveValidatorSetEvent> & {
      data_decoded: LeaveValidatorSetEvent;
      type_arguments: [];
    };

  export interface OwnerCapability {
    pool_address: MoveAddressType;
  }

  export namespace OwnerCapability {
    export const TYPE_QNAME = "0x1::stake::OwnerCapability";

    const TYPE = new TypeDescriptor<OwnerCapability>(
      OwnerCapability.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<OwnerCapability> {
      return TYPE.apply();
    }
  }

  export interface PendingTransactionFee {
    pending_fee_by_validator: big_ordered_map.BigOrderedMap<
      bigint,
      aggregator_v2.Aggregator<bigint>
    >;
  }

  export namespace PendingTransactionFee {
    export const TYPE_QNAME = "0x1::stake::PendingTransactionFee";

    const TYPE = new TypeDescriptor<PendingTransactionFee>(
      PendingTransactionFee.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PendingTransactionFee> {
      return TYPE.apply();
    }
  }

  export interface PrecomputedValidatorSet {
    validator_set: stake.ValidatorSet;
    is_liveness_fallback: boolean;
  }

  export namespace PrecomputedValidatorSet {
    export const TYPE_QNAME = "0x1::stake::PrecomputedValidatorSet";

    const TYPE = new TypeDescriptor<PrecomputedValidatorSet>(
      PrecomputedValidatorSet.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PrecomputedValidatorSet> {
      return TYPE.apply();
    }
  }

  export interface ReactivateStake {
    pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace ReactivateStake {
    export const TYPE_QNAME = "0x1::stake::ReactivateStake";

    const TYPE = new TypeDescriptor<ReactivateStake>(
      ReactivateStake.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ReactivateStake> {
      return TYPE.apply();
    }
  }

  export type ReactivateStakeInstance = TypedEventInstance<ReactivateStake> & {
    data_decoded: ReactivateStake;
    type_arguments: [];
  };

  export interface ReactivateStakeEvent {
    pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace ReactivateStakeEvent {
    export const TYPE_QNAME = "0x1::stake::ReactivateStakeEvent";

    const TYPE = new TypeDescriptor<ReactivateStakeEvent>(
      ReactivateStakeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ReactivateStakeEvent> {
      return TYPE.apply();
    }
  }

  export type ReactivateStakeEventInstance =
    TypedEventInstance<ReactivateStakeEvent> & {
      data_decoded: ReactivateStakeEvent;
      type_arguments: [];
    };

  export interface RegisterValidatorCandidate {
    pool_address: MoveAddressType;
  }

  export namespace RegisterValidatorCandidate {
    export const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidate";

    const TYPE = new TypeDescriptor<RegisterValidatorCandidate>(
      RegisterValidatorCandidate.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RegisterValidatorCandidate> {
      return TYPE.apply();
    }
  }

  export type RegisterValidatorCandidateInstance =
    TypedEventInstance<RegisterValidatorCandidate> & {
      data_decoded: RegisterValidatorCandidate;
      type_arguments: [];
    };

  export interface RegisterValidatorCandidateEvent {
    pool_address: MoveAddressType;
  }

  export namespace RegisterValidatorCandidateEvent {
    export const TYPE_QNAME = "0x1::stake::RegisterValidatorCandidateEvent";

    const TYPE = new TypeDescriptor<RegisterValidatorCandidateEvent>(
      RegisterValidatorCandidateEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RegisterValidatorCandidateEvent> {
      return TYPE.apply();
    }
  }

  export type RegisterValidatorCandidateEventInstance =
    TypedEventInstance<RegisterValidatorCandidateEvent> & {
      data_decoded: RegisterValidatorCandidateEvent;
      type_arguments: [];
    };

  export interface RotateConsensusKey {
    pool_address: MoveAddressType;
    old_consensus_pubkey: string;
    new_consensus_pubkey: string;
  }

  export namespace RotateConsensusKey {
    export const TYPE_QNAME = "0x1::stake::RotateConsensusKey";

    const TYPE = new TypeDescriptor<RotateConsensusKey>(
      RotateConsensusKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RotateConsensusKey> {
      return TYPE.apply();
    }
  }

  export type RotateConsensusKeyInstance =
    TypedEventInstance<RotateConsensusKey> & {
      data_decoded: RotateConsensusKey;
      type_arguments: [];
    };

  export interface RotateConsensusKeyEvent {
    pool_address: MoveAddressType;
    old_consensus_pubkey: string;
    new_consensus_pubkey: string;
  }

  export namespace RotateConsensusKeyEvent {
    export const TYPE_QNAME = "0x1::stake::RotateConsensusKeyEvent";

    const TYPE = new TypeDescriptor<RotateConsensusKeyEvent>(
      RotateConsensusKeyEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RotateConsensusKeyEvent> {
      return TYPE.apply();
    }
  }

  export type RotateConsensusKeyEventInstance =
    TypedEventInstance<RotateConsensusKeyEvent> & {
      data_decoded: RotateConsensusKeyEvent;
      type_arguments: [];
    };

  export interface SetOperator {
    pool_address: MoveAddressType;
    old_operator: MoveAddressType;
    new_operator: MoveAddressType;
  }

  export namespace SetOperator {
    export const TYPE_QNAME = "0x1::stake::SetOperator";

    const TYPE = new TypeDescriptor<SetOperator>(SetOperator.TYPE_QNAME);

    export function type(): TypeDescriptor<SetOperator> {
      return TYPE.apply();
    }
  }

  export type SetOperatorInstance = TypedEventInstance<SetOperator> & {
    data_decoded: SetOperator;
    type_arguments: [];
  };

  export interface SetOperatorEvent {
    pool_address: MoveAddressType;
    old_operator: MoveAddressType;
    new_operator: MoveAddressType;
  }

  export namespace SetOperatorEvent {
    export const TYPE_QNAME = "0x1::stake::SetOperatorEvent";

    const TYPE = new TypeDescriptor<SetOperatorEvent>(
      SetOperatorEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SetOperatorEvent> {
      return TYPE.apply();
    }
  }

  export type SetOperatorEventInstance =
    TypedEventInstance<SetOperatorEvent> & {
      data_decoded: SetOperatorEvent;
      type_arguments: [];
    };

  export interface StakeManagementPermission {
    dummy_field: boolean;
  }

  export namespace StakeManagementPermission {
    export const TYPE_QNAME = "0x1::stake::StakeManagementPermission";

    const TYPE = new TypeDescriptor<StakeManagementPermission>(
      StakeManagementPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StakeManagementPermission> {
      return TYPE.apply();
    }
  }

  export interface StakePool {
    active: coin.Coin<aptos_coin.AptosCoin>;
    inactive: coin.Coin<aptos_coin.AptosCoin>;
    pending_active: coin.Coin<aptos_coin.AptosCoin>;
    pending_inactive: coin.Coin<aptos_coin.AptosCoin>;
    locked_until_secs: bigint;
    operator_address: MoveAddressType;
    delegated_voter: MoveAddressType;
    initialize_validator_events: event.EventHandle<stake.RegisterValidatorCandidateEvent>;
    set_operator_events: event.EventHandle<stake.SetOperatorEvent>;
    add_stake_events: event.EventHandle<stake.AddStakeEvent>;
    reactivate_stake_events: event.EventHandle<stake.ReactivateStakeEvent>;
    rotate_consensus_key_events: event.EventHandle<stake.RotateConsensusKeyEvent>;
    update_network_and_fullnode_addresses_events: event.EventHandle<stake.UpdateNetworkAndFullnodeAddressesEvent>;
    increase_lockup_events: event.EventHandle<stake.IncreaseLockupEvent>;
    join_validator_set_events: event.EventHandle<stake.JoinValidatorSetEvent>;
    distribute_rewards_events: event.EventHandle<stake.DistributeRewardsEvent>;
    unlock_stake_events: event.EventHandle<stake.UnlockStakeEvent>;
    withdraw_stake_events: event.EventHandle<stake.WithdrawStakeEvent>;
    leave_validator_set_events: event.EventHandle<stake.LeaveValidatorSetEvent>;
  }

  export namespace StakePool {
    export const TYPE_QNAME = "0x1::stake::StakePool";

    const TYPE = new TypeDescriptor<StakePool>(StakePool.TYPE_QNAME);

    export function type(): TypeDescriptor<StakePool> {
      return TYPE.apply();
    }
  }

  export interface TransactionFeeConfig {}

  export namespace TransactionFeeConfig {
    export const TYPE_QNAME = "0x1::stake::TransactionFeeConfig";

    const TYPE = new TypeDescriptor<TransactionFeeConfig>(
      TransactionFeeConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransactionFeeConfig> {
      return TYPE.apply();
    }
  }

  export interface UnlockStake {
    pool_address: MoveAddressType;
    amount_unlocked: bigint;
  }

  export namespace UnlockStake {
    export const TYPE_QNAME = "0x1::stake::UnlockStake";

    const TYPE = new TypeDescriptor<UnlockStake>(UnlockStake.TYPE_QNAME);

    export function type(): TypeDescriptor<UnlockStake> {
      return TYPE.apply();
    }
  }

  export type UnlockStakeInstance = TypedEventInstance<UnlockStake> & {
    data_decoded: UnlockStake;
    type_arguments: [];
  };

  export interface UnlockStakeEvent {
    pool_address: MoveAddressType;
    amount_unlocked: bigint;
  }

  export namespace UnlockStakeEvent {
    export const TYPE_QNAME = "0x1::stake::UnlockStakeEvent";

    const TYPE = new TypeDescriptor<UnlockStakeEvent>(
      UnlockStakeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UnlockStakeEvent> {
      return TYPE.apply();
    }
  }

  export type UnlockStakeEventInstance =
    TypedEventInstance<UnlockStakeEvent> & {
      data_decoded: UnlockStakeEvent;
      type_arguments: [];
    };

  export interface UpdateNetworkAndFullnodeAddresses {
    pool_address: MoveAddressType;
    old_network_addresses: string;
    new_network_addresses: string;
    old_fullnode_addresses: string;
    new_fullnode_addresses: string;
  }

  export namespace UpdateNetworkAndFullnodeAddresses {
    export const TYPE_QNAME = "0x1::stake::UpdateNetworkAndFullnodeAddresses";

    const TYPE = new TypeDescriptor<UpdateNetworkAndFullnodeAddresses>(
      UpdateNetworkAndFullnodeAddresses.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateNetworkAndFullnodeAddresses> {
      return TYPE.apply();
    }
  }

  export type UpdateNetworkAndFullnodeAddressesInstance =
    TypedEventInstance<UpdateNetworkAndFullnodeAddresses> & {
      data_decoded: UpdateNetworkAndFullnodeAddresses;
      type_arguments: [];
    };

  export interface UpdateNetworkAndFullnodeAddressesEvent {
    pool_address: MoveAddressType;
    old_network_addresses: string;
    new_network_addresses: string;
    old_fullnode_addresses: string;
    new_fullnode_addresses: string;
  }

  export namespace UpdateNetworkAndFullnodeAddressesEvent {
    export const TYPE_QNAME =
      "0x1::stake::UpdateNetworkAndFullnodeAddressesEvent";

    const TYPE = new TypeDescriptor<UpdateNetworkAndFullnodeAddressesEvent>(
      UpdateNetworkAndFullnodeAddressesEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateNetworkAndFullnodeAddressesEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateNetworkAndFullnodeAddressesEventInstance =
    TypedEventInstance<UpdateNetworkAndFullnodeAddressesEvent> & {
      data_decoded: UpdateNetworkAndFullnodeAddressesEvent;
      type_arguments: [];
    };

  export interface ValidatorConfig {
    consensus_pubkey: string;
    network_addresses: string;
    fullnode_addresses: string;
    validator_index: bigint;
  }

  export namespace ValidatorConfig {
    export const TYPE_QNAME = "0x1::stake::ValidatorConfig";

    const TYPE = new TypeDescriptor<ValidatorConfig>(
      ValidatorConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatorConfig> {
      return TYPE.apply();
    }
  }

  export interface ValidatorFees {
    fees_table: table.Table<MoveAddressType, coin.Coin<aptos_coin.AptosCoin>>;
  }

  export namespace ValidatorFees {
    export const TYPE_QNAME = "0x1::stake::ValidatorFees";

    const TYPE = new TypeDescriptor<ValidatorFees>(ValidatorFees.TYPE_QNAME);

    export function type(): TypeDescriptor<ValidatorFees> {
      return TYPE.apply();
    }
  }

  export interface ValidatorInfo {
    addr: MoveAddressType;
    voting_power: bigint;
    config: stake.ValidatorConfig;
  }

  export namespace ValidatorInfo {
    export const TYPE_QNAME = "0x1::stake::ValidatorInfo";

    const TYPE = new TypeDescriptor<ValidatorInfo>(ValidatorInfo.TYPE_QNAME);

    export function type(): TypeDescriptor<ValidatorInfo> {
      return TYPE.apply();
    }
  }

  export interface ValidatorPerformance {
    validators: stake.IndividualValidatorPerformance[];
  }

  export namespace ValidatorPerformance {
    export const TYPE_QNAME = "0x1::stake::ValidatorPerformance";

    const TYPE = new TypeDescriptor<ValidatorPerformance>(
      ValidatorPerformance.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatorPerformance> {
      return TYPE.apply();
    }
  }

  export interface ValidatorSet {
    consensus_scheme: number;
    active_validators: stake.ValidatorInfo[];
    pending_inactive: stake.ValidatorInfo[];
    pending_active: stake.ValidatorInfo[];
    total_voting_power: bigint;
    total_joining_power: bigint;
  }

  export namespace ValidatorSet {
    export const TYPE_QNAME = "0x1::stake::ValidatorSet";

    const TYPE = new TypeDescriptor<ValidatorSet>(ValidatorSet.TYPE_QNAME);

    export function type(): TypeDescriptor<ValidatorSet> {
      return TYPE.apply();
    }
  }

  export interface ValidatorSetLivenessFallback {
    minimum_stake: bigint;
    emergency_validator_count: bigint;
    total_emergency_voting_power: bigint;
  }

  export namespace ValidatorSetLivenessFallback {
    export const TYPE_QNAME = "0x1::stake::ValidatorSetLivenessFallback";

    const TYPE = new TypeDescriptor<ValidatorSetLivenessFallback>(
      ValidatorSetLivenessFallback.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatorSetLivenessFallback> {
      return TYPE.apply();
    }
  }

  export type ValidatorSetLivenessFallbackInstance =
    TypedEventInstance<ValidatorSetLivenessFallback> & {
      data_decoded: ValidatorSetLivenessFallback;
      type_arguments: [];
    };

  export interface WithdrawStake {
    pool_address: MoveAddressType;
    amount_withdrawn: bigint;
  }

  export namespace WithdrawStake {
    export const TYPE_QNAME = "0x1::stake::WithdrawStake";

    const TYPE = new TypeDescriptor<WithdrawStake>(WithdrawStake.TYPE_QNAME);

    export function type(): TypeDescriptor<WithdrawStake> {
      return TYPE.apply();
    }
  }

  export type WithdrawStakeInstance = TypedEventInstance<WithdrawStake> & {
    data_decoded: WithdrawStake;
    type_arguments: [];
  };

  export interface WithdrawStakeEvent {
    pool_address: MoveAddressType;
    amount_withdrawn: bigint;
  }

  export namespace WithdrawStakeEvent {
    export const TYPE_QNAME = "0x1::stake::WithdrawStakeEvent";

    const TYPE = new TypeDescriptor<WithdrawStakeEvent>(
      WithdrawStakeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<WithdrawStakeEvent> {
      return TYPE.apply();
    }
  }

  export type WithdrawStakeEventInstance =
    TypedEventInstance<WithdrawStakeEvent> & {
      data_decoded: WithdrawStakeEvent;
      type_arguments: [];
    };

  export namespace entry {
    export async function withdraw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::withdraw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function addStake(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::add_stake",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function increaseLockup(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::increase_lockup",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function initializeStakeOwner(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint, MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::initialize_stake_owner",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function initializeValidator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::initialize_validator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function joinValidatorSet(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::join_validator_set",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function leaveValidatorSet(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::leave_validator_set",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function reactivateStake(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::reactivate_stake",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function rotateConsensusKey(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::rotate_consensus_key",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setDelegatedVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::set_delegated_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function setOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::set_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function unlock(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::unlock",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function updateNetworkAndFullnodeAddresses(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::stake::update_network_and_fullnode_addresses",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function getCurrentEpochProposalCounts(
      client: Aptos,
      request: {
        functionArguments: [bigint];
      },
      version?: bigint,
    ): Promise<[bigint, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_current_epoch_proposal_counts",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_current_epoch_proposal_counts",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getCurrentEpochVotingPower(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_current_epoch_voting_power",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_current_epoch_voting_power",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getDelegatedVoter(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_delegated_voter",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_delegated_voter",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getLockupSecs(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_lockup_secs",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::stake::get_lockup_secs");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getOperator(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_operator",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::stake::get_operator");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function getPendingTransactionFee(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint[]]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_pending_transaction_fee",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_pending_transaction_fee",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getPoolAddressForOwner(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_pool_address_for_owner",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_pool_address_for_owner",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getRemainingLockupSecs(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_remaining_lockup_secs",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_remaining_lockup_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getStake(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint, bigint, bigint, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_stake",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::stake::get_stake");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getValidatorConfig(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[string, string, string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_validator_config",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_validator_config",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getValidatorIndex(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_validator_index",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_validator_index",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getValidatorState(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::get_validator_state",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::stake::get_validator_state",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function ownerCapExists(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::owner_cap_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::stake::owner_cap_exists");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function stakePoolExists(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::stake::stake_pool_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::stake::stake_pool_exists");
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface WithdrawPayload extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface AddStakePayload extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface IncreaseLockupPayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface InitializeStakeOwnerPayload
    extends TypedFunctionPayload<[bigint, MoveAddressType, MoveAddressType]> {
    arguments_decoded: [bigint, MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface InitializeValidatorPayload
    extends TypedFunctionPayload<[string, string, string, string]> {
    arguments_decoded: [string, string, string, string];
    type_arguments: [];
  }

  export interface JoinValidatorSetPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface LeaveValidatorSetPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface ReactivateStakePayload
    extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface RotateConsensusKeyPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string]> {
    arguments_decoded: [MoveAddressType, string, string];
    type_arguments: [];
  }

  export interface SetDelegatedVoterPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface SetOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UnlockPayload extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface UpdateNetworkAndFullnodeAddressesPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string]> {
    arguments_decoded: [MoveAddressType, string, string];
    type_arguments: [];
  }
}

export namespace table {
  export interface Box<T0> {
    val: T0;
  }

  export namespace Box {
    export const TYPE_QNAME = "0x1::table::Box";

    const TYPE = new TypeDescriptor<Box<any>>(Box.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Box<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface Table<T0, T1> {
    handle: MoveAddressType;
  }

  export namespace Table {
    export const TYPE_QNAME = "0x1::table::Table";

    const TYPE = new TypeDescriptor<Table<any, any>>(Table.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<Table<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace base16 {
  export namespace entry {}
  export namespace view {}
}

export namespace math64 {
  export namespace entry {}
  export namespace view {}
}

export class object$ extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("object", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): object$ {
    return new object$({ ...object$.DEFAULT_OPTIONS, ...options });
  }

  onEntryBurn(
    func: (call: object$.BurnPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, object$.BurnPayload>,
  ): object$ {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object::burn",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransfer(
    func: (call: object$.TransferPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, object$.TransferPayload>,
  ): object$ {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object::transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransferCall(
    func: (call: object$.TransferCallPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object$.TransferCallPayload
    >,
  ): object$ {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object::transfer_call",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransferToObject(
    func: (call: object$.TransferToObjectPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object$.TransferToObjectPayload
    >,
  ): object$ {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object::transfer_to_object",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnburn(
    func: (call: object$.UnburnPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, object$.UnburnPayload>,
  ): object$ {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object::unburn",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDeleteRef(
    func: (event: object$.DeleteRefInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, object$.DeleteRefInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object::DeleteRef" },
      handlerOptions,
    );
    return this;
  }

  onEventDeriveRef(
    func: (event: object$.DeriveRefInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, object$.DeriveRefInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object::DeriveRef" },
      handlerOptions,
    );
    return this;
  }

  onEventExtendRef(
    func: (event: object$.ExtendRefInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, object$.ExtendRefInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object::ExtendRef" },
      handlerOptions,
    );
    return this;
  }

  onEventTransfer(
    func: (event: object$.TransferInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, object$.TransferInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object::Transfer" },
      handlerOptions,
    );
    return this;
  }

  onEventTransferEvent(
    func: (event: object$.TransferEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object$.TransferEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object::TransferEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventTransferRef(
    func: (event: object$.TransferRefInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object$.TransferRefInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object$ {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object::TransferRef" },
      handlerOptions,
    );
    return this;
  }
}

export namespace object$ {
  export interface ConstructorRef {
    self: MoveAddressType;
    can_delete: boolean;
  }

  export namespace ConstructorRef {
    export const TYPE_QNAME = "0x1::object::ConstructorRef";

    const TYPE = new TypeDescriptor<ConstructorRef>(ConstructorRef.TYPE_QNAME);

    export function type(): TypeDescriptor<ConstructorRef> {
      return TYPE.apply();
    }
  }

  export interface DeleteRef {
    self: MoveAddressType;
  }

  export namespace DeleteRef {
    export const TYPE_QNAME = "0x1::object::DeleteRef";

    const TYPE = new TypeDescriptor<DeleteRef>(DeleteRef.TYPE_QNAME);

    export function type(): TypeDescriptor<DeleteRef> {
      return TYPE.apply();
    }
  }

  export type DeleteRefInstance = TypedEventInstance<DeleteRef> & {
    data_decoded: DeleteRef;
    type_arguments: [];
  };

  export interface DeriveRef {
    self: MoveAddressType;
  }

  export namespace DeriveRef {
    export const TYPE_QNAME = "0x1::object::DeriveRef";

    const TYPE = new TypeDescriptor<DeriveRef>(DeriveRef.TYPE_QNAME);

    export function type(): TypeDescriptor<DeriveRef> {
      return TYPE.apply();
    }
  }

  export type DeriveRefInstance = TypedEventInstance<DeriveRef> & {
    data_decoded: DeriveRef;
    type_arguments: [];
  };

  export interface ExtendRef {
    self: MoveAddressType;
  }

  export namespace ExtendRef {
    export const TYPE_QNAME = "0x1::object::ExtendRef";

    const TYPE = new TypeDescriptor<ExtendRef>(ExtendRef.TYPE_QNAME);

    export function type(): TypeDescriptor<ExtendRef> {
      return TYPE.apply();
    }
  }

  export type ExtendRefInstance = TypedEventInstance<ExtendRef> & {
    data_decoded: ExtendRef;
    type_arguments: [];
  };

  export interface LinearTransferRef {
    self: MoveAddressType;
    owner: MoveAddressType;
  }

  export namespace LinearTransferRef {
    export const TYPE_QNAME = "0x1::object::LinearTransferRef";

    const TYPE = new TypeDescriptor<LinearTransferRef>(
      LinearTransferRef.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<LinearTransferRef> {
      return TYPE.apply();
    }
  }

  export type Object<T> = MoveAddressType;
  export namespace Object {
    export const TYPE_QNAME = "0x1::object::Object";

    const TYPE = new TypeDescriptor<Object<any>>(Object.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Object<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface ObjectCore {
    guid_creation_num: bigint;
    owner: MoveAddressType;
    allow_ungated_transfer: boolean;
    transfer_events: event.EventHandle<object$.TransferEvent>;
  }

  export namespace ObjectCore {
    export const TYPE_QNAME = "0x1::object::ObjectCore";

    const TYPE = new TypeDescriptor<ObjectCore>(ObjectCore.TYPE_QNAME);

    export function type(): TypeDescriptor<ObjectCore> {
      return TYPE.apply();
    }
  }

  export interface ObjectGroup {
    dummy_field: boolean;
  }

  export namespace ObjectGroup {
    export const TYPE_QNAME = "0x1::object::ObjectGroup";

    const TYPE = new TypeDescriptor<ObjectGroup>(ObjectGroup.TYPE_QNAME);

    export function type(): TypeDescriptor<ObjectGroup> {
      return TYPE.apply();
    }
  }

  export interface TombStone {
    original_owner: MoveAddressType;
  }

  export namespace TombStone {
    export const TYPE_QNAME = "0x1::object::TombStone";

    const TYPE = new TypeDescriptor<TombStone>(TombStone.TYPE_QNAME);

    export function type(): TypeDescriptor<TombStone> {
      return TYPE.apply();
    }
  }

  export interface Transfer {
    object: MoveAddressType;
    from: MoveAddressType;
    to: MoveAddressType;
  }

  export namespace Transfer {
    export const TYPE_QNAME = "0x1::object::Transfer";

    const TYPE = new TypeDescriptor<Transfer>(Transfer.TYPE_QNAME);

    export function type(): TypeDescriptor<Transfer> {
      return TYPE.apply();
    }
  }

  export type TransferInstance = TypedEventInstance<Transfer> & {
    data_decoded: Transfer;
    type_arguments: [];
  };

  export interface TransferEvent {
    object: MoveAddressType;
    from: MoveAddressType;
    to: MoveAddressType;
  }

  export namespace TransferEvent {
    export const TYPE_QNAME = "0x1::object::TransferEvent";

    const TYPE = new TypeDescriptor<TransferEvent>(TransferEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<TransferEvent> {
      return TYPE.apply();
    }
  }

  export type TransferEventInstance = TypedEventInstance<TransferEvent> & {
    data_decoded: TransferEvent;
    type_arguments: [];
  };

  export interface TransferPermission {
    object: MoveAddressType;
  }

  export namespace TransferPermission {
    export const TYPE_QNAME = "0x1::object::TransferPermission";

    const TYPE = new TypeDescriptor<TransferPermission>(
      TransferPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransferPermission> {
      return TYPE.apply();
    }
  }

  export interface TransferRef {
    self: MoveAddressType;
  }

  export namespace TransferRef {
    export const TYPE_QNAME = "0x1::object::TransferRef";

    const TYPE = new TypeDescriptor<TransferRef>(TransferRef.TYPE_QNAME);

    export function type(): TypeDescriptor<TransferRef> {
      return TYPE.apply();
    }
  }

  export type TransferRefInstance = TypedEventInstance<TransferRef> & {
    data_decoded: TransferRef;
    type_arguments: [];
  };

  export interface Untransferable {
    dummy_field: boolean;
  }

  export namespace Untransferable {
    export const TYPE_QNAME = "0x1::object::Untransferable";

    const TYPE = new TypeDescriptor<Untransferable>(Untransferable.TYPE_QNAME);

    export function type(): TypeDescriptor<Untransferable> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function burn<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object::burn",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function transfer<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object::transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function transferCall(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object::transfer_call",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function transferToObject<T0 = any, T1 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId, MoveStructId];
        functionArguments: [object$.Object<T0>, object$.Object<T1>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object::transfer_to_object",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function unburn<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object::unburn",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function owner<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::object::owner",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::object::owner");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isBurnt<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::object::is_burnt",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::object::is_burnt");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isOwner<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::object::is_owner",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::object::is_owner");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isUntransferable<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::object::is_untransferable",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::object::is_untransferable",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function owns<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::object::owns",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::object::owns");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function rootOwner<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::object::root_owner",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::object::root_owner");
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface BurnPayload<T0 = any>
    extends TypedFunctionPayload<[object$.Object<T0>]> {
    arguments_decoded: [object$.Object<T0>];
    type_arguments: [string];
  }

  export interface TransferPayload<T0 = any>
    extends TypedFunctionPayload<[object$.Object<T0>, MoveAddressType]> {
    arguments_decoded: [object$.Object<T0>, MoveAddressType];
    type_arguments: [string];
  }

  export interface TransferCallPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface TransferToObjectPayload<T0 = any, T1 = any>
    extends TypedFunctionPayload<[object$.Object<T0>, object$.Object<T1>]> {
    arguments_decoded: [object$.Object<T0>, object$.Object<T1>];
    type_arguments: [string, string];
  }

  export interface UnburnPayload<T0 = any>
    extends TypedFunctionPayload<[object$.Object<T0>]> {
    arguments_decoded: [object$.Object<T0>];
    type_arguments: [string];
  }
}

export namespace option {
  export interface Option<T0> {
    vec: T0[];
  }

  export namespace Option {
    export const TYPE_QNAME = "0x1::option::Option";

    const TYPE = new TypeDescriptor<Option<any>>(Option.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Option<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace result {
  export interface Result<T0, T1> {}

  export namespace Result {
    export const TYPE_QNAME = "0x1::result::Result";

    const TYPE = new TypeDescriptor<Result<any, any>>(Result.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<Result<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace signer {
  export namespace entry {}
  export namespace view {}
}

export namespace string$ {
  export interface String {
    bytes: string;
  }

  export namespace String {
    export const TYPE_QNAME = "0x1::string::String";

    const TYPE = new TypeDescriptor<String>(String.TYPE_QNAME);

    export function type(): TypeDescriptor<String> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace vector {
  export namespace entry {}
  export namespace view {}
}

export class voting extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("voting", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): voting {
    return new voting({ ...voting.DEFAULT_OPTIONS, ...options });
  }

  onEventCreateProposal(
    func: (event: voting.CreateProposalInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      voting.CreateProposalInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): voting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "voting::CreateProposal" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateProposalEvent(
    func: (
      event: voting.CreateProposalEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      voting.CreateProposalEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): voting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "voting::CreateProposalEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventRegisterForum(
    func: (event: voting.RegisterForumInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      voting.RegisterForumInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): voting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "voting::RegisterForum" },
      handlerOptions,
    );
    return this;
  }

  onEventRegisterForumEvent(
    func: (event: voting.RegisterForumEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      voting.RegisterForumEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): voting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "voting::RegisterForumEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventResolveProposal(
    func: (event: voting.ResolveProposalInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      voting.ResolveProposalInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): voting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "voting::ResolveProposal" },
      handlerOptions,
    );
    return this;
  }

  onEventVote(
    func: (event: voting.VoteInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, voting.VoteInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): voting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "voting::Vote" },
      handlerOptions,
    );
    return this;
  }

  onEventVoteEvent(
    func: (event: voting.VoteEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, voting.VoteEventInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): voting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "voting::VoteEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace voting {
  export interface CreateProposal {
    proposal_id: bigint;
    early_resolution_vote_threshold: option.Option<bigint>;
    execution_hash: string;
    expiration_secs: bigint;
    metadata: simple_map.SimpleMap<string, string>;
    min_vote_threshold: bigint;
  }

  export namespace CreateProposal {
    export const TYPE_QNAME = "0x1::voting::CreateProposal";

    const TYPE = new TypeDescriptor<CreateProposal>(CreateProposal.TYPE_QNAME);

    export function type(): TypeDescriptor<CreateProposal> {
      return TYPE.apply();
    }
  }

  export type CreateProposalInstance = TypedEventInstance<CreateProposal> & {
    data_decoded: CreateProposal;
    type_arguments: [];
  };

  export interface CreateProposalEvent {
    proposal_id: bigint;
    early_resolution_vote_threshold: option.Option<bigint>;
    execution_hash: string;
    expiration_secs: bigint;
    metadata: simple_map.SimpleMap<string, string>;
    min_vote_threshold: bigint;
  }

  export namespace CreateProposalEvent {
    export const TYPE_QNAME = "0x1::voting::CreateProposalEvent";

    const TYPE = new TypeDescriptor<CreateProposalEvent>(
      CreateProposalEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateProposalEvent> {
      return TYPE.apply();
    }
  }

  export type CreateProposalEventInstance =
    TypedEventInstance<CreateProposalEvent> & {
      data_decoded: CreateProposalEvent;
      type_arguments: [];
    };

  export interface Proposal<T0> {
    proposer: MoveAddressType;
    execution_content: option.Option<T0>;
    metadata: simple_map.SimpleMap<string, string>;
    creation_time_secs: bigint;
    execution_hash: string;
    min_vote_threshold: bigint;
    expiration_secs: bigint;
    early_resolution_vote_threshold: option.Option<bigint>;
    yes_votes: bigint;
    no_votes: bigint;
    is_resolved: boolean;
    resolution_time_secs: bigint;
  }

  export namespace Proposal {
    export const TYPE_QNAME = "0x1::voting::Proposal";

    const TYPE = new TypeDescriptor<Proposal<any>>(Proposal.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Proposal<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface RegisterForum {
    hosting_account: MoveAddressType;
    proposal_type_info: type_info.TypeInfo;
  }

  export namespace RegisterForum {
    export const TYPE_QNAME = "0x1::voting::RegisterForum";

    const TYPE = new TypeDescriptor<RegisterForum>(RegisterForum.TYPE_QNAME);

    export function type(): TypeDescriptor<RegisterForum> {
      return TYPE.apply();
    }
  }

  export type RegisterForumInstance = TypedEventInstance<RegisterForum> & {
    data_decoded: RegisterForum;
    type_arguments: [];
  };

  export interface RegisterForumEvent {
    hosting_account: MoveAddressType;
    proposal_type_info: type_info.TypeInfo;
  }

  export namespace RegisterForumEvent {
    export const TYPE_QNAME = "0x1::voting::RegisterForumEvent";

    const TYPE = new TypeDescriptor<RegisterForumEvent>(
      RegisterForumEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RegisterForumEvent> {
      return TYPE.apply();
    }
  }

  export type RegisterForumEventInstance =
    TypedEventInstance<RegisterForumEvent> & {
      data_decoded: RegisterForumEvent;
      type_arguments: [];
    };

  export interface ResolveProposal {
    proposal_id: bigint;
    yes_votes: bigint;
    no_votes: bigint;
    resolved_early: boolean;
  }

  export namespace ResolveProposal {
    export const TYPE_QNAME = "0x1::voting::ResolveProposal";

    const TYPE = new TypeDescriptor<ResolveProposal>(
      ResolveProposal.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ResolveProposal> {
      return TYPE.apply();
    }
  }

  export type ResolveProposalInstance = TypedEventInstance<ResolveProposal> & {
    data_decoded: ResolveProposal;
    type_arguments: [];
  };

  export interface Vote {
    proposal_id: bigint;
    num_votes: bigint;
  }

  export namespace Vote {
    export const TYPE_QNAME = "0x1::voting::Vote";

    const TYPE = new TypeDescriptor<Vote>(Vote.TYPE_QNAME);

    export function type(): TypeDescriptor<Vote> {
      return TYPE.apply();
    }
  }

  export type VoteInstance = TypedEventInstance<Vote> & {
    data_decoded: Vote;
    type_arguments: [];
  };

  export interface VoteEvent {
    proposal_id: bigint;
    num_votes: bigint;
  }

  export namespace VoteEvent {
    export const TYPE_QNAME = "0x1::voting::VoteEvent";

    const TYPE = new TypeDescriptor<VoteEvent>(VoteEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<VoteEvent> {
      return TYPE.apply();
    }
  }

  export type VoteEventInstance = TypedEventInstance<VoteEvent> & {
    data_decoded: VoteEvent;
    type_arguments: [];
  };

  export interface VotePermission {
    dummy_field: boolean;
  }

  export namespace VotePermission {
    export const TYPE_QNAME = "0x1::voting::VotePermission";

    const TYPE = new TypeDescriptor<VotePermission>(VotePermission.TYPE_QNAME);

    export function type(): TypeDescriptor<VotePermission> {
      return TYPE.apply();
    }
  }

  export interface VotingEvents {
    create_proposal_events: event.EventHandle<voting.CreateProposalEvent>;
    register_forum_events: event.EventHandle<voting.RegisterForumEvent>;
    resolve_proposal_events: event.EventHandle<voting.ResolveProposal>;
    vote_events: event.EventHandle<voting.VoteEvent>;
  }

  export namespace VotingEvents {
    export const TYPE_QNAME = "0x1::voting::VotingEvents";

    const TYPE = new TypeDescriptor<VotingEvents>(VotingEvents.TYPE_QNAME);

    export function type(): TypeDescriptor<VotingEvents> {
      return TYPE.apply();
    }
  }

  export interface VotingForum<T0> {
    proposals: table.Table<bigint, voting.Proposal<T0>>;
    events: voting.VotingEvents;
    next_proposal_id: bigint;
  }

  export namespace VotingForum {
    export const TYPE_QNAME = "0x1::voting::VotingForum";

    const TYPE = new TypeDescriptor<VotingForum<any>>(VotingForum.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<VotingForum<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {
    export async function getEarlyResolutionVoteThreshold<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[option.Option<bigint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_early_resolution_vote_threshold",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_early_resolution_vote_threshold",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getExecutionHash<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_execution_hash",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_execution_hash",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getMinVoteThreshold<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_min_vote_threshold",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_min_vote_threshold",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getProposalCreationSecs<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_proposal_creation_secs",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_proposal_creation_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getProposalExpirationSecs<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_proposal_expiration_secs",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_proposal_expiration_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getProposalMetadata<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[simple_map.SimpleMap<string, string>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_proposal_metadata",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_proposal_metadata",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getProposalMetadataValue<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint, string];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_proposal_metadata_value",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_proposal_metadata_value",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getProposalState<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_proposal_state",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_proposal_state",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getProposer<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_proposer",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::voting::get_proposer");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getResolutionTimeSecs<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_resolution_time_secs",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::get_resolution_time_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getVotes<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::get_votes",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::voting::get_votes");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isMultiStepProposalInExecution<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::is_multi_step_proposal_in_execution",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::voting::is_multi_step_proposal_in_execution",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isResolved<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::is_resolved",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::voting::is_resolved");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isVotingClosed<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::is_voting_closed",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::voting::is_voting_closed");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function nextProposalId<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::voting::next_proposal_id",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::voting::next_proposal_id");
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export class account extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("account", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): account {
    return new account({ ...account.DEFAULT_OPTIONS, ...options });
  }

  onEntryOfferRotationCapability(
    func: (
      call: account.OfferRotationCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.OfferRotationCapabilityPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::offer_rotation_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryOfferSignerCapability(
    func: (
      call: account.OfferSignerCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.OfferSignerCapabilityPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::offer_signer_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRevokeAnyRotationCapability(
    func: (
      call: account.RevokeAnyRotationCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RevokeAnyRotationCapabilityPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::revoke_any_rotation_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRevokeAnySignerCapability(
    func: (
      call: account.RevokeAnySignerCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RevokeAnySignerCapabilityPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::revoke_any_signer_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRevokeRotationCapability(
    func: (
      call: account.RevokeRotationCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RevokeRotationCapabilityPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::revoke_rotation_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRevokeSignerCapability(
    func: (
      call: account.RevokeSignerCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RevokeSignerCapabilityPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::revoke_signer_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRotateAuthenticationKey(
    func: (
      call: account.RotateAuthenticationKeyPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RotateAuthenticationKeyPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::rotate_authentication_key",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRotateAuthenticationKeyCall(
    func: (
      call: account.RotateAuthenticationKeyCallPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RotateAuthenticationKeyCallPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::rotate_authentication_key_call",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRotateAuthenticationKeyFromPublicKey(
    func: (
      call: account.RotateAuthenticationKeyFromPublicKeyPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RotateAuthenticationKeyFromPublicKeyPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::rotate_authentication_key_from_public_key",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRotateAuthenticationKeyWithRotationCapability(
    func: (
      call: account.RotateAuthenticationKeyWithRotationCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RotateAuthenticationKeyWithRotationCapabilityPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::rotate_authentication_key_with_rotation_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetOriginatingAddress(
    func: (
      call: account.SetOriginatingAddressPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.SetOriginatingAddressPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::set_originating_address",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpsertEd25519BackupKeyAndEncryptDk(
    func: (
      call: account.UpsertEd25519BackupKeyAndEncryptDkPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.UpsertEd25519BackupKeyAndEncryptDkPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::upsert_ed25519_backup_key_and_encrypt_dk",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpsertEd25519BackupKeyOnKeylessAccount(
    func: (
      call: account.UpsertEd25519BackupKeyOnKeylessAccountPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.UpsertEd25519BackupKeyOnKeylessAccountPayload
    >,
  ): account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account::upsert_ed25519_backup_key_on_keyless_account",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCoinRegister(
    func: (event: account.CoinRegisterInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.CoinRegisterInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "account::CoinRegister" },
      handlerOptions,
    );
    return this;
  }

  onEventCoinRegisterEvent(
    func: (event: account.CoinRegisterEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.CoinRegisterEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "account::CoinRegisterEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventKeyRotation(
    func: (event: account.KeyRotationInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.KeyRotationInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "account::KeyRotation" },
      handlerOptions,
    );
    return this;
  }

  onEventKeyRotationEvent(
    func: (event: account.KeyRotationEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.KeyRotationEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "account::KeyRotationEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventKeyRotationToPublicKey(
    func: (
      event: account.KeyRotationToPublicKeyInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.KeyRotationToPublicKeyInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "account::KeyRotationToPublicKey" },
      handlerOptions,
    );
    return this;
  }

  onEventRotationCapability(
    func: (
      event: account.RotationCapabilityInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.RotationCapabilityInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "account::RotationCapability" },
      handlerOptions,
    );
    return this;
  }

  onEventSignerCapability(
    func: (event: account.SignerCapabilityInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account.SignerCapabilityInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "account::SignerCapability" },
      handlerOptions,
    );
    return this;
  }
}

export namespace account {
  export interface Account {
    authentication_key: string;
    sequence_number: bigint;
    guid_creation_num: bigint;
    coin_register_events: event.EventHandle<account.CoinRegisterEvent>;
    key_rotation_events: event.EventHandle<account.KeyRotationEvent>;
    rotation_capability_offer: account.CapabilityOffer<account.RotationCapability>;
    signer_capability_offer: account.CapabilityOffer<account.SignerCapability>;
  }

  export namespace Account {
    export const TYPE_QNAME = "0x1::account::Account";

    const TYPE = new TypeDescriptor<Account>(Account.TYPE_QNAME);

    export function type(): TypeDescriptor<Account> {
      return TYPE.apply();
    }
  }

  export interface AccountPermission {}

  export namespace AccountPermission {
    export const TYPE_QNAME = "0x1::account::AccountPermission";

    const TYPE = new TypeDescriptor<AccountPermission>(
      AccountPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AccountPermission> {
      return TYPE.apply();
    }
  }

  export interface CapabilityOffer<T0> {
    for: option.Option<MoveAddressType>;
  }

  export namespace CapabilityOffer {
    export const TYPE_QNAME = "0x1::account::CapabilityOffer";

    const TYPE = new TypeDescriptor<CapabilityOffer<any>>(
      CapabilityOffer.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<CapabilityOffer<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface CoinRegister {
    account: MoveAddressType;
    type_info: type_info.TypeInfo;
  }

  export namespace CoinRegister {
    export const TYPE_QNAME = "0x1::account::CoinRegister";

    const TYPE = new TypeDescriptor<CoinRegister>(CoinRegister.TYPE_QNAME);

    export function type(): TypeDescriptor<CoinRegister> {
      return TYPE.apply();
    }
  }

  export type CoinRegisterInstance = TypedEventInstance<CoinRegister> & {
    data_decoded: CoinRegister;
    type_arguments: [];
  };

  export interface CoinRegisterEvent {
    type_info: type_info.TypeInfo;
  }

  export namespace CoinRegisterEvent {
    export const TYPE_QNAME = "0x1::account::CoinRegisterEvent";

    const TYPE = new TypeDescriptor<CoinRegisterEvent>(
      CoinRegisterEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CoinRegisterEvent> {
      return TYPE.apply();
    }
  }

  export type CoinRegisterEventInstance =
    TypedEventInstance<CoinRegisterEvent> & {
      data_decoded: CoinRegisterEvent;
      type_arguments: [];
    };

  export interface EncryptedDK {}

  export namespace EncryptedDK {
    export const TYPE_QNAME = "0x1::account::EncryptedDK";

    const TYPE = new TypeDescriptor<EncryptedDK>(EncryptedDK.TYPE_QNAME);

    export function type(): TypeDescriptor<EncryptedDK> {
      return TYPE.apply();
    }
  }

  export interface KeyRotation {
    account: MoveAddressType;
    old_authentication_key: string;
    new_authentication_key: string;
  }

  export namespace KeyRotation {
    export const TYPE_QNAME = "0x1::account::KeyRotation";

    const TYPE = new TypeDescriptor<KeyRotation>(KeyRotation.TYPE_QNAME);

    export function type(): TypeDescriptor<KeyRotation> {
      return TYPE.apply();
    }
  }

  export type KeyRotationInstance = TypedEventInstance<KeyRotation> & {
    data_decoded: KeyRotation;
    type_arguments: [];
  };

  export interface KeyRotationEvent {
    old_authentication_key: string;
    new_authentication_key: string;
  }

  export namespace KeyRotationEvent {
    export const TYPE_QNAME = "0x1::account::KeyRotationEvent";

    const TYPE = new TypeDescriptor<KeyRotationEvent>(
      KeyRotationEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<KeyRotationEvent> {
      return TYPE.apply();
    }
  }

  export type KeyRotationEventInstance =
    TypedEventInstance<KeyRotationEvent> & {
      data_decoded: KeyRotationEvent;
      type_arguments: [];
    };

  export interface KeyRotationToPublicKey {
    account: MoveAddressType;
    verified_public_key_bit_map: string;
    public_key_scheme: number;
    public_key: string;
    old_auth_key: string;
    new_auth_key: string;
  }

  export namespace KeyRotationToPublicKey {
    export const TYPE_QNAME = "0x1::account::KeyRotationToPublicKey";

    const TYPE = new TypeDescriptor<KeyRotationToPublicKey>(
      KeyRotationToPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<KeyRotationToPublicKey> {
      return TYPE.apply();
    }
  }

  export type KeyRotationToPublicKeyInstance =
    TypedEventInstance<KeyRotationToPublicKey> & {
      data_decoded: KeyRotationToPublicKey;
      type_arguments: [];
    };

  export interface OriginatingAddress {
    address_map: table.Table<MoveAddressType, MoveAddressType>;
  }

  export namespace OriginatingAddress {
    export const TYPE_QNAME = "0x1::account::OriginatingAddress";

    const TYPE = new TypeDescriptor<OriginatingAddress>(
      OriginatingAddress.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<OriginatingAddress> {
      return TYPE.apply();
    }
  }

  export interface RotationCapability {
    account: MoveAddressType;
  }

  export namespace RotationCapability {
    export const TYPE_QNAME = "0x1::account::RotationCapability";

    const TYPE = new TypeDescriptor<RotationCapability>(
      RotationCapability.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RotationCapability> {
      return TYPE.apply();
    }
  }

  export type RotationCapabilityInstance =
    TypedEventInstance<RotationCapability> & {
      data_decoded: RotationCapability;
      type_arguments: [];
    };

  export interface RotationCapabilityOfferProofChallenge {
    sequence_number: bigint;
    recipient_address: MoveAddressType;
  }

  export namespace RotationCapabilityOfferProofChallenge {
    export const TYPE_QNAME =
      "0x1::account::RotationCapabilityOfferProofChallenge";

    const TYPE = new TypeDescriptor<RotationCapabilityOfferProofChallenge>(
      RotationCapabilityOfferProofChallenge.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RotationCapabilityOfferProofChallenge> {
      return TYPE.apply();
    }
  }

  export interface RotationCapabilityOfferProofChallengeV2 {
    chain_id: number;
    sequence_number: bigint;
    source_address: MoveAddressType;
    recipient_address: MoveAddressType;
  }

  export namespace RotationCapabilityOfferProofChallengeV2 {
    export const TYPE_QNAME =
      "0x1::account::RotationCapabilityOfferProofChallengeV2";

    const TYPE = new TypeDescriptor<RotationCapabilityOfferProofChallengeV2>(
      RotationCapabilityOfferProofChallengeV2.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RotationCapabilityOfferProofChallengeV2> {
      return TYPE.apply();
    }
  }

  export interface RotationProofChallenge {
    sequence_number: bigint;
    originator: MoveAddressType;
    current_auth_key: MoveAddressType;
    new_public_key: string;
  }

  export namespace RotationProofChallenge {
    export const TYPE_QNAME = "0x1::account::RotationProofChallenge";

    const TYPE = new TypeDescriptor<RotationProofChallenge>(
      RotationProofChallenge.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RotationProofChallenge> {
      return TYPE.apply();
    }
  }

  export interface SignerCapability {
    account: MoveAddressType;
  }

  export namespace SignerCapability {
    export const TYPE_QNAME = "0x1::account::SignerCapability";

    const TYPE = new TypeDescriptor<SignerCapability>(
      SignerCapability.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SignerCapability> {
      return TYPE.apply();
    }
  }

  export type SignerCapabilityInstance =
    TypedEventInstance<SignerCapability> & {
      data_decoded: SignerCapability;
      type_arguments: [];
    };

  export interface SignerCapabilityOfferProofChallenge {
    sequence_number: bigint;
    recipient_address: MoveAddressType;
  }

  export namespace SignerCapabilityOfferProofChallenge {
    export const TYPE_QNAME =
      "0x1::account::SignerCapabilityOfferProofChallenge";

    const TYPE = new TypeDescriptor<SignerCapabilityOfferProofChallenge>(
      SignerCapabilityOfferProofChallenge.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SignerCapabilityOfferProofChallenge> {
      return TYPE.apply();
    }
  }

  export interface SignerCapabilityOfferProofChallengeV2 {
    sequence_number: bigint;
    source_address: MoveAddressType;
    recipient_address: MoveAddressType;
  }

  export namespace SignerCapabilityOfferProofChallengeV2 {
    export const TYPE_QNAME =
      "0x1::account::SignerCapabilityOfferProofChallengeV2";

    const TYPE = new TypeDescriptor<SignerCapabilityOfferProofChallengeV2>(
      SignerCapabilityOfferProofChallengeV2.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SignerCapabilityOfferProofChallengeV2> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function offerRotationCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, number, string, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::offer_rotation_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function offerSignerCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, number, string, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::offer_signer_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function revokeAnyRotationCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::revoke_any_rotation_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function revokeAnySignerCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::revoke_any_signer_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function revokeRotationCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::revoke_rotation_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function revokeSignerCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::revoke_signer_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function rotateAuthenticationKey(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [number, string, number, string, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::rotate_authentication_key",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function rotateAuthenticationKeyCall(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::rotate_authentication_key_call",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function rotateAuthenticationKeyFromPublicKey(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [number, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::rotate_authentication_key_from_public_key",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function rotateAuthenticationKeyWithRotationCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, number, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::account::rotate_authentication_key_with_rotation_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setOriginatingAddress(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::set_originating_address",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function upsertEd25519BackupKeyAndEncryptDk(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account::upsert_ed25519_backup_key_and_encrypt_dk",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function upsertEd25519BackupKeyOnKeylessAccount(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::account::upsert_ed25519_backup_key_on_keyless_account",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function encryptedDkExists(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::encrypted_dk_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::encrypted_dk_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function existsAt(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::exists_at",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::account::exists_at");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getAuthenticationKey(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::get_authentication_key",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::get_authentication_key",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getEncryptedDk(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[account.EncryptedDK]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::get_encrypted_dk",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::get_encrypted_dk",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getGuidNextCreationNum(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::get_guid_next_creation_num",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::get_guid_next_creation_num",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getRotationCapabilityOfferFor(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::get_rotation_capability_offer_for",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::get_rotation_capability_offer_for",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getSequenceNumber(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::get_sequence_number",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::get_sequence_number",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function getSignerCapabilityOfferFor(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::get_signer_capability_offer_for",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::get_signer_capability_offer_for",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isRotationCapabilityOffered(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::is_rotation_capability_offered",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::is_rotation_capability_offered",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isSignerCapabilityOffered(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::is_signer_capability_offered",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::is_signer_capability_offered",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function originatingAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[option.Option<MoveAddressType>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account::originating_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account::originating_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface OfferRotationCapabilityPayload
    extends TypedFunctionPayload<[string, number, string, MoveAddressType]> {
    arguments_decoded: [string, number, string, MoveAddressType];
    type_arguments: [];
  }

  export interface OfferSignerCapabilityPayload
    extends TypedFunctionPayload<[string, number, string, MoveAddressType]> {
    arguments_decoded: [string, number, string, MoveAddressType];
    type_arguments: [];
  }

  export interface RevokeAnyRotationCapabilityPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface RevokeAnySignerCapabilityPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface RevokeRotationCapabilityPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface RevokeSignerCapabilityPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface RotateAuthenticationKeyPayload
    extends TypedFunctionPayload<
      [number, string, number, string, string, string]
    > {
    arguments_decoded: [number, string, number, string, string, string];
    type_arguments: [];
  }

  export interface RotateAuthenticationKeyCallPayload
    extends TypedFunctionPayload<[string]> {
    arguments_decoded: [string];
    type_arguments: [];
  }

  export interface RotateAuthenticationKeyFromPublicKeyPayload
    extends TypedFunctionPayload<[number, string]> {
    arguments_decoded: [number, string];
    type_arguments: [];
  }

  export interface RotateAuthenticationKeyWithRotationCapabilityPayload
    extends TypedFunctionPayload<[MoveAddressType, number, string, string]> {
    arguments_decoded: [MoveAddressType, number, string, string];
    type_arguments: [];
  }

  export interface SetOriginatingAddressPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface UpsertEd25519BackupKeyAndEncryptDkPayload
    extends TypedFunctionPayload<[string, string, string, string]> {
    arguments_decoded: [string, string, string, string];
    type_arguments: [];
  }

  export interface UpsertEd25519BackupKeyOnKeylessAccountPayload
    extends TypedFunctionPayload<[string, string, string]> {
    arguments_decoded: [string, string, string];
    type_arguments: [];
  }
}

export namespace ed25519 {
  export interface Signature {
    bytes: string;
  }

  export namespace Signature {
    export const TYPE_QNAME = "0x1::ed25519::Signature";

    const TYPE = new TypeDescriptor<Signature>(Signature.TYPE_QNAME);

    export function type(): TypeDescriptor<Signature> {
      return TYPE.apply();
    }
  }

  export interface SignedMessage<T0> {
    type_info: type_info.TypeInfo;
    inner: T0;
  }

  export namespace SignedMessage {
    export const TYPE_QNAME = "0x1::ed25519::SignedMessage";

    const TYPE = new TypeDescriptor<SignedMessage<any>>(
      SignedMessage.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<SignedMessage<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface UnvalidatedPublicKey {
    bytes: string;
  }

  export namespace UnvalidatedPublicKey {
    export const TYPE_QNAME = "0x1::ed25519::UnvalidatedPublicKey";

    const TYPE = new TypeDescriptor<UnvalidatedPublicKey>(
      UnvalidatedPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UnvalidatedPublicKey> {
      return TYPE.apply();
    }
  }

  export interface ValidatedPublicKey {
    bytes: string;
  }

  export namespace ValidatedPublicKey {
    export const TYPE_QNAME = "0x1::ed25519::ValidatedPublicKey";

    const TYPE = new TypeDescriptor<ValidatedPublicKey>(
      ValidatedPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatedPublicKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace genesis {
  export interface AccountMap {
    account_address: MoveAddressType;
    balance: bigint;
  }

  export namespace AccountMap {
    export const TYPE_QNAME = "0x1::genesis::AccountMap";

    const TYPE = new TypeDescriptor<AccountMap>(AccountMap.TYPE_QNAME);

    export function type(): TypeDescriptor<AccountMap> {
      return TYPE.apply();
    }
  }

  export interface EmployeeAccountMap {
    accounts: MoveAddressType[];
    validator: genesis.ValidatorConfigurationWithCommission;
    vesting_schedule_numerator: bigint[];
    vesting_schedule_denominator: bigint;
    beneficiary_resetter: MoveAddressType;
  }

  export namespace EmployeeAccountMap {
    export const TYPE_QNAME = "0x1::genesis::EmployeeAccountMap";

    const TYPE = new TypeDescriptor<EmployeeAccountMap>(
      EmployeeAccountMap.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<EmployeeAccountMap> {
      return TYPE.apply();
    }
  }

  export interface ValidatorConfiguration {
    owner_address: MoveAddressType;
    operator_address: MoveAddressType;
    voter_address: MoveAddressType;
    stake_amount: bigint;
    consensus_pubkey: string;
    proof_of_possession: string;
    network_addresses: string;
    full_node_network_addresses: string;
  }

  export namespace ValidatorConfiguration {
    export const TYPE_QNAME = "0x1::genesis::ValidatorConfiguration";

    const TYPE = new TypeDescriptor<ValidatorConfiguration>(
      ValidatorConfiguration.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatorConfiguration> {
      return TYPE.apply();
    }
  }

  export interface ValidatorConfigurationWithCommission {
    validator_config: genesis.ValidatorConfiguration;
    commission_percentage: bigint;
    join_during_genesis: boolean;
  }

  export namespace ValidatorConfigurationWithCommission {
    export const TYPE_QNAME =
      "0x1::genesis::ValidatorConfigurationWithCommission";

    const TYPE = new TypeDescriptor<ValidatorConfigurationWithCommission>(
      ValidatorConfigurationWithCommission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatorConfigurationWithCommission> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace keyless {
  export interface PublicKey {
    iss: string;
    idc: string;
  }

  export namespace PublicKey {
    export const TYPE_QNAME = "0x1::keyless::PublicKey";

    const TYPE = new TypeDescriptor<PublicKey>(PublicKey.TYPE_QNAME);

    export function type(): TypeDescriptor<PublicKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace math128 {
  export namespace entry {}
  export namespace view {}
}

export namespace reflect {
  export interface ReflectionError {}

  export namespace ReflectionError {
    export const TYPE_QNAME = "0x1::reflect::ReflectionError";

    const TYPE = new TypeDescriptor<ReflectionError>(
      ReflectionError.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ReflectionError> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class version extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("version", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): version {
    return new version({ ...version.DEFAULT_OPTIONS, ...options });
  }

  onEntrySetForNextEpoch(
    func: (call: version.SetForNextEpochPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      version.SetForNextEpochPayload
    >,
  ): version {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "version::set_for_next_epoch",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetVersion(
    func: (call: version.SetVersionPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, version.SetVersionPayload>,
  ): version {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "version::set_version",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace version {
  export interface SetVersionCapability {
    dummy_field: boolean;
  }

  export namespace SetVersionCapability {
    export const TYPE_QNAME = "0x1::version::SetVersionCapability";

    const TYPE = new TypeDescriptor<SetVersionCapability>(
      SetVersionCapability.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SetVersionCapability> {
      return TYPE.apply();
    }
  }

  export interface Version {
    major: bigint;
  }

  export namespace Version {
    export const TYPE_QNAME = "0x1::version::Version";

    const TYPE = new TypeDescriptor<Version>(Version.TYPE_QNAME);

    export function type(): TypeDescriptor<Version> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function setForNextEpoch(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::version::set_for_next_epoch",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setVersion(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::version::set_version",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface SetForNextEpochPayload
    extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface SetVersionPayload extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }
}

export class vesting extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("vesting", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): vesting {
    return new vesting({ ...vesting.DEFAULT_OPTIONS, ...options });
  }

  onEntrySetBeneficiaryForOperator(
    func: (
      call: vesting.SetBeneficiaryForOperatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.SetBeneficiaryForOperatorPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::set_beneficiary_for_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateCommissionPercentage(
    func: (
      call: vesting.UpdateCommissionPercentagePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateCommissionPercentagePayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::update_commission_percentage",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDistribute(
    func: (call: vesting.DistributePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, vesting.DistributePayload>,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::distribute",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryResetLockup(
    func: (call: vesting.ResetLockupPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.ResetLockupPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::reset_lockup",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnlockRewards(
    func: (call: vesting.UnlockRewardsPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UnlockRewardsPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::unlock_rewards",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateVoter(
    func: (call: vesting.UpdateVoterPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateVoterPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::update_voter",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAdminWithdraw(
    func: (call: vesting.AdminWithdrawPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.AdminWithdrawPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::admin_withdraw",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDistributeMany(
    func: (call: vesting.DistributeManyPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.DistributeManyPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::distribute_many",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryResetBeneficiary(
    func: (call: vesting.ResetBeneficiaryPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.ResetBeneficiaryPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::reset_beneficiary",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetBeneficiary(
    func: (call: vesting.SetBeneficiaryPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.SetBeneficiaryPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::set_beneficiary",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetBeneficiaryResetter(
    func: (
      call: vesting.SetBeneficiaryResetterPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.SetBeneficiaryResetterPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::set_beneficiary_resetter",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetManagementRole(
    func: (call: vesting.SetManagementRolePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.SetManagementRolePayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::set_management_role",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTerminateVestingContract(
    func: (
      call: vesting.TerminateVestingContractPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.TerminateVestingContractPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::terminate_vesting_contract",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnlockRewardsMany(
    func: (call: vesting.UnlockRewardsManyPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UnlockRewardsManyPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::unlock_rewards_many",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateOperator(
    func: (call: vesting.UpdateOperatorPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateOperatorPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::update_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateOperatorWithSameCommission(
    func: (
      call: vesting.UpdateOperatorWithSameCommissionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateOperatorWithSameCommissionPayload
    >,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::update_operator_with_same_commission",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryVest(
    func: (call: vesting.VestPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, vesting.VestPayload>,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::vest",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryVestMany(
    func: (call: vesting.VestManyPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, vesting.VestManyPayload>,
  ): vesting {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "vesting::vest_many",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDistribute(
    func: (event: vesting.DistributeInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.DistributeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::Distribute" },
      handlerOptions,
    );
    return this;
  }

  onEventDistributeEvent(
    func: (event: vesting.DistributeEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.DistributeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::DistributeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventResetLockup(
    func: (event: vesting.ResetLockupInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.ResetLockupInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::ResetLockup" },
      handlerOptions,
    );
    return this;
  }

  onEventResetLockupEvent(
    func: (event: vesting.ResetLockupEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.ResetLockupEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::ResetLockupEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateVoter(
    func: (event: vesting.UpdateVoterInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateVoterInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::UpdateVoter" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateVoterEvent(
    func: (event: vesting.UpdateVoterEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateVoterEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::UpdateVoterEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventAdminWithdraw(
    func: (event: vesting.AdminWithdrawInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.AdminWithdrawInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::AdminWithdraw" },
      handlerOptions,
    );
    return this;
  }

  onEventAdminWithdrawEvent(
    func: (
      event: vesting.AdminWithdrawEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.AdminWithdrawEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::AdminWithdrawEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateVestingContract(
    func: (
      event: vesting.CreateVestingContractInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.CreateVestingContractInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::CreateVestingContract" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateVestingContractEvent(
    func: (
      event: vesting.CreateVestingContractEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.CreateVestingContractEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::CreateVestingContractEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventSetBeneficiary(
    func: (event: vesting.SetBeneficiaryInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.SetBeneficiaryInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::SetBeneficiary" },
      handlerOptions,
    );
    return this;
  }

  onEventSetBeneficiaryEvent(
    func: (
      event: vesting.SetBeneficiaryEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.SetBeneficiaryEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::SetBeneficiaryEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventTerminate(
    func: (event: vesting.TerminateInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, vesting.TerminateInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::Terminate" },
      handlerOptions,
    );
    return this;
  }

  onEventTerminateEvent(
    func: (event: vesting.TerminateEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.TerminateEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::TerminateEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockRewards(
    func: (event: vesting.UnlockRewardsInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UnlockRewardsInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::UnlockRewards" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockRewardsEvent(
    func: (
      event: vesting.UnlockRewardsEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UnlockRewardsEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::UnlockRewardsEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateOperator(
    func: (event: vesting.UpdateOperatorInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateOperatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::UpdateOperator" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateOperatorEvent(
    func: (
      event: vesting.UpdateOperatorEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      vesting.UpdateOperatorEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::UpdateOperatorEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventVest(
    func: (event: vesting.VestInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, vesting.VestInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::Vest" },
      handlerOptions,
    );
    return this;
  }

  onEventVestEvent(
    func: (event: vesting.VestEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<MoveFetchConfig, vesting.VestEventInstance>,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): vesting {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "vesting::VestEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace vesting {
  export interface Distribute {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    amount: bigint;
  }

  export namespace Distribute {
    export const TYPE_QNAME = "0x1::vesting::Distribute";

    const TYPE = new TypeDescriptor<Distribute>(Distribute.TYPE_QNAME);

    export function type(): TypeDescriptor<Distribute> {
      return TYPE.apply();
    }
  }

  export type DistributeInstance = TypedEventInstance<Distribute> & {
    data_decoded: Distribute;
    type_arguments: [];
  };

  export interface DistributeEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    amount: bigint;
  }

  export namespace DistributeEvent {
    export const TYPE_QNAME = "0x1::vesting::DistributeEvent";

    const TYPE = new TypeDescriptor<DistributeEvent>(
      DistributeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DistributeEvent> {
      return TYPE.apply();
    }
  }

  export type DistributeEventInstance = TypedEventInstance<DistributeEvent> & {
    data_decoded: DistributeEvent;
    type_arguments: [];
  };

  export interface ResetLockup {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    new_lockup_expiration_secs: bigint;
  }

  export namespace ResetLockup {
    export const TYPE_QNAME = "0x1::vesting::ResetLockup";

    const TYPE = new TypeDescriptor<ResetLockup>(ResetLockup.TYPE_QNAME);

    export function type(): TypeDescriptor<ResetLockup> {
      return TYPE.apply();
    }
  }

  export type ResetLockupInstance = TypedEventInstance<ResetLockup> & {
    data_decoded: ResetLockup;
    type_arguments: [];
  };

  export interface ResetLockupEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    new_lockup_expiration_secs: bigint;
  }

  export namespace ResetLockupEvent {
    export const TYPE_QNAME = "0x1::vesting::ResetLockupEvent";

    const TYPE = new TypeDescriptor<ResetLockupEvent>(
      ResetLockupEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ResetLockupEvent> {
      return TYPE.apply();
    }
  }

  export type ResetLockupEventInstance =
    TypedEventInstance<ResetLockupEvent> & {
      data_decoded: ResetLockupEvent;
      type_arguments: [];
    };

  export interface UpdateVoter {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    old_voter: MoveAddressType;
    new_voter: MoveAddressType;
  }

  export namespace UpdateVoter {
    export const TYPE_QNAME = "0x1::vesting::UpdateVoter";

    const TYPE = new TypeDescriptor<UpdateVoter>(UpdateVoter.TYPE_QNAME);

    export function type(): TypeDescriptor<UpdateVoter> {
      return TYPE.apply();
    }
  }

  export type UpdateVoterInstance = TypedEventInstance<UpdateVoter> & {
    data_decoded: UpdateVoter;
    type_arguments: [];
  };

  export interface UpdateVoterEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    old_voter: MoveAddressType;
    new_voter: MoveAddressType;
  }

  export namespace UpdateVoterEvent {
    export const TYPE_QNAME = "0x1::vesting::UpdateVoterEvent";

    const TYPE = new TypeDescriptor<UpdateVoterEvent>(
      UpdateVoterEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateVoterEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateVoterEventInstance =
    TypedEventInstance<UpdateVoterEvent> & {
      data_decoded: UpdateVoterEvent;
      type_arguments: [];
    };

  export interface AdminStore {
    vesting_contracts: MoveAddressType[];
    nonce: bigint;
    create_events: event.EventHandle<vesting.CreateVestingContractEvent>;
  }

  export namespace AdminStore {
    export const TYPE_QNAME = "0x1::vesting::AdminStore";

    const TYPE = new TypeDescriptor<AdminStore>(AdminStore.TYPE_QNAME);

    export function type(): TypeDescriptor<AdminStore> {
      return TYPE.apply();
    }
  }

  export interface AdminWithdraw {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    amount: bigint;
  }

  export namespace AdminWithdraw {
    export const TYPE_QNAME = "0x1::vesting::AdminWithdraw";

    const TYPE = new TypeDescriptor<AdminWithdraw>(AdminWithdraw.TYPE_QNAME);

    export function type(): TypeDescriptor<AdminWithdraw> {
      return TYPE.apply();
    }
  }

  export type AdminWithdrawInstance = TypedEventInstance<AdminWithdraw> & {
    data_decoded: AdminWithdraw;
    type_arguments: [];
  };

  export interface AdminWithdrawEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    amount: bigint;
  }

  export namespace AdminWithdrawEvent {
    export const TYPE_QNAME = "0x1::vesting::AdminWithdrawEvent";

    const TYPE = new TypeDescriptor<AdminWithdrawEvent>(
      AdminWithdrawEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AdminWithdrawEvent> {
      return TYPE.apply();
    }
  }

  export type AdminWithdrawEventInstance =
    TypedEventInstance<AdminWithdrawEvent> & {
      data_decoded: AdminWithdrawEvent;
      type_arguments: [];
    };

  export interface CreateVestingContract {
    operator: MoveAddressType;
    voter: MoveAddressType;
    grant_amount: bigint;
    withdrawal_address: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    commission_percentage: bigint;
  }

  export namespace CreateVestingContract {
    export const TYPE_QNAME = "0x1::vesting::CreateVestingContract";

    const TYPE = new TypeDescriptor<CreateVestingContract>(
      CreateVestingContract.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateVestingContract> {
      return TYPE.apply();
    }
  }

  export type CreateVestingContractInstance =
    TypedEventInstance<CreateVestingContract> & {
      data_decoded: CreateVestingContract;
      type_arguments: [];
    };

  export interface CreateVestingContractEvent {
    operator: MoveAddressType;
    voter: MoveAddressType;
    grant_amount: bigint;
    withdrawal_address: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    commission_percentage: bigint;
  }

  export namespace CreateVestingContractEvent {
    export const TYPE_QNAME = "0x1::vesting::CreateVestingContractEvent";

    const TYPE = new TypeDescriptor<CreateVestingContractEvent>(
      CreateVestingContractEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateVestingContractEvent> {
      return TYPE.apply();
    }
  }

  export type CreateVestingContractEventInstance =
    TypedEventInstance<CreateVestingContractEvent> & {
      data_decoded: CreateVestingContractEvent;
      type_arguments: [];
    };

  export interface SetBeneficiary {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    shareholder: MoveAddressType;
    old_beneficiary: MoveAddressType;
    new_beneficiary: MoveAddressType;
  }

  export namespace SetBeneficiary {
    export const TYPE_QNAME = "0x1::vesting::SetBeneficiary";

    const TYPE = new TypeDescriptor<SetBeneficiary>(SetBeneficiary.TYPE_QNAME);

    export function type(): TypeDescriptor<SetBeneficiary> {
      return TYPE.apply();
    }
  }

  export type SetBeneficiaryInstance = TypedEventInstance<SetBeneficiary> & {
    data_decoded: SetBeneficiary;
    type_arguments: [];
  };

  export interface SetBeneficiaryEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    shareholder: MoveAddressType;
    old_beneficiary: MoveAddressType;
    new_beneficiary: MoveAddressType;
  }

  export namespace SetBeneficiaryEvent {
    export const TYPE_QNAME = "0x1::vesting::SetBeneficiaryEvent";

    const TYPE = new TypeDescriptor<SetBeneficiaryEvent>(
      SetBeneficiaryEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SetBeneficiaryEvent> {
      return TYPE.apply();
    }
  }

  export type SetBeneficiaryEventInstance =
    TypedEventInstance<SetBeneficiaryEvent> & {
      data_decoded: SetBeneficiaryEvent;
      type_arguments: [];
    };

  export interface StakingInfo {
    pool_address: MoveAddressType;
    operator: MoveAddressType;
    voter: MoveAddressType;
    commission_percentage: bigint;
  }

  export namespace StakingInfo {
    export const TYPE_QNAME = "0x1::vesting::StakingInfo";

    const TYPE = new TypeDescriptor<StakingInfo>(StakingInfo.TYPE_QNAME);

    export function type(): TypeDescriptor<StakingInfo> {
      return TYPE.apply();
    }
  }

  export interface Terminate {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
  }

  export namespace Terminate {
    export const TYPE_QNAME = "0x1::vesting::Terminate";

    const TYPE = new TypeDescriptor<Terminate>(Terminate.TYPE_QNAME);

    export function type(): TypeDescriptor<Terminate> {
      return TYPE.apply();
    }
  }

  export type TerminateInstance = TypedEventInstance<Terminate> & {
    data_decoded: Terminate;
    type_arguments: [];
  };

  export interface TerminateEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
  }

  export namespace TerminateEvent {
    export const TYPE_QNAME = "0x1::vesting::TerminateEvent";

    const TYPE = new TypeDescriptor<TerminateEvent>(TerminateEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<TerminateEvent> {
      return TYPE.apply();
    }
  }

  export type TerminateEventInstance = TypedEventInstance<TerminateEvent> & {
    data_decoded: TerminateEvent;
    type_arguments: [];
  };

  export interface UnlockRewards {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace UnlockRewards {
    export const TYPE_QNAME = "0x1::vesting::UnlockRewards";

    const TYPE = new TypeDescriptor<UnlockRewards>(UnlockRewards.TYPE_QNAME);

    export function type(): TypeDescriptor<UnlockRewards> {
      return TYPE.apply();
    }
  }

  export type UnlockRewardsInstance = TypedEventInstance<UnlockRewards> & {
    data_decoded: UnlockRewards;
    type_arguments: [];
  };

  export interface UnlockRewardsEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace UnlockRewardsEvent {
    export const TYPE_QNAME = "0x1::vesting::UnlockRewardsEvent";

    const TYPE = new TypeDescriptor<UnlockRewardsEvent>(
      UnlockRewardsEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UnlockRewardsEvent> {
      return TYPE.apply();
    }
  }

  export type UnlockRewardsEventInstance =
    TypedEventInstance<UnlockRewardsEvent> & {
      data_decoded: UnlockRewardsEvent;
      type_arguments: [];
    };

  export interface UpdateOperator {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    old_operator: MoveAddressType;
    new_operator: MoveAddressType;
    commission_percentage: bigint;
  }

  export namespace UpdateOperator {
    export const TYPE_QNAME = "0x1::vesting::UpdateOperator";

    const TYPE = new TypeDescriptor<UpdateOperator>(UpdateOperator.TYPE_QNAME);

    export function type(): TypeDescriptor<UpdateOperator> {
      return TYPE.apply();
    }
  }

  export type UpdateOperatorInstance = TypedEventInstance<UpdateOperator> & {
    data_decoded: UpdateOperator;
    type_arguments: [];
  };

  export interface UpdateOperatorEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    old_operator: MoveAddressType;
    new_operator: MoveAddressType;
    commission_percentage: bigint;
  }

  export namespace UpdateOperatorEvent {
    export const TYPE_QNAME = "0x1::vesting::UpdateOperatorEvent";

    const TYPE = new TypeDescriptor<UpdateOperatorEvent>(
      UpdateOperatorEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateOperatorEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateOperatorEventInstance =
    TypedEventInstance<UpdateOperatorEvent> & {
      data_decoded: UpdateOperatorEvent;
      type_arguments: [];
    };

  export interface Vest {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    period_vested: bigint;
    amount: bigint;
  }

  export namespace Vest {
    export const TYPE_QNAME = "0x1::vesting::Vest";

    const TYPE = new TypeDescriptor<Vest>(Vest.TYPE_QNAME);

    export function type(): TypeDescriptor<Vest> {
      return TYPE.apply();
    }
  }

  export type VestInstance = TypedEventInstance<Vest> & {
    data_decoded: Vest;
    type_arguments: [];
  };

  export interface VestEvent {
    admin: MoveAddressType;
    vesting_contract_address: MoveAddressType;
    staking_pool_address: MoveAddressType;
    period_vested: bigint;
    amount: bigint;
  }

  export namespace VestEvent {
    export const TYPE_QNAME = "0x1::vesting::VestEvent";

    const TYPE = new TypeDescriptor<VestEvent>(VestEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<VestEvent> {
      return TYPE.apply();
    }
  }

  export type VestEventInstance = TypedEventInstance<VestEvent> & {
    data_decoded: VestEvent;
    type_arguments: [];
  };

  export interface VestPermission {
    dummy_field: boolean;
  }

  export namespace VestPermission {
    export const TYPE_QNAME = "0x1::vesting::VestPermission";

    const TYPE = new TypeDescriptor<VestPermission>(VestPermission.TYPE_QNAME);

    export function type(): TypeDescriptor<VestPermission> {
      return TYPE.apply();
    }
  }

  export interface VestingAccountManagement {
    roles: simple_map.SimpleMap<string, MoveAddressType>;
  }

  export namespace VestingAccountManagement {
    export const TYPE_QNAME = "0x1::vesting::VestingAccountManagement";

    const TYPE = new TypeDescriptor<VestingAccountManagement>(
      VestingAccountManagement.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<VestingAccountManagement> {
      return TYPE.apply();
    }
  }

  export interface VestingContract {
    state: bigint;
    admin: MoveAddressType;
    grant_pool: pool_u64.Pool;
    beneficiaries: simple_map.SimpleMap<MoveAddressType, MoveAddressType>;
    vesting_schedule: vesting.VestingSchedule;
    withdrawal_address: MoveAddressType;
    staking: vesting.StakingInfo;
    remaining_grant: bigint;
    signer_cap: account.SignerCapability;
    update_operator_events: event.EventHandle<vesting.UpdateOperatorEvent>;
    update_voter_events: event.EventHandle<vesting.UpdateVoterEvent>;
    reset_lockup_events: event.EventHandle<vesting.ResetLockupEvent>;
    set_beneficiary_events: event.EventHandle<vesting.SetBeneficiaryEvent>;
    unlock_rewards_events: event.EventHandle<vesting.UnlockRewardsEvent>;
    vest_events: event.EventHandle<vesting.VestEvent>;
    distribute_events: event.EventHandle<vesting.DistributeEvent>;
    terminate_events: event.EventHandle<vesting.TerminateEvent>;
    admin_withdraw_events: event.EventHandle<vesting.AdminWithdrawEvent>;
  }

  export namespace VestingContract {
    export const TYPE_QNAME = "0x1::vesting::VestingContract";

    const TYPE = new TypeDescriptor<VestingContract>(
      VestingContract.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<VestingContract> {
      return TYPE.apply();
    }
  }

  export interface VestingSchedule {
    schedule: fixed_point32.FixedPoint32[];
    start_timestamp_secs: bigint;
    period_duration: bigint;
    last_vested_period: bigint;
  }

  export namespace VestingSchedule {
    export const TYPE_QNAME = "0x1::vesting::VestingSchedule";

    const TYPE = new TypeDescriptor<VestingSchedule>(
      VestingSchedule.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<VestingSchedule> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function setBeneficiaryForOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::set_beneficiary_for_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateCommissionPercentage(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::update_commission_percentage",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function distribute(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::distribute",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function resetLockup(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::reset_lockup",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function unlockRewards(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::unlock_rewards",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::update_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function adminWithdraw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::admin_withdraw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function distributeMany(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::distribute_many",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function resetBeneficiary(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::reset_beneficiary",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setBeneficiary(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::set_beneficiary",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setBeneficiaryResetter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::set_beneficiary_resetter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setManagementRole(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::set_management_role",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function terminateVestingContract(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::terminate_vesting_contract",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function unlockRewardsMany(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::unlock_rewards_many",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::update_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateOperatorWithSameCommission(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::update_operator_with_same_commission",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function vest(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::vest",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function vestMany(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::vesting::vest_many",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function operator(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::operator",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::vesting::operator");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function voter(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::voter",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::vesting::voter");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function shareholder(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::shareholder",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::vesting::shareholder");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function operatorCommissionPercentage(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::operator_commission_percentage",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::operator_commission_percentage",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function beneficiary(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::beneficiary",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::vesting::beneficiary");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function shareholders(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType[]]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::shareholders",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::vesting::shareholders");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function stakePoolAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::stake_pool_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::stake_pool_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function accumulatedRewards(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::accumulated_rewards",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::accumulated_rewards",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function vestingSchedule(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[vesting.VestingSchedule]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::vesting_schedule",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::vesting_schedule",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function periodDurationSecs(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::period_duration_secs",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::period_duration_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function remainingGrant(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::remaining_grant",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::vesting::remaining_grant");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function totalAccumulatedRewards(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::total_accumulated_rewards",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::total_accumulated_rewards",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function vestingContracts(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType[]]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::vesting_contracts",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::vesting_contracts",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function vestingStartSecs(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::vesting::vesting_start_secs",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::vesting::vesting_start_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface SetBeneficiaryForOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UpdateCommissionPercentagePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface DistributePayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface ResetLockupPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UnlockRewardsPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UpdateVoterPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface AdminWithdrawPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface DistributeManyPayload
    extends TypedFunctionPayload<[MoveAddressType[]]> {
    arguments_decoded: [MoveAddressType[]];
    type_arguments: [];
  }

  export interface ResetBeneficiaryPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetBeneficiaryPayload
    extends TypedFunctionPayload<
      [MoveAddressType, MoveAddressType, MoveAddressType]
    > {
    arguments_decoded: [MoveAddressType, MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetBeneficiaryResetterPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetManagementRolePayload
    extends TypedFunctionPayload<[MoveAddressType, string, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, string, MoveAddressType];
    type_arguments: [];
  }

  export interface TerminateVestingContractPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UnlockRewardsManyPayload
    extends TypedFunctionPayload<[MoveAddressType[]]> {
    arguments_decoded: [MoveAddressType[]];
    type_arguments: [];
  }

  export interface UpdateOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface UpdateOperatorWithSameCommissionPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface VestPayload extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface VestManyPayload
    extends TypedFunctionPayload<[MoveAddressType[]]> {
    arguments_decoded: [MoveAddressType[]];
    type_arguments: [];
  }
}

export namespace bls12381 {
  export interface AggrOrMultiSignature {
    bytes: string;
  }

  export namespace AggrOrMultiSignature {
    export const TYPE_QNAME = "0x1::bls12381::AggrOrMultiSignature";

    const TYPE = new TypeDescriptor<AggrOrMultiSignature>(
      AggrOrMultiSignature.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AggrOrMultiSignature> {
      return TYPE.apply();
    }
  }

  export interface AggrPublicKeysWithPoP {
    bytes: string;
  }

  export namespace AggrPublicKeysWithPoP {
    export const TYPE_QNAME = "0x1::bls12381::AggrPublicKeysWithPoP";

    const TYPE = new TypeDescriptor<AggrPublicKeysWithPoP>(
      AggrPublicKeysWithPoP.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AggrPublicKeysWithPoP> {
      return TYPE.apply();
    }
  }

  export interface ProofOfPossession {
    bytes: string;
  }

  export namespace ProofOfPossession {
    export const TYPE_QNAME = "0x1::bls12381::ProofOfPossession";

    const TYPE = new TypeDescriptor<ProofOfPossession>(
      ProofOfPossession.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ProofOfPossession> {
      return TYPE.apply();
    }
  }

  export interface PublicKey {
    bytes: string;
  }

  export namespace PublicKey {
    export const TYPE_QNAME = "0x1::bls12381::PublicKey";

    const TYPE = new TypeDescriptor<PublicKey>(PublicKey.TYPE_QNAME);

    export function type(): TypeDescriptor<PublicKey> {
      return TYPE.apply();
    }
  }

  export interface PublicKeyWithPoP {
    bytes: string;
  }

  export namespace PublicKeyWithPoP {
    export const TYPE_QNAME = "0x1::bls12381::PublicKeyWithPoP";

    const TYPE = new TypeDescriptor<PublicKeyWithPoP>(
      PublicKeyWithPoP.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PublicKeyWithPoP> {
      return TYPE.apply();
    }
  }

  export interface Signature {
    bytes: string;
  }

  export namespace Signature {
    export const TYPE_QNAME = "0x1::bls12381::Signature";

    const TYPE = new TypeDescriptor<Signature>(Signature.TYPE_QNAME);

    export function type(): TypeDescriptor<Signature> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace chain_id {
  export interface ChainId {
    id: number;
  }

  export namespace ChainId {
    export const TYPE_QNAME = "0x1::chain_id::ChainId";

    const TYPE = new TypeDescriptor<ChainId>(ChainId.TYPE_QNAME);

    export function type(): TypeDescriptor<ChainId> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {
    export async function get(
      client: Aptos,

      version?: bigint,
    ): Promise<[number]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::chain_id::get",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::chain_id::get");
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace features {
  export interface Features {
    features: string;
  }

  export namespace Features {
    export const TYPE_QNAME = "0x1::features::Features";

    const TYPE = new TypeDescriptor<Features>(Features.TYPE_QNAME);

    export function type(): TypeDescriptor<Features> {
      return TYPE.apply();
    }
  }

  export interface PendingFeatures {
    features: string;
  }

  export namespace PendingFeatures {
    export const TYPE_QNAME = "0x1::features::PendingFeatures";

    const TYPE = new TypeDescriptor<PendingFeatures>(
      PendingFeatures.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PendingFeatures> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {
    export async function isEnabled(
      client: Aptos,
      request: {
        functionArguments: [bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::features::is_enabled",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::features::is_enabled");
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace from_bcs {
  export namespace entry {}
  export namespace view {}
}

export namespace pool_u64 {
  export interface Pool {
    shareholders_limit: bigint;
    total_coins: bigint;
    total_shares: bigint;
    shares: simple_map.SimpleMap<MoveAddressType, bigint>;
    shareholders: MoveAddressType[];
    scaling_factor: bigint;
  }

  export namespace Pool {
    export const TYPE_QNAME = "0x1::pool_u64::Pool";

    const TYPE = new TypeDescriptor<Pool>(Pool.TYPE_QNAME);

    export function type(): TypeDescriptor<Pool> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace auth_data {
  export interface AbstractionAuthData {}

  export namespace AbstractionAuthData {
    export const TYPE_QNAME = "0x1::auth_data::AbstractionAuthData";

    const TYPE = new TypeDescriptor<AbstractionAuthData>(
      AbstractionAuthData.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AbstractionAuthData> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace multi_key {
  export interface MultiKey {
    public_keys: single_key.AnyPublicKey[];
    signatures_required: number;
  }

  export namespace MultiKey {
    export const TYPE_QNAME = "0x1::multi_key::MultiKey";

    const TYPE = new TypeDescriptor<MultiKey>(MultiKey.TYPE_QNAME);

    export function type(): TypeDescriptor<MultiKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace secp256k1 {
  export interface ECDSARawPublicKey {
    bytes: string;
  }

  export namespace ECDSARawPublicKey {
    export const TYPE_QNAME = "0x1::secp256k1::ECDSARawPublicKey";

    const TYPE = new TypeDescriptor<ECDSARawPublicKey>(
      ECDSARawPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ECDSARawPublicKey> {
      return TYPE.apply();
    }
  }

  export interface ECDSASignature {
    bytes: string;
  }

  export namespace ECDSASignature {
    export const TYPE_QNAME = "0x1::secp256k1::ECDSASignature";

    const TYPE = new TypeDescriptor<ECDSASignature>(ECDSASignature.TYPE_QNAME);

    export function type(): TypeDescriptor<ECDSASignature> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace secp256r1 {
  export interface ECDSARawPublicKey {
    bytes: string;
  }

  export namespace ECDSARawPublicKey {
    export const TYPE_QNAME = "0x1::secp256r1::ECDSARawPublicKey";

    const TYPE = new TypeDescriptor<ECDSARawPublicKey>(
      ECDSARawPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ECDSARawPublicKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace timestamp {
  export interface CurrentTimeMicroseconds {
    microseconds: bigint;
  }

  export namespace CurrentTimeMicroseconds {
    export const TYPE_QNAME = "0x1::timestamp::CurrentTimeMicroseconds";

    const TYPE = new TypeDescriptor<CurrentTimeMicroseconds>(
      CurrentTimeMicroseconds.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CurrentTimeMicroseconds> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {
    export async function nowMicroseconds(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::timestamp::now_microseconds",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::timestamp::now_microseconds",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function nowSeconds(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::timestamp::now_seconds",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::timestamp::now_seconds");
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace type_info {
  export interface TypeInfo {
    account_address: MoveAddressType;
    module_name: string;
    struct_name: string;
  }

  export namespace TypeInfo {
    export const TYPE_QNAME = "0x1::type_info::TypeInfo";

    const TYPE = new TypeDescriptor<TypeInfo>(TypeInfo.TYPE_QNAME);

    export function type(): TypeDescriptor<TypeInfo> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace aggregator {
  export interface Aggregator {
    handle: MoveAddressType;
    key: MoveAddressType;
    limit: bigint;
  }

  export namespace Aggregator {
    export const TYPE_QNAME = "0x1::aggregator::Aggregator";

    const TYPE = new TypeDescriptor<Aggregator>(Aggregator.TYPE_QNAME);

    export function type(): TypeDescriptor<Aggregator> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class aptos_coin extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("aptos_coin", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): aptos_coin {
    return new aptos_coin({ ...aptos_coin.DEFAULT_OPTIONS, ...options });
  }

  onEntryMint(
    func: (call: aptos_coin.MintPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, aptos_coin.MintPayload>,
  ): aptos_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_coin::mint",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryClaimMintCapability(
    func: (
      call: aptos_coin.ClaimMintCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_coin.ClaimMintCapabilityPayload
    >,
  ): aptos_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_coin::claim_mint_capability",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDelegateMintCapability(
    func: (
      call: aptos_coin.DelegateMintCapabilityPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_coin.DelegateMintCapabilityPayload
    >,
  ): aptos_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_coin::delegate_mint_capability",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace aptos_coin {
  export interface AptosCoin {
    dummy_field: boolean;
  }

  export namespace AptosCoin {
    export const TYPE_QNAME = "0x1::aptos_coin::AptosCoin";

    const TYPE = new TypeDescriptor<AptosCoin>(AptosCoin.TYPE_QNAME);

    export function type(): TypeDescriptor<AptosCoin> {
      return TYPE.apply();
    }
  }

  export interface DelegatedMintCapability {
    to: MoveAddressType;
  }

  export namespace DelegatedMintCapability {
    export const TYPE_QNAME = "0x1::aptos_coin::DelegatedMintCapability";

    const TYPE = new TypeDescriptor<DelegatedMintCapability>(
      DelegatedMintCapability.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DelegatedMintCapability> {
      return TYPE.apply();
    }
  }

  export interface Delegations {
    inner: aptos_coin.DelegatedMintCapability[];
  }

  export namespace Delegations {
    export const TYPE_QNAME = "0x1::aptos_coin::Delegations";

    const TYPE = new TypeDescriptor<Delegations>(Delegations.TYPE_QNAME);

    export function type(): TypeDescriptor<Delegations> {
      return TYPE.apply();
    }
  }

  export interface MintCapStore {
    mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
  }

  export namespace MintCapStore {
    export const TYPE_QNAME = "0x1::aptos_coin::MintCapStore";

    const TYPE = new TypeDescriptor<MintCapStore>(MintCapStore.TYPE_QNAME);

    export function type(): TypeDescriptor<MintCapStore> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function mint(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_coin::mint",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function claimMintCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_coin::claim_mint_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function delegateMintCapability(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_coin::delegate_mint_capability",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface MintPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface ClaimMintCapabilityPayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface DelegateMintCapabilityPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }
}

export namespace aptos_hash {
  export namespace entry {}
  export namespace view {}
}

export class bcs_stream extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("bcs_stream", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): bcs_stream {
    return new bcs_stream({ ...bcs_stream.DEFAULT_OPTIONS, ...options });
  }

  onEntryDeserializeU256Entry(
    func: (
      call: bcs_stream.DeserializeU256EntryPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      bcs_stream.DeserializeU256EntryPayload
    >,
  ): bcs_stream {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "bcs_stream::deserialize_u256_entry",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace bcs_stream {
  export interface BCSStream {
    data: string;
    cur: bigint;
  }

  export namespace BCSStream {
    export const TYPE_QNAME = "0x1::bcs_stream::BCSStream";

    const TYPE = new TypeDescriptor<BCSStream>(BCSStream.TYPE_QNAME);

    export function type(): TypeDescriptor<BCSStream> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function deserializeU256Entry(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::bcs_stream::deserialize_u256_entry",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface DeserializeU256EntryPayload
    extends TypedFunctionPayload<[string, bigint]> {
    arguments_decoded: [string, bigint];
    type_arguments: [];
  }
}

export namespace big_vector {
  export interface BigVector<T0> {
    buckets: table_with_length.TableWithLength<bigint, T0[]>;
    end_index: bigint;
    bucket_size: bigint;
  }

  export namespace BigVector {
    export const TYPE_QNAME = "0x1::big_vector::BigVector";

    const TYPE = new TypeDescriptor<BigVector<any>>(BigVector.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<BigVector<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace bit_vector {
  export interface BitVector {
    length: bigint;
    bit_field: boolean[];
  }

  export namespace BitVector {
    export const TYPE_QNAME = "0x1::bit_vector::BitVector";

    const TYPE = new TypeDescriptor<BitVector>(BitVector.TYPE_QNAME);

    export function type(): TypeDescriptor<BitVector> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace capability {
  export interface Cap<T0> {
    root: MoveAddressType;
  }

  export namespace Cap {
    export const TYPE_QNAME = "0x1::capability::Cap";

    const TYPE = new TypeDescriptor<Cap<any>>(Cap.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Cap<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface CapDelegateState<T0> {
    root: MoveAddressType;
  }

  export namespace CapDelegateState {
    export const TYPE_QNAME = "0x1::capability::CapDelegateState";

    const TYPE = new TypeDescriptor<CapDelegateState<any>>(
      CapDelegateState.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<CapDelegateState<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface CapState<T0> {
    delegates: MoveAddressType[];
  }

  export namespace CapState {
    export const TYPE_QNAME = "0x1::capability::CapState";

    const TYPE = new TypeDescriptor<CapState<any>>(CapState.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<CapState<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface LinearCap<T0> {
    root: MoveAddressType;
  }

  export namespace LinearCap {
    export const TYPE_QNAME = "0x1::capability::LinearCap";

    const TYPE = new TypeDescriptor<LinearCap<any>>(LinearCap.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<LinearCap<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class chunky_dkg extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("chunky_dkg", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): chunky_dkg {
    return new chunky_dkg({ ...chunky_dkg.DEFAULT_OPTIONS, ...options });
  }

  onEventChunkyDKGStartEvent(
    func: (
      event: chunky_dkg.ChunkyDKGStartEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      chunky_dkg.ChunkyDKGStartEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): chunky_dkg {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "chunky_dkg::ChunkyDKGStartEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace chunky_dkg {
  export interface ChunkyDKGSessionMetadata {
    dealer_epoch: bigint;
    chunky_dkg_config: chunky_dkg_config.ChunkyDKGConfig;
    dealer_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
    target_validator_set: validator_consensus_info.ValidatorConsensusInfo[];
  }

  export namespace ChunkyDKGSessionMetadata {
    export const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGSessionMetadata";

    const TYPE = new TypeDescriptor<ChunkyDKGSessionMetadata>(
      ChunkyDKGSessionMetadata.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ChunkyDKGSessionMetadata> {
      return TYPE.apply();
    }
  }

  export interface ChunkyDKGSessionState {
    metadata: chunky_dkg.ChunkyDKGSessionMetadata;
    start_time_us: bigint;
    aggregated_subtranscript: string;
  }

  export namespace ChunkyDKGSessionState {
    export const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGSessionState";

    const TYPE = new TypeDescriptor<ChunkyDKGSessionState>(
      ChunkyDKGSessionState.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ChunkyDKGSessionState> {
      return TYPE.apply();
    }
  }

  export interface ChunkyDKGStartEvent {
    session_metadata: chunky_dkg.ChunkyDKGSessionMetadata;
    start_time_us: bigint;
  }

  export namespace ChunkyDKGStartEvent {
    export const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGStartEvent";

    const TYPE = new TypeDescriptor<ChunkyDKGStartEvent>(
      ChunkyDKGStartEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ChunkyDKGStartEvent> {
      return TYPE.apply();
    }
  }

  export type ChunkyDKGStartEventInstance =
    TypedEventInstance<ChunkyDKGStartEvent> & {
      data_decoded: ChunkyDKGStartEvent;
      type_arguments: [];
    };

  export interface ChunkyDKGState {
    last_completed: option.Option<chunky_dkg.ChunkyDKGSessionState>;
    in_progress: option.Option<chunky_dkg.ChunkyDKGSessionState>;
  }

  export namespace ChunkyDKGState {
    export const TYPE_QNAME = "0x1::chunky_dkg::ChunkyDKGState";

    const TYPE = new TypeDescriptor<ChunkyDKGState>(ChunkyDKGState.TYPE_QNAME);

    export function type(): TypeDescriptor<ChunkyDKGState> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace comparator {
  export interface Result {
    inner: number;
  }

  export namespace Result {
    export const TYPE_QNAME = "0x1::comparator::Result";

    const TYPE = new TypeDescriptor<Result>(Result.TYPE_QNAME);

    export function type(): TypeDescriptor<Result> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace decryption {
  export interface PerBlockDecryptionKey {
    epoch: bigint;
    round: bigint;
    decryption_key: option.Option<string>;
  }

  export namespace PerBlockDecryptionKey {
    export const TYPE_QNAME = "0x1::decryption::PerBlockDecryptionKey";

    const TYPE = new TypeDescriptor<PerBlockDecryptionKey>(
      PerBlockDecryptionKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PerBlockDecryptionKey> {
      return TYPE.apply();
    }
  }

  export interface PerEpochEncryptionKey {
    epoch: bigint;
    encryption_key: option.Option<string>;
  }

  export namespace PerEpochEncryptionKey {
    export const TYPE_QNAME = "0x1::decryption::PerEpochEncryptionKey";

    const TYPE = new TypeDescriptor<PerEpochEncryptionKey>(
      PerEpochEncryptionKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PerEpochEncryptionKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace math_fixed {
  export namespace entry {}
  export namespace view {}
}

export class randomness extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("randomness", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): randomness {
    return new randomness({ ...randomness.DEFAULT_OPTIONS, ...options });
  }

  onEventRandomnessGeneratedEvent(
    func: (
      event: randomness.RandomnessGeneratedEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      randomness.RandomnessGeneratedEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): randomness {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "randomness::RandomnessGeneratedEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace randomness {
  export interface PerBlockRandomness {
    epoch: bigint;
    round: bigint;
    seed: option.Option<string>;
  }

  export namespace PerBlockRandomness {
    export const TYPE_QNAME = "0x1::randomness::PerBlockRandomness";

    const TYPE = new TypeDescriptor<PerBlockRandomness>(
      PerBlockRandomness.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PerBlockRandomness> {
      return TYPE.apply();
    }
  }

  export interface RandomnessGeneratedEvent {
    dummy_field: boolean;
  }

  export namespace RandomnessGeneratedEvent {
    export const TYPE_QNAME = "0x1::randomness::RandomnessGeneratedEvent";

    const TYPE = new TypeDescriptor<RandomnessGeneratedEvent>(
      RandomnessGeneratedEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RandomnessGeneratedEvent> {
      return TYPE.apply();
    }
  }

  export type RandomnessGeneratedEventInstance =
    TypedEventInstance<RandomnessGeneratedEvent> & {
      data_decoded: RandomnessGeneratedEvent;
      type_arguments: [];
    };

  export namespace entry {}
  export namespace view {}
}

export namespace simple_map {
  export interface Element<T0, T1> {
    key: T0;
    value: T1;
  }

  export namespace Element {
    export const TYPE_QNAME = "0x1::simple_map::Element";

    const TYPE = new TypeDescriptor<Element<any, any>>(Element.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<Element<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export interface SimpleMap<T0, T1> {
    data: simple_map.Element<T0, T1>[];
  }

  export namespace SimpleMap {
    export const TYPE_QNAME = "0x1::simple_map::SimpleMap";

    const TYPE = new TypeDescriptor<SimpleMap<any, any>>(SimpleMap.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<SimpleMap<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace single_key {
  export interface AnyPublicKey {}

  export namespace AnyPublicKey {
    export const TYPE_QNAME = "0x1::single_key::AnyPublicKey";

    const TYPE = new TypeDescriptor<AnyPublicKey>(AnyPublicKey.TYPE_QNAME);

    export function type(): TypeDescriptor<AnyPublicKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace ordered_map {
  export interface Entry<T0, T1> {
    key: T0;
    value: T1;
  }

  export namespace Entry {
    export const TYPE_QNAME = "0x1::ordered_map::Entry";

    const TYPE = new TypeDescriptor<Entry<any, any>>(Entry.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<Entry<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export interface IteratorPtr {}

  export namespace IteratorPtr {
    export const TYPE_QNAME = "0x1::ordered_map::IteratorPtr";

    const TYPE = new TypeDescriptor<IteratorPtr>(IteratorPtr.TYPE_QNAME);

    export function type(): TypeDescriptor<IteratorPtr> {
      return TYPE.apply();
    }
  }

  export interface OrderedMap<T0, T1> {}

  export namespace OrderedMap {
    export const TYPE_QNAME = "0x1::ordered_map::OrderedMap";

    const TYPE = new TypeDescriptor<OrderedMap<any, any>>(
      OrderedMap.TYPE_QNAME,
    );

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<OrderedMap<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace smart_table {
  export interface Entry<T0, T1> {
    hash: bigint;
    key: T0;
    value: T1;
  }

  export namespace Entry {
    export const TYPE_QNAME = "0x1::smart_table::Entry";

    const TYPE = new TypeDescriptor<Entry<any, any>>(Entry.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<Entry<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export interface SmartTable<T0, T1> {
    buckets: table_with_length.TableWithLength<
      bigint,
      smart_table.Entry<T0, T1>[]
    >;
    num_buckets: bigint;
    level: number;
    size: bigint;
    split_load_threshold: number;
    target_bucket_size: bigint;
  }

  export namespace SmartTable {
    export const TYPE_QNAME = "0x1::smart_table::SmartTable";

    const TYPE = new TypeDescriptor<SmartTable<any, any>>(
      SmartTable.TYPE_QNAME,
    );

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<SmartTable<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace storage_gas {
  export interface GasCurve {
    min_gas: bigint;
    max_gas: bigint;
    points: storage_gas.Point[];
  }

  export namespace GasCurve {
    export const TYPE_QNAME = "0x1::storage_gas::GasCurve";

    const TYPE = new TypeDescriptor<GasCurve>(GasCurve.TYPE_QNAME);

    export function type(): TypeDescriptor<GasCurve> {
      return TYPE.apply();
    }
  }

  export interface Point {
    x: bigint;
    y: bigint;
  }

  export namespace Point {
    export const TYPE_QNAME = "0x1::storage_gas::Point";

    const TYPE = new TypeDescriptor<Point>(Point.TYPE_QNAME);

    export function type(): TypeDescriptor<Point> {
      return TYPE.apply();
    }
  }

  export interface StorageGas {
    per_item_read: bigint;
    per_item_create: bigint;
    per_item_write: bigint;
    per_byte_read: bigint;
    per_byte_create: bigint;
    per_byte_write: bigint;
  }

  export namespace StorageGas {
    export const TYPE_QNAME = "0x1::storage_gas::StorageGas";

    const TYPE = new TypeDescriptor<StorageGas>(StorageGas.TYPE_QNAME);

    export function type(): TypeDescriptor<StorageGas> {
      return TYPE.apply();
    }
  }

  export interface StorageGasConfig {
    item_config: storage_gas.UsageGasConfig;
    byte_config: storage_gas.UsageGasConfig;
  }

  export namespace StorageGasConfig {
    export const TYPE_QNAME = "0x1::storage_gas::StorageGasConfig";

    const TYPE = new TypeDescriptor<StorageGasConfig>(
      StorageGasConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StorageGasConfig> {
      return TYPE.apply();
    }
  }

  export interface UsageGasConfig {
    target_usage: bigint;
    read_curve: storage_gas.GasCurve;
    create_curve: storage_gas.GasCurve;
    write_curve: storage_gas.GasCurve;
  }

  export namespace UsageGasConfig {
    export const TYPE_QNAME = "0x1::storage_gas::UsageGasConfig";

    const TYPE = new TypeDescriptor<UsageGasConfig>(UsageGasConfig.TYPE_QNAME);

    export function type(): TypeDescriptor<UsageGasConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace chain_status {
  export interface GenesisEndMarker {
    dummy_field: boolean;
  }

  export namespace GenesisEndMarker {
    export const TYPE_QNAME = "0x1::chain_status::GenesisEndMarker";

    const TYPE = new TypeDescriptor<GenesisEndMarker>(
      GenesisEndMarker.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GenesisEndMarker> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {
    export async function isGenesis(
      client: Aptos,

      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::chain_status::is_genesis",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::chain_status::is_genesis");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isOperating(
      client: Aptos,

      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::chain_status::is_operating",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::chain_status::is_operating",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace copyable_any {
  export interface Any {
    type_name: string;
    data: string;
  }

  export namespace Any {
    export const TYPE_QNAME = "0x1::copyable_any::Any";

    const TYPE = new TypeDescriptor<Any>(Any.TYPE_QNAME);

    export function type(): TypeDescriptor<Any> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace gas_schedule {
  export interface GasEntry {
    key: string;
    val: bigint;
  }

  export namespace GasEntry {
    export const TYPE_QNAME = "0x1::gas_schedule::GasEntry";

    const TYPE = new TypeDescriptor<GasEntry>(GasEntry.TYPE_QNAME);

    export function type(): TypeDescriptor<GasEntry> {
      return TYPE.apply();
    }
  }

  export interface GasSchedule {
    entries: gas_schedule.GasEntry[];
  }

  export namespace GasSchedule {
    export const TYPE_QNAME = "0x1::gas_schedule::GasSchedule";

    const TYPE = new TypeDescriptor<GasSchedule>(GasSchedule.TYPE_QNAME);

    export function type(): TypeDescriptor<GasSchedule> {
      return TYPE.apply();
    }
  }

  export interface GasScheduleV2 {
    feature_version: bigint;
    entries: gas_schedule.GasEntry[];
  }

  export namespace GasScheduleV2 {
    export const TYPE_QNAME = "0x1::gas_schedule::GasScheduleV2";

    const TYPE = new TypeDescriptor<GasScheduleV2>(GasScheduleV2.TYPE_QNAME);

    export function type(): TypeDescriptor<GasScheduleV2> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class managed_coin extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("managed_coin", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): managed_coin {
    return new managed_coin({ ...managed_coin.DEFAULT_OPTIONS, ...options });
  }

  onEntryInitialize(
    func: (call: managed_coin.InitializePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      managed_coin.InitializePayload
    >,
  ): managed_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "managed_coin::initialize",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryBurn(
    func: (call: managed_coin.BurnPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, managed_coin.BurnPayload>,
  ): managed_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "managed_coin::burn",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryMint(
    func: (call: managed_coin.MintPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<MoveFetchConfig, managed_coin.MintPayload>,
  ): managed_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "managed_coin::mint",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRegister(
    func: (call: managed_coin.RegisterPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      managed_coin.RegisterPayload
    >,
  ): managed_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "managed_coin::register",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDestroyCaps(
    func: (call: managed_coin.DestroyCapsPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      managed_coin.DestroyCapsPayload
    >,
  ): managed_coin {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "managed_coin::destroy_caps",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace managed_coin {
  export interface Capabilities<T0> {
    burn_cap: coin.BurnCapability<T0>;
    freeze_cap: coin.FreezeCapability<T0>;
    mint_cap: coin.MintCapability<T0>;
  }

  export namespace Capabilities {
    export const TYPE_QNAME = "0x1::managed_coin::Capabilities";

    const TYPE = new TypeDescriptor<Capabilities<any>>(Capabilities.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Capabilities<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {
    export async function initialize<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [string, string, number, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::managed_coin::initialize",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function burn<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::managed_coin::burn",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function mint<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::managed_coin::mint",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function register<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::managed_coin::register",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function destroyCaps<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::managed_coin::destroy_caps",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface InitializePayload<T0 = any>
    extends TypedFunctionPayload<[string, string, number, boolean]> {
    arguments_decoded: [string, string, number, boolean];
    type_arguments: [string];
  }

  export interface BurnPayload<T0 = any>
    extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [string];
  }

  export interface MintPayload<T0 = any>
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [string];
  }

  export interface RegisterPayload<T0 = any> extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [string];
  }

  export interface DestroyCapsPayload<T0 = any>
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [string];
  }
}

export namespace math_fixed64 {
  export namespace entry {}
  export namespace view {}
}

export namespace rate_limiter {
  export interface RateLimiter {}

  export namespace RateLimiter {
    export const TYPE_QNAME = "0x1::rate_limiter::RateLimiter";

    const TYPE = new TypeDescriptor<RateLimiter>(RateLimiter.TYPE_QNAME);

    export function type(): TypeDescriptor<RateLimiter> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace ristretto255 {
  export interface CompressedRistretto {
    data: string;
  }

  export namespace CompressedRistretto {
    export const TYPE_QNAME = "0x1::ristretto255::CompressedRistretto";

    const TYPE = new TypeDescriptor<CompressedRistretto>(
      CompressedRistretto.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CompressedRistretto> {
      return TYPE.apply();
    }
  }

  export interface RistrettoPoint {
    handle: bigint;
  }

  export namespace RistrettoPoint {
    export const TYPE_QNAME = "0x1::ristretto255::RistrettoPoint";

    const TYPE = new TypeDescriptor<RistrettoPoint>(RistrettoPoint.TYPE_QNAME);

    export function type(): TypeDescriptor<RistrettoPoint> {
      return TYPE.apply();
    }
  }

  export interface Scalar {
    data: string;
  }

  export namespace Scalar {
    export const TYPE_QNAME = "0x1::ristretto255::Scalar";

    const TYPE = new TypeDescriptor<Scalar>(Scalar.TYPE_QNAME);

    export function type(): TypeDescriptor<Scalar> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace smart_vector {
  export interface SmartVector<T0> {
    inline_vec: T0[];
    big_vec: option.Option<big_vector.BigVector<T0>>;
    inline_capacity: option.Option<bigint>;
    bucket_size: option.Option<bigint>;
  }

  export namespace SmartVector {
    export const TYPE_QNAME = "0x1::smart_vector::SmartVector";

    const TYPE = new TypeDescriptor<SmartVector<any>>(SmartVector.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<SmartVector<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace storage_slot {
  export interface StorageSlot<T0> {
    addr: MoveAddressType;
  }

  export namespace StorageSlot {
    export const TYPE_QNAME = "0x1::storage_slot::StorageSlot";

    const TYPE = new TypeDescriptor<StorageSlot<any>>(StorageSlot.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<StorageSlot<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface StorageSlotResource<T0> {
    val: T0;
  }

  export namespace StorageSlotResource {
    export const TYPE_QNAME = "0x1::storage_slot::StorageSlotResource";

    const TYPE = new TypeDescriptor<StorageSlotResource<any>>(
      StorageSlotResource.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<StorageSlotResource<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace string_utils {
  export interface Cons<T0, T1> {
    car: T0;
    cdr: T1;
  }

  export namespace Cons {
    export const TYPE_QNAME = "0x1::string_utils::Cons";

    const TYPE = new TypeDescriptor<Cons<any, any>>(Cons.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<Cons<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export interface FakeCons<T0, T1> {
    car: T0;
    cdr: T1;
  }

  export namespace FakeCons {
    export const TYPE_QNAME = "0x1::string_utils::FakeCons";

    const TYPE = new TypeDescriptor<FakeCons<any, any>>(FakeCons.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<FakeCons<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export interface NIL {
    dummy_field: boolean;
  }

  export namespace NIL {
    export const TYPE_QNAME = "0x1::string_utils::NIL";

    const TYPE = new TypeDescriptor<NIL>(NIL.TYPE_QNAME);

    export function type(): TypeDescriptor<NIL> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class aggregator_v2 extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("aggregator_v2", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): aggregator_v2 {
    return new aggregator_v2({ ...aggregator_v2.DEFAULT_OPTIONS, ...options });
  }

  onEventAggregator(
    func: (event: aggregator_v2.AggregatorInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aggregator_v2.AggregatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aggregator_v2 {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aggregator_v2::Aggregator" },
      handlerOptions,
    );
    return this;
  }

  onEventAggregatorSnapshot(
    func: (
      event: aggregator_v2.AggregatorSnapshotInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aggregator_v2.AggregatorSnapshotInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aggregator_v2 {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aggregator_v2::AggregatorSnapshot" },
      handlerOptions,
    );
    return this;
  }

  onEventDerivedStringSnapshot(
    func: (
      event: aggregator_v2.DerivedStringSnapshotInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aggregator_v2.DerivedStringSnapshotInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aggregator_v2 {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aggregator_v2::DerivedStringSnapshot" },
      handlerOptions,
    );
    return this;
  }
}

export namespace aggregator_v2 {
  export interface Aggregator<T0> {
    value: T0;
    max_value: T0;
  }

  export namespace Aggregator {
    export const TYPE_QNAME = "0x1::aggregator_v2::Aggregator";

    const TYPE = new TypeDescriptor<Aggregator<any>>(Aggregator.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Aggregator<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export type AggregatorInstance = TypedEventInstance<Aggregator<any>> & {
    data_decoded: Aggregator<any>;
    type_arguments: [string];
  };

  export interface AggregatorSnapshot<T0> {
    value: T0;
  }

  export namespace AggregatorSnapshot {
    export const TYPE_QNAME = "0x1::aggregator_v2::AggregatorSnapshot";

    const TYPE = new TypeDescriptor<AggregatorSnapshot<any>>(
      AggregatorSnapshot.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<AggregatorSnapshot<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export type AggregatorSnapshotInstance = TypedEventInstance<
    AggregatorSnapshot<any>
  > & {
    data_decoded: AggregatorSnapshot<any>;
    type_arguments: [string];
  };

  export interface DerivedStringSnapshot {
    value: string;
    padding: string;
  }

  export namespace DerivedStringSnapshot {
    export const TYPE_QNAME = "0x1::aggregator_v2::DerivedStringSnapshot";

    const TYPE = new TypeDescriptor<DerivedStringSnapshot>(
      DerivedStringSnapshot.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DerivedStringSnapshot> {
      return TYPE.apply();
    }
  }

  export type DerivedStringSnapshotInstance =
    TypedEventInstance<DerivedStringSnapshot> & {
      data_decoded: DerivedStringSnapshot;
      type_arguments: [];
    };

  export namespace entry {}
  export namespace view {}
}

export class aptos_account extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("aptos_account", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): aptos_account {
    return new aptos_account({ ...aptos_account.DEFAULT_OPTIONS, ...options });
  }

  onEntryCreateAccount(
    func: (call: aptos_account.CreateAccountPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.CreateAccountPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::create_account",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransfer(
    func: (call: aptos_account.TransferPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.TransferPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryBatchTransfer(
    func: (call: aptos_account.BatchTransferPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.BatchTransferPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::batch_transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryBatchTransferCoins(
    func: (
      call: aptos_account.BatchTransferCoinsPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.BatchTransferCoinsPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::batch_transfer_coins",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryBatchTransferFungibleAssets(
    func: (
      call: aptos_account.BatchTransferFungibleAssetsPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.BatchTransferFungibleAssetsPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::batch_transfer_fungible_assets",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryFungibleTransferOnly(
    func: (
      call: aptos_account.FungibleTransferOnlyPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.FungibleTransferOnlyPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::fungible_transfer_only",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetAllowDirectCoinTransfers(
    func: (
      call: aptos_account.SetAllowDirectCoinTransfersPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.SetAllowDirectCoinTransfersPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::set_allow_direct_coin_transfers",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransferCoins(
    func: (call: aptos_account.TransferCoinsPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.TransferCoinsPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::transfer_coins",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransferFungibleAssets(
    func: (
      call: aptos_account.TransferFungibleAssetsPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.TransferFungibleAssetsPayload
    >,
  ): aptos_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_account::transfer_fungible_assets",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDirectCoinTransferConfigUpdated(
    func: (
      event: aptos_account.DirectCoinTransferConfigUpdatedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.DirectCoinTransferConfigUpdatedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "aptos_account::DirectCoinTransferConfigUpdated",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDirectCoinTransferConfigUpdatedEvent(
    func: (
      event: aptos_account.DirectCoinTransferConfigUpdatedEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_account.DirectCoinTransferConfigUpdatedEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "aptos_account::DirectCoinTransferConfigUpdatedEvent",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace aptos_account {
  export interface DirectCoinTransferConfigUpdated {
    account: MoveAddressType;
    new_allow_direct_transfers: boolean;
  }

  export namespace DirectCoinTransferConfigUpdated {
    export const TYPE_QNAME =
      "0x1::aptos_account::DirectCoinTransferConfigUpdated";

    const TYPE = new TypeDescriptor<DirectCoinTransferConfigUpdated>(
      DirectCoinTransferConfigUpdated.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DirectCoinTransferConfigUpdated> {
      return TYPE.apply();
    }
  }

  export type DirectCoinTransferConfigUpdatedInstance =
    TypedEventInstance<DirectCoinTransferConfigUpdated> & {
      data_decoded: DirectCoinTransferConfigUpdated;
      type_arguments: [];
    };

  export interface DirectCoinTransferConfigUpdatedEvent {
    new_allow_direct_transfers: boolean;
  }

  export namespace DirectCoinTransferConfigUpdatedEvent {
    export const TYPE_QNAME =
      "0x1::aptos_account::DirectCoinTransferConfigUpdatedEvent";

    const TYPE = new TypeDescriptor<DirectCoinTransferConfigUpdatedEvent>(
      DirectCoinTransferConfigUpdatedEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DirectCoinTransferConfigUpdatedEvent> {
      return TYPE.apply();
    }
  }

  export type DirectCoinTransferConfigUpdatedEventInstance =
    TypedEventInstance<DirectCoinTransferConfigUpdatedEvent> & {
      data_decoded: DirectCoinTransferConfigUpdatedEvent;
      type_arguments: [];
    };

  export interface DirectTransferConfig {
    allow_arbitrary_coin_transfers: boolean;
    update_coin_transfer_events: event.EventHandle<aptos_account.DirectCoinTransferConfigUpdatedEvent>;
  }

  export namespace DirectTransferConfig {
    export const TYPE_QNAME = "0x1::aptos_account::DirectTransferConfig";

    const TYPE = new TypeDescriptor<DirectTransferConfig>(
      DirectTransferConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DirectTransferConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function createAccount(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::create_account",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function transfer(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function batchTransfer(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::batch_transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function batchTransferCoins<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType[], bigint[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::batch_transfer_coins",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function batchTransferFungibleAssets(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          object$.Object<fungible_asset.Metadata>,
          MoveAddressType[],
          bigint[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::batch_transfer_fungible_assets",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function fungibleTransferOnly(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::fungible_transfer_only",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function setAllowDirectCoinTransfers(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::set_allow_direct_coin_transfers",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function transferCoins<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::transfer_coins",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function transferFungibleAssets(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          object$.Object<fungible_asset.Metadata>,
          MoveAddressType,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_account::transfer_fungible_assets",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function canReceiveDirectCoinTransfers(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::aptos_account::can_receive_direct_coin_transfers",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::aptos_account::can_receive_direct_coin_transfers",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface CreateAccountPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface TransferPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface BatchTransferPayload
    extends TypedFunctionPayload<[MoveAddressType[], bigint[]]> {
    arguments_decoded: [MoveAddressType[], bigint[]];
    type_arguments: [];
  }

  export interface BatchTransferCoinsPayload<T0 = any>
    extends TypedFunctionPayload<[MoveAddressType[], bigint[]]> {
    arguments_decoded: [MoveAddressType[], bigint[]];
    type_arguments: [string];
  }

  export interface BatchTransferFungibleAssetsPayload
    extends TypedFunctionPayload<
      [object$.Object<fungible_asset.Metadata>, MoveAddressType[], bigint[]]
    > {
    arguments_decoded: [
      object$.Object<fungible_asset.Metadata>,
      MoveAddressType[],
      bigint[],
    ];
    type_arguments: [];
  }

  export interface FungibleTransferOnlyPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface SetAllowDirectCoinTransfersPayload
    extends TypedFunctionPayload<[boolean]> {
    arguments_decoded: [boolean];
    type_arguments: [];
  }

  export interface TransferCoinsPayload<T0 = any>
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [string];
  }

  export interface TransferFungibleAssetsPayload
    extends TypedFunctionPayload<
      [object$.Object<fungible_asset.Metadata>, MoveAddressType, bigint]
    > {
    arguments_decoded: [
      object$.Object<fungible_asset.Metadata>,
      MoveAddressType,
      bigint,
    ];
    type_arguments: [];
  }
}

export namespace bn254_algebra {
  export interface FormatFq12LscLsb {
    dummy_field: boolean;
  }

  export namespace FormatFq12LscLsb {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatFq12LscLsb";

    const TYPE = new TypeDescriptor<FormatFq12LscLsb>(
      FormatFq12LscLsb.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FormatFq12LscLsb> {
      return TYPE.apply();
    }
  }

  export interface FormatFrLsb {
    dummy_field: boolean;
  }

  export namespace FormatFrLsb {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatFrLsb";

    const TYPE = new TypeDescriptor<FormatFrLsb>(FormatFrLsb.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatFrLsb> {
      return TYPE.apply();
    }
  }

  export interface FormatFrMsb {
    dummy_field: boolean;
  }

  export namespace FormatFrMsb {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatFrMsb";

    const TYPE = new TypeDescriptor<FormatFrMsb>(FormatFrMsb.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatFrMsb> {
      return TYPE.apply();
    }
  }

  export interface FormatG1Compr {
    dummy_field: boolean;
  }

  export namespace FormatG1Compr {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatG1Compr";

    const TYPE = new TypeDescriptor<FormatG1Compr>(FormatG1Compr.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatG1Compr> {
      return TYPE.apply();
    }
  }

  export interface FormatG1Uncompr {
    dummy_field: boolean;
  }

  export namespace FormatG1Uncompr {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatG1Uncompr";

    const TYPE = new TypeDescriptor<FormatG1Uncompr>(
      FormatG1Uncompr.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FormatG1Uncompr> {
      return TYPE.apply();
    }
  }

  export interface FormatG2Compr {
    dummy_field: boolean;
  }

  export namespace FormatG2Compr {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatG2Compr";

    const TYPE = new TypeDescriptor<FormatG2Compr>(FormatG2Compr.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatG2Compr> {
      return TYPE.apply();
    }
  }

  export interface FormatG2Uncompr {
    dummy_field: boolean;
  }

  export namespace FormatG2Uncompr {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatG2Uncompr";

    const TYPE = new TypeDescriptor<FormatG2Uncompr>(
      FormatG2Uncompr.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FormatG2Uncompr> {
      return TYPE.apply();
    }
  }

  export interface FormatGt {
    dummy_field: boolean;
  }

  export namespace FormatGt {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatGt";

    const TYPE = new TypeDescriptor<FormatGt>(FormatGt.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatGt> {
      return TYPE.apply();
    }
  }

  export interface Fq12 {
    dummy_field: boolean;
  }

  export namespace Fq12 {
    export const TYPE_QNAME = "0x1::bn254_algebra::Fq12";

    const TYPE = new TypeDescriptor<Fq12>(Fq12.TYPE_QNAME);

    export function type(): TypeDescriptor<Fq12> {
      return TYPE.apply();
    }
  }

  export interface Fr {
    dummy_field: boolean;
  }

  export namespace Fr {
    export const TYPE_QNAME = "0x1::bn254_algebra::Fr";

    const TYPE = new TypeDescriptor<Fr>(Fr.TYPE_QNAME);

    export function type(): TypeDescriptor<Fr> {
      return TYPE.apply();
    }
  }

  export interface G1 {
    dummy_field: boolean;
  }

  export namespace G1 {
    export const TYPE_QNAME = "0x1::bn254_algebra::G1";

    const TYPE = new TypeDescriptor<G1>(G1.TYPE_QNAME);

    export function type(): TypeDescriptor<G1> {
      return TYPE.apply();
    }
  }

  export interface G2 {
    dummy_field: boolean;
  }

  export namespace G2 {
    export const TYPE_QNAME = "0x1::bn254_algebra::G2";

    const TYPE = new TypeDescriptor<G2>(G2.TYPE_QNAME);

    export function type(): TypeDescriptor<G2> {
      return TYPE.apply();
    }
  }

  export interface Gt {
    dummy_field: boolean;
  }

  export namespace Gt {
    export const TYPE_QNAME = "0x1::bn254_algebra::Gt";

    const TYPE = new TypeDescriptor<Gt>(Gt.TYPE_QNAME);

    export function type(): TypeDescriptor<Gt> {
      return TYPE.apply();
    }
  }

  export interface FormatFqLsb {
    dummy_field: boolean;
  }

  export namespace FormatFqLsb {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatFqLsb";

    const TYPE = new TypeDescriptor<FormatFqLsb>(FormatFqLsb.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatFqLsb> {
      return TYPE.apply();
    }
  }

  export interface FormatFqMsb {
    dummy_field: boolean;
  }

  export namespace FormatFqMsb {
    export const TYPE_QNAME = "0x1::bn254_algebra::FormatFqMsb";

    const TYPE = new TypeDescriptor<FormatFqMsb>(FormatFqMsb.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatFqMsb> {
      return TYPE.apply();
    }
  }

  export interface Fq {
    dummy_field: boolean;
  }

  export namespace Fq {
    export const TYPE_QNAME = "0x1::bn254_algebra::Fq";

    const TYPE = new TypeDescriptor<Fq>(Fq.TYPE_QNAME);

    export function type(): TypeDescriptor<Fq> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace config_buffer {
  export interface PendingConfigs {
    configs: simple_map.SimpleMap<string, any$.Any>;
  }

  export namespace PendingConfigs {
    export const TYPE_QNAME = "0x1::config_buffer::PendingConfigs";

    const TYPE = new TypeDescriptor<PendingConfigs>(PendingConfigs.TYPE_QNAME);

    export function type(): TypeDescriptor<PendingConfigs> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace create_signer {
  export namespace entry {}
  export namespace view {}
}

export namespace fixed_point32 {
  export interface FixedPoint32 {
    value: bigint;
  }

  export namespace FixedPoint32 {
    export const TYPE_QNAME = "0x1::fixed_point32::FixedPoint32";

    const TYPE = new TypeDescriptor<FixedPoint32>(FixedPoint32.TYPE_QNAME);

    export function type(): TypeDescriptor<FixedPoint32> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace fixed_point64 {
  export interface FixedPoint64 {
    value: bigint;
  }

  export namespace FixedPoint64 {
    export const TYPE_QNAME = "0x1::fixed_point64::FixedPoint64";

    const TYPE = new TypeDescriptor<FixedPoint64>(FixedPoint64.TYPE_QNAME);

    export function type(): TypeDescriptor<FixedPoint64> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace function_info {
  export interface FunctionInfo {
    module_address: MoveAddressType;
    module_name: string;
    function_name: string;
  }

  export namespace FunctionInfo {
    export const TYPE_QNAME = "0x1::function_info::FunctionInfo";

    const TYPE = new TypeDescriptor<FunctionInfo>(FunctionInfo.TYPE_QNAME);

    export function type(): TypeDescriptor<FunctionInfo> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace multi_ed25519 {
  export interface Signature {
    bytes: string;
  }

  export namespace Signature {
    export const TYPE_QNAME = "0x1::multi_ed25519::Signature";

    const TYPE = new TypeDescriptor<Signature>(Signature.TYPE_QNAME);

    export function type(): TypeDescriptor<Signature> {
      return TYPE.apply();
    }
  }

  export interface UnvalidatedPublicKey {
    bytes: string;
  }

  export namespace UnvalidatedPublicKey {
    export const TYPE_QNAME = "0x1::multi_ed25519::UnvalidatedPublicKey";

    const TYPE = new TypeDescriptor<UnvalidatedPublicKey>(
      UnvalidatedPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UnvalidatedPublicKey> {
      return TYPE.apply();
    }
  }

  export interface ValidatedPublicKey {
    bytes: string;
  }

  export namespace ValidatedPublicKey {
    export const TYPE_QNAME = "0x1::multi_ed25519::ValidatedPublicKey";

    const TYPE = new TypeDescriptor<ValidatedPublicKey>(
      ValidatedPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatedPublicKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class staking_proxy extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("staking_proxy", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): staking_proxy {
    return new staking_proxy({ ...staking_proxy.DEFAULT_OPTIONS, ...options });
  }

  onEntrySetOperator(
    func: (call: staking_proxy.SetOperatorPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetOperatorPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetStakePoolOperator(
    func: (
      call: staking_proxy.SetStakePoolOperatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetStakePoolOperatorPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_stake_pool_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetStakePoolVoter(
    func: (
      call: staking_proxy.SetStakePoolVoterPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetStakePoolVoterPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_stake_pool_voter",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetStakingContractOperator(
    func: (
      call: staking_proxy.SetStakingContractOperatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetStakingContractOperatorPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_staking_contract_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetStakingContractVoter(
    func: (
      call: staking_proxy.SetStakingContractVoterPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetStakingContractVoterPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_staking_contract_voter",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetVestingContractOperator(
    func: (
      call: staking_proxy.SetVestingContractOperatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetVestingContractOperatorPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_vesting_contract_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetVestingContractVoter(
    func: (
      call: staking_proxy.SetVestingContractVoterPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetVestingContractVoterPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_vesting_contract_voter",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetVoter(
    func: (call: staking_proxy.SetVoterPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_proxy.SetVoterPayload
    >,
  ): staking_proxy {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_proxy::set_voter",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace staking_proxy {
  export interface StakeProxyPermission {
    dummy_field: boolean;
  }

  export namespace StakeProxyPermission {
    export const TYPE_QNAME = "0x1::staking_proxy::StakeProxyPermission";

    const TYPE = new TypeDescriptor<StakeProxyPermission>(
      StakeProxyPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StakeProxyPermission> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function setOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setStakePoolOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_stake_pool_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setStakePoolVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_stake_pool_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setStakingContractOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_staking_contract_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setStakingContractVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_staking_contract_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setVestingContractOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_vesting_contract_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setVestingContractVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_vesting_contract_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_proxy::set_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface SetOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetStakePoolOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface SetStakePoolVoterPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface SetStakingContractOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetStakingContractVoterPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetVestingContractOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetVestingContractVoterPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SetVoterPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }
}

export namespace state_storage {
  export interface GasParameter {
    usage: state_storage.Usage;
  }

  export namespace GasParameter {
    export const TYPE_QNAME = "0x1::state_storage::GasParameter";

    const TYPE = new TypeDescriptor<GasParameter>(GasParameter.TYPE_QNAME);

    export function type(): TypeDescriptor<GasParameter> {
      return TYPE.apply();
    }
  }

  export interface StateStorageUsage {
    epoch: bigint;
    usage: state_storage.Usage;
  }

  export namespace StateStorageUsage {
    export const TYPE_QNAME = "0x1::state_storage::StateStorageUsage";

    const TYPE = new TypeDescriptor<StateStorageUsage>(
      StateStorageUsage.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StateStorageUsage> {
      return TYPE.apply();
    }
  }

  export interface Usage {
    items: bigint;
    bytes: bigint;
  }

  export namespace Usage {
    export const TYPE_QNAME = "0x1::state_storage::Usage";

    const TYPE = new TypeDescriptor<Usage>(Usage.TYPE_QNAME);

    export function type(): TypeDescriptor<Usage> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace crypto_algebra {
  export interface Element<T0> {
    handle: bigint;
  }

  export namespace Element {
    export const TYPE_QNAME = "0x1::crypto_algebra::Element";

    const TYPE = new TypeDescriptor<Element<any>>(Element.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Element<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class fungible_asset extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("fungible_asset", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): fungible_asset {
    return new fungible_asset({
      ...fungible_asset.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryTransfer(
    func: (call: fungible_asset.TransferPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.TransferPayload
    >,
  ): fungible_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "fungible_asset::transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpgradeStoreToConcurrent(
    func: (
      call: fungible_asset.UpgradeStoreToConcurrentPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.UpgradeStoreToConcurrentPayload
    >,
  ): fungible_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "fungible_asset::upgrade_store_to_concurrent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventTransferRef(
    func: (
      event: fungible_asset.TransferRefInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.TransferRefInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::TransferRef" },
      handlerOptions,
    );
    return this;
  }

  onEventBurnRef(
    func: (event: fungible_asset.BurnRefInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.BurnRefInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::BurnRef" },
      handlerOptions,
    );
    return this;
  }

  onEventCreation(
    func: (event: fungible_asset.CreationInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.CreationInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::Creation" },
      handlerOptions,
    );
    return this;
  }

  onEventDeposit(
    func: (event: fungible_asset.DepositInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.DepositInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::Deposit" },
      handlerOptions,
    );
    return this;
  }

  onEventDepositEvent(
    func: (
      event: fungible_asset.DepositEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.DepositEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::DepositEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventFrozen(
    func: (event: fungible_asset.FrozenInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.FrozenInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::Frozen" },
      handlerOptions,
    );
    return this;
  }

  onEventFrozenEvent(
    func: (
      event: fungible_asset.FrozenEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.FrozenEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::FrozenEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventFungibleStoreDeletion(
    func: (
      event: fungible_asset.FungibleStoreDeletionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.FungibleStoreDeletionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::FungibleStoreDeletion" },
      handlerOptions,
    );
    return this;
  }

  onEventMintRef(
    func: (event: fungible_asset.MintRefInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.MintRefInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::MintRef" },
      handlerOptions,
    );
    return this;
  }

  onEventMutateMetadataRef(
    func: (
      event: fungible_asset.MutateMetadataRefInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.MutateMetadataRefInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::MutateMetadataRef" },
      handlerOptions,
    );
    return this;
  }

  onEventRawBalanceRef(
    func: (
      event: fungible_asset.RawBalanceRefInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.RawBalanceRefInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::RawBalanceRef" },
      handlerOptions,
    );
    return this;
  }

  onEventRawSupplyRef(
    func: (
      event: fungible_asset.RawSupplyRefInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.RawSupplyRefInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::RawSupplyRef" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdraw(
    func: (event: fungible_asset.WithdrawInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.WithdrawInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::Withdraw" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawEvent(
    func: (
      event: fungible_asset.WithdrawEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      fungible_asset.WithdrawEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): fungible_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "fungible_asset::WithdrawEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace fungible_asset {
  export interface TransferRef {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace TransferRef {
    export const TYPE_QNAME = "0x1::fungible_asset::TransferRef";

    const TYPE = new TypeDescriptor<TransferRef>(TransferRef.TYPE_QNAME);

    export function type(): TypeDescriptor<TransferRef> {
      return TYPE.apply();
    }
  }

  export type TransferRefInstance = TypedEventInstance<TransferRef> & {
    data_decoded: TransferRef;
    type_arguments: [];
  };

  export interface Untransferable {
    dummy_field: boolean;
  }

  export namespace Untransferable {
    export const TYPE_QNAME = "0x1::fungible_asset::Untransferable";

    const TYPE = new TypeDescriptor<Untransferable>(Untransferable.TYPE_QNAME);

    export function type(): TypeDescriptor<Untransferable> {
      return TYPE.apply();
    }
  }

  export interface BurnRef {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace BurnRef {
    export const TYPE_QNAME = "0x1::fungible_asset::BurnRef";

    const TYPE = new TypeDescriptor<BurnRef>(BurnRef.TYPE_QNAME);

    export function type(): TypeDescriptor<BurnRef> {
      return TYPE.apply();
    }
  }

  export type BurnRefInstance = TypedEventInstance<BurnRef> & {
    data_decoded: BurnRef;
    type_arguments: [];
  };

  export interface ConcurrentFungibleBalance {
    balance: aggregator_v2.Aggregator<bigint>;
  }

  export namespace ConcurrentFungibleBalance {
    export const TYPE_QNAME = "0x1::fungible_asset::ConcurrentFungibleBalance";

    const TYPE = new TypeDescriptor<ConcurrentFungibleBalance>(
      ConcurrentFungibleBalance.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ConcurrentFungibleBalance> {
      return TYPE.apply();
    }
  }

  export interface ConcurrentSupply {
    current: aggregator_v2.Aggregator<bigint>;
  }

  export namespace ConcurrentSupply {
    export const TYPE_QNAME = "0x1::fungible_asset::ConcurrentSupply";

    const TYPE = new TypeDescriptor<ConcurrentSupply>(
      ConcurrentSupply.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ConcurrentSupply> {
      return TYPE.apply();
    }
  }

  export interface Creation {
    metadata: MoveAddressType;
    name: string;
    symbol: string;
    decimals: number;
    icon_uri: string;
    project_uri: string;
    maximum_supply: option.Option<bigint>;
  }

  export namespace Creation {
    export const TYPE_QNAME = "0x1::fungible_asset::Creation";

    const TYPE = new TypeDescriptor<Creation>(Creation.TYPE_QNAME);

    export function type(): TypeDescriptor<Creation> {
      return TYPE.apply();
    }
  }

  export type CreationInstance = TypedEventInstance<Creation> & {
    data_decoded: Creation;
    type_arguments: [];
  };

  export interface Deposit {
    store: MoveAddressType;
    amount: bigint;
  }

  export namespace Deposit {
    export const TYPE_QNAME = "0x1::fungible_asset::Deposit";

    const TYPE = new TypeDescriptor<Deposit>(Deposit.TYPE_QNAME);

    export function type(): TypeDescriptor<Deposit> {
      return TYPE.apply();
    }
  }

  export type DepositInstance = TypedEventInstance<Deposit> & {
    data_decoded: Deposit;
    type_arguments: [];
  };

  export interface DepositEvent {
    amount: bigint;
  }

  export namespace DepositEvent {
    export const TYPE_QNAME = "0x1::fungible_asset::DepositEvent";

    const TYPE = new TypeDescriptor<DepositEvent>(DepositEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<DepositEvent> {
      return TYPE.apply();
    }
  }

  export type DepositEventInstance = TypedEventInstance<DepositEvent> & {
    data_decoded: DepositEvent;
    type_arguments: [];
  };

  export interface DeriveSupply {
    dispatch_function: option.Option<function_info.FunctionInfo>;
  }

  export namespace DeriveSupply {
    export const TYPE_QNAME = "0x1::fungible_asset::DeriveSupply";

    const TYPE = new TypeDescriptor<DeriveSupply>(DeriveSupply.TYPE_QNAME);

    export function type(): TypeDescriptor<DeriveSupply> {
      return TYPE.apply();
    }
  }

  export interface DispatchFunctionStore {
    withdraw_function: option.Option<function_info.FunctionInfo>;
    deposit_function: option.Option<function_info.FunctionInfo>;
    derived_balance_function: option.Option<function_info.FunctionInfo>;
  }

  export namespace DispatchFunctionStore {
    export const TYPE_QNAME = "0x1::fungible_asset::DispatchFunctionStore";

    const TYPE = new TypeDescriptor<DispatchFunctionStore>(
      DispatchFunctionStore.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DispatchFunctionStore> {
      return TYPE.apply();
    }
  }

  export interface Frozen {
    store: MoveAddressType;
    frozen: boolean;
  }

  export namespace Frozen {
    export const TYPE_QNAME = "0x1::fungible_asset::Frozen";

    const TYPE = new TypeDescriptor<Frozen>(Frozen.TYPE_QNAME);

    export function type(): TypeDescriptor<Frozen> {
      return TYPE.apply();
    }
  }

  export type FrozenInstance = TypedEventInstance<Frozen> & {
    data_decoded: Frozen;
    type_arguments: [];
  };

  export interface FrozenEvent {
    frozen: boolean;
  }

  export namespace FrozenEvent {
    export const TYPE_QNAME = "0x1::fungible_asset::FrozenEvent";

    const TYPE = new TypeDescriptor<FrozenEvent>(FrozenEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<FrozenEvent> {
      return TYPE.apply();
    }
  }

  export type FrozenEventInstance = TypedEventInstance<FrozenEvent> & {
    data_decoded: FrozenEvent;
    type_arguments: [];
  };

  export interface FungibleAsset {
    metadata: object$.Object<fungible_asset.Metadata>;
    amount: bigint;
  }

  export namespace FungibleAsset {
    export const TYPE_QNAME = "0x1::fungible_asset::FungibleAsset";

    const TYPE = new TypeDescriptor<FungibleAsset>(FungibleAsset.TYPE_QNAME);

    export function type(): TypeDescriptor<FungibleAsset> {
      return TYPE.apply();
    }
  }

  export interface FungibleAssetEvents {
    deposit_events: event.EventHandle<fungible_asset.DepositEvent>;
    withdraw_events: event.EventHandle<fungible_asset.WithdrawEvent>;
    frozen_events: event.EventHandle<fungible_asset.FrozenEvent>;
  }

  export namespace FungibleAssetEvents {
    export const TYPE_QNAME = "0x1::fungible_asset::FungibleAssetEvents";

    const TYPE = new TypeDescriptor<FungibleAssetEvents>(
      FungibleAssetEvents.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FungibleAssetEvents> {
      return TYPE.apply();
    }
  }

  export interface FungibleStore {
    metadata: object$.Object<fungible_asset.Metadata>;
    balance: bigint;
    frozen: boolean;
  }

  export namespace FungibleStore {
    export const TYPE_QNAME = "0x1::fungible_asset::FungibleStore";

    const TYPE = new TypeDescriptor<FungibleStore>(FungibleStore.TYPE_QNAME);

    export function type(): TypeDescriptor<FungibleStore> {
      return TYPE.apply();
    }
  }

  export interface FungibleStoreDeletion {
    store: MoveAddressType;
    owner: MoveAddressType;
    metadata: MoveAddressType;
  }

  export namespace FungibleStoreDeletion {
    export const TYPE_QNAME = "0x1::fungible_asset::FungibleStoreDeletion";

    const TYPE = new TypeDescriptor<FungibleStoreDeletion>(
      FungibleStoreDeletion.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FungibleStoreDeletion> {
      return TYPE.apply();
    }
  }

  export type FungibleStoreDeletionInstance =
    TypedEventInstance<FungibleStoreDeletion> & {
      data_decoded: FungibleStoreDeletion;
      type_arguments: [];
    };

  export interface Metadata {
    name: string;
    symbol: string;
    decimals: number;
    icon_uri: string;
    project_uri: string;
  }

  export namespace Metadata {
    export const TYPE_QNAME = "0x1::fungible_asset::Metadata";

    const TYPE = new TypeDescriptor<Metadata>(Metadata.TYPE_QNAME);

    export function type(): TypeDescriptor<Metadata> {
      return TYPE.apply();
    }
  }

  export interface MintRef {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace MintRef {
    export const TYPE_QNAME = "0x1::fungible_asset::MintRef";

    const TYPE = new TypeDescriptor<MintRef>(MintRef.TYPE_QNAME);

    export function type(): TypeDescriptor<MintRef> {
      return TYPE.apply();
    }
  }

  export type MintRefInstance = TypedEventInstance<MintRef> & {
    data_decoded: MintRef;
    type_arguments: [];
  };

  export interface MutateMetadataRef {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace MutateMetadataRef {
    export const TYPE_QNAME = "0x1::fungible_asset::MutateMetadataRef";

    const TYPE = new TypeDescriptor<MutateMetadataRef>(
      MutateMetadataRef.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MutateMetadataRef> {
      return TYPE.apply();
    }
  }

  export type MutateMetadataRefInstance =
    TypedEventInstance<MutateMetadataRef> & {
      data_decoded: MutateMetadataRef;
      type_arguments: [];
    };

  export interface RawBalanceRef {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace RawBalanceRef {
    export const TYPE_QNAME = "0x1::fungible_asset::RawBalanceRef";

    const TYPE = new TypeDescriptor<RawBalanceRef>(RawBalanceRef.TYPE_QNAME);

    export function type(): TypeDescriptor<RawBalanceRef> {
      return TYPE.apply();
    }
  }

  export type RawBalanceRefInstance = TypedEventInstance<RawBalanceRef> & {
    data_decoded: RawBalanceRef;
    type_arguments: [];
  };

  export interface RawSupplyRef {
    metadata: object$.Object<fungible_asset.Metadata>;
  }

  export namespace RawSupplyRef {
    export const TYPE_QNAME = "0x1::fungible_asset::RawSupplyRef";

    const TYPE = new TypeDescriptor<RawSupplyRef>(RawSupplyRef.TYPE_QNAME);

    export function type(): TypeDescriptor<RawSupplyRef> {
      return TYPE.apply();
    }
  }

  export type RawSupplyRefInstance = TypedEventInstance<RawSupplyRef> & {
    data_decoded: RawSupplyRef;
    type_arguments: [];
  };

  export interface Supply {
    current: bigint;
    maximum: option.Option<bigint>;
  }

  export namespace Supply {
    export const TYPE_QNAME = "0x1::fungible_asset::Supply";

    const TYPE = new TypeDescriptor<Supply>(Supply.TYPE_QNAME);

    export function type(): TypeDescriptor<Supply> {
      return TYPE.apply();
    }
  }

  export interface Withdraw {
    store: MoveAddressType;
    amount: bigint;
  }

  export namespace Withdraw {
    export const TYPE_QNAME = "0x1::fungible_asset::Withdraw";

    const TYPE = new TypeDescriptor<Withdraw>(Withdraw.TYPE_QNAME);

    export function type(): TypeDescriptor<Withdraw> {
      return TYPE.apply();
    }
  }

  export type WithdrawInstance = TypedEventInstance<Withdraw> & {
    data_decoded: Withdraw;
    type_arguments: [];
  };

  export interface WithdrawEvent {
    amount: bigint;
  }

  export namespace WithdrawEvent {
    export const TYPE_QNAME = "0x1::fungible_asset::WithdrawEvent";

    const TYPE = new TypeDescriptor<WithdrawEvent>(WithdrawEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<WithdrawEvent> {
      return TYPE.apply();
    }
  }

  export type WithdrawEventInstance = TypedEventInstance<WithdrawEvent> & {
    data_decoded: WithdrawEvent;
    type_arguments: [];
  };

  export interface WithdrawPermission {}

  export namespace WithdrawPermission {
    export const TYPE_QNAME = "0x1::fungible_asset::WithdrawPermission";

    const TYPE = new TypeDescriptor<WithdrawPermission>(
      WithdrawPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<WithdrawPermission> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function transfer<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, object$.Object<T0>, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::fungible_asset::transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function upgradeStoreToConcurrent<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::fungible_asset::upgrade_store_to_concurrent",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function name<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::name",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::name");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isUntransferable<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::is_untransferable",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::is_untransferable",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function symbol$<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::symbol",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::symbol");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function decimals<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[number]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::decimals",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::decimals");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function iconUri<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::icon_uri",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::icon_uri");
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function projectUri<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::project_uri",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::project_uri",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function balance<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::balance",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::balance");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function metadata<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[fungible_asset.Metadata]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::metadata",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::metadata");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isAssetTypeDispatchable(
      client: Aptos,
      request: {
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::is_asset_type_dispatchable",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::is_asset_type_dispatchable",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isBalanceAtLeast<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::is_balance_at_least",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::is_balance_at_least",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isFrozen<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::is_frozen",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::is_frozen",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isStoreDispatchable<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::is_store_dispatchable",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::is_store_dispatchable",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function maximum<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[option.Option<bigint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::maximum",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::maximum");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function storeExists(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::store_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::store_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function storeMetadata<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[object$.Object<fungible_asset.Metadata>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::store_metadata",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::fungible_asset::store_metadata",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function supply<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[option.Option<bigint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::fungible_asset::supply",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::fungible_asset::supply");
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface TransferPayload<T0 = any>
    extends TypedFunctionPayload<
      [object$.Object<T0>, object$.Object<T0>, bigint]
    > {
    arguments_decoded: [object$.Object<T0>, object$.Object<T0>, bigint];
    type_arguments: [string];
  }

  export interface UpgradeStoreToConcurrentPayload<T0 = any>
    extends TypedFunctionPayload<[object$.Object<T0>]> {
    arguments_decoded: [object$.Object<T0>];
    type_arguments: [string];
  }
}

export namespace sigma_protocol {
  export namespace entry {}
  export namespace view {}
}

export namespace staking_config {
  export interface StakingConfig {
    minimum_stake: bigint;
    maximum_stake: bigint;
    recurring_lockup_duration_secs: bigint;
    allow_validator_set_change: boolean;
    rewards_rate: bigint;
    rewards_rate_denominator: bigint;
    voting_power_increase_limit: bigint;
  }

  export namespace StakingConfig {
    export const TYPE_QNAME = "0x1::staking_config::StakingConfig";

    const TYPE = new TypeDescriptor<StakingConfig>(StakingConfig.TYPE_QNAME);

    export function type(): TypeDescriptor<StakingConfig> {
      return TYPE.apply();
    }
  }

  export interface StakingRewardsConfig {
    rewards_rate: fixed_point64.FixedPoint64;
    min_rewards_rate: fixed_point64.FixedPoint64;
    rewards_rate_period_in_secs: bigint;
    last_rewards_rate_period_start_in_secs: bigint;
    rewards_rate_decrease_rate: fixed_point64.FixedPoint64;
  }

  export namespace StakingRewardsConfig {
    export const TYPE_QNAME = "0x1::staking_config::StakingRewardsConfig";

    const TYPE = new TypeDescriptor<StakingRewardsConfig>(
      StakingRewardsConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StakingRewardsConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {
    export async function rewardRate(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_config::reward_rate",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_config::reward_rate",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace big_ordered_map {
  export interface IteratorPtr<T0> {}

  export namespace IteratorPtr {
    export const TYPE_QNAME = "0x1::big_ordered_map::IteratorPtr";

    const TYPE = new TypeDescriptor<IteratorPtr<any>>(IteratorPtr.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<IteratorPtr<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface BigOrderedMap<T0, T1> {}

  export namespace BigOrderedMap {
    export const TYPE_QNAME = "0x1::big_ordered_map::BigOrderedMap";

    const TYPE = new TypeDescriptor<BigOrderedMap<any, any>>(
      BigOrderedMap.TYPE_QNAME,
    );

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<BigOrderedMap<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export interface Child<T0> {}

  export namespace Child {
    export const TYPE_QNAME = "0x1::big_ordered_map::Child";

    const TYPE = new TypeDescriptor<Child<any>>(Child.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Child<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface IteratorPtrWithPath<T0> {
    iterator: big_ordered_map.IteratorPtr<T0>;
    path: bigint[];
  }

  export namespace IteratorPtrWithPath {
    export const TYPE_QNAME = "0x1::big_ordered_map::IteratorPtrWithPath";

    const TYPE = new TypeDescriptor<IteratorPtrWithPath<any>>(
      IteratorPtrWithPath.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<IteratorPtrWithPath<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface LeafNodeIteratorPtr {}

  export namespace LeafNodeIteratorPtr {
    export const TYPE_QNAME = "0x1::big_ordered_map::LeafNodeIteratorPtr";

    const TYPE = new TypeDescriptor<LeafNodeIteratorPtr>(
      LeafNodeIteratorPtr.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<LeafNodeIteratorPtr> {
      return TYPE.apply();
    }
  }

  export interface Node<T0, T1> {}

  export namespace Node {
    export const TYPE_QNAME = "0x1::big_ordered_map::Node";

    const TYPE = new TypeDescriptor<Node<any, any>>(Node.TYPE_QNAME);

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<Node<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class delegation_pool extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("delegation_pool", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): delegation_pool {
    return new delegation_pool({
      ...delegation_pool.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryWithdraw(
    func: (call: delegation_pool.WithdrawPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.WithdrawPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::withdraw",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateProposal(
    func: (
      call: delegation_pool.CreateProposalPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.CreateProposalPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::create_proposal",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryVote(
    func: (call: delegation_pool.VotePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.VotePayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::vote",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddStake(
    func: (call: delegation_pool.AddStakePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.AddStakePayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::add_stake",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryReactivateStake(
    func: (
      call: delegation_pool.ReactivateStakePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.ReactivateStakePayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::reactivate_stake",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetDelegatedVoter(
    func: (
      call: delegation_pool.SetDelegatedVoterPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.SetDelegatedVoterPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::set_delegated_voter",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetOperator(
    func: (call: delegation_pool.SetOperatorPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.SetOperatorPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::set_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnlock(
    func: (call: delegation_pool.UnlockPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.UnlockPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::unlock",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAllowlistDelegator(
    func: (
      call: delegation_pool.AllowlistDelegatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.AllowlistDelegatorPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::allowlist_delegator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDelegateVotingPower(
    func: (
      call: delegation_pool.DelegateVotingPowerPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.DelegateVotingPowerPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::delegate_voting_power",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDisableDelegatorsAllowlisting(
    func: (
      call: delegation_pool.DisableDelegatorsAllowlistingPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.DisableDelegatorsAllowlistingPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::disable_delegators_allowlisting",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryEnableDelegatorsAllowlisting(
    func: (
      call: delegation_pool.EnableDelegatorsAllowlistingPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.EnableDelegatorsAllowlistingPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::enable_delegators_allowlisting",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryEnablePartialGovernanceVoting(
    func: (
      call: delegation_pool.EnablePartialGovernanceVotingPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.EnablePartialGovernanceVotingPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::enable_partial_governance_voting",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryEvictDelegator(
    func: (
      call: delegation_pool.EvictDelegatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.EvictDelegatorPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::evict_delegator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryInitializeDelegationPool(
    func: (
      call: delegation_pool.InitializeDelegationPoolPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.InitializeDelegationPoolPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::initialize_delegation_pool",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveDelegatorFromAllowlist(
    func: (
      call: delegation_pool.RemoveDelegatorFromAllowlistPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.RemoveDelegatorFromAllowlistPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::remove_delegator_from_allowlist",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetBeneficiaryForOperator(
    func: (
      call: delegation_pool.SetBeneficiaryForOperatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.SetBeneficiaryForOperatorPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::set_beneficiary_for_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySynchronizeDelegationPool(
    func: (
      call: delegation_pool.SynchronizeDelegationPoolPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.SynchronizeDelegationPoolPayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::synchronize_delegation_pool",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateCommissionPercentage(
    func: (
      call: delegation_pool.UpdateCommissionPercentagePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.UpdateCommissionPercentagePayload
    >,
  ): delegation_pool {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "delegation_pool::update_commission_percentage",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCreateProposal(
    func: (
      event: delegation_pool.CreateProposalInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.CreateProposalInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::CreateProposal" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateProposalEvent(
    func: (
      event: delegation_pool.CreateProposalEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.CreateProposalEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::CreateProposalEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventVote(
    func: (event: delegation_pool.VoteInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.VoteInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::Vote" },
      handlerOptions,
    );
    return this;
  }

  onEventVoteEvent(
    func: (event: delegation_pool.VoteEventInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.VoteEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::VoteEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventAddStake(
    func: (event: delegation_pool.AddStakeInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.AddStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::AddStake" },
      handlerOptions,
    );
    return this;
  }

  onEventAddStakeEvent(
    func: (
      event: delegation_pool.AddStakeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.AddStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::AddStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventReactivateStake(
    func: (
      event: delegation_pool.ReactivateStakeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.ReactivateStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::ReactivateStake" },
      handlerOptions,
    );
    return this;
  }

  onEventReactivateStakeEvent(
    func: (
      event: delegation_pool.ReactivateStakeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.ReactivateStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::ReactivateStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockStake(
    func: (
      event: delegation_pool.UnlockStakeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.UnlockStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::UnlockStake" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockStakeEvent(
    func: (
      event: delegation_pool.UnlockStakeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.UnlockStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::UnlockStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawStake(
    func: (
      event: delegation_pool.WithdrawStakeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.WithdrawStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::WithdrawStake" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawStakeEvent(
    func: (
      event: delegation_pool.WithdrawStakeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.WithdrawStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::WithdrawStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventAllowlistDelegator(
    func: (
      event: delegation_pool.AllowlistDelegatorInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.AllowlistDelegatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::AllowlistDelegator" },
      handlerOptions,
    );
    return this;
  }

  onEventCommissionPercentageChange(
    func: (
      event: delegation_pool.CommissionPercentageChangeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.CommissionPercentageChangeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "delegation_pool::CommissionPercentageChange",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDelegateVotingPower(
    func: (
      event: delegation_pool.DelegateVotingPowerInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.DelegateVotingPowerInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::DelegateVotingPower" },
      handlerOptions,
    );
    return this;
  }

  onEventDelegateVotingPowerEvent(
    func: (
      event: delegation_pool.DelegateVotingPowerEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.DelegateVotingPowerEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "delegation_pool::DelegateVotingPowerEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDisableDelegatorsAllowlisting(
    func: (
      event: delegation_pool.DisableDelegatorsAllowlistingInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.DisableDelegatorsAllowlistingInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "delegation_pool::DisableDelegatorsAllowlisting",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDistributeCommission(
    func: (
      event: delegation_pool.DistributeCommissionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.DistributeCommissionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::DistributeCommission" },
      handlerOptions,
    );
    return this;
  }

  onEventDistributeCommissionEvent(
    func: (
      event: delegation_pool.DistributeCommissionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.DistributeCommissionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "delegation_pool::DistributeCommissionEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventEnableDelegatorsAllowlisting(
    func: (
      event: delegation_pool.EnableDelegatorsAllowlistingInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.EnableDelegatorsAllowlistingInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "delegation_pool::EnableDelegatorsAllowlisting",
      },
      handlerOptions,
    );
    return this;
  }

  onEventEvictDelegator(
    func: (
      event: delegation_pool.EvictDelegatorInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.EvictDelegatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "delegation_pool::EvictDelegator" },
      handlerOptions,
    );
    return this;
  }

  onEventRemoveDelegatorFromAllowlist(
    func: (
      event: delegation_pool.RemoveDelegatorFromAllowlistInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.RemoveDelegatorFromAllowlistInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "delegation_pool::RemoveDelegatorFromAllowlist",
      },
      handlerOptions,
    );
    return this;
  }

  onEventSetBeneficiaryForOperator(
    func: (
      event: delegation_pool.SetBeneficiaryForOperatorInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      delegation_pool.SetBeneficiaryForOperatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): delegation_pool {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "delegation_pool::SetBeneficiaryForOperator",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace delegation_pool {
  export interface CreateProposal {
    proposal_id: bigint;
    voter: MoveAddressType;
    delegation_pool: MoveAddressType;
  }

  export namespace CreateProposal {
    export const TYPE_QNAME = "0x1::delegation_pool::CreateProposal";

    const TYPE = new TypeDescriptor<CreateProposal>(CreateProposal.TYPE_QNAME);

    export function type(): TypeDescriptor<CreateProposal> {
      return TYPE.apply();
    }
  }

  export type CreateProposalInstance = TypedEventInstance<CreateProposal> & {
    data_decoded: CreateProposal;
    type_arguments: [];
  };

  export interface CreateProposalEvent {
    proposal_id: bigint;
    voter: MoveAddressType;
    delegation_pool: MoveAddressType;
  }

  export namespace CreateProposalEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::CreateProposalEvent";

    const TYPE = new TypeDescriptor<CreateProposalEvent>(
      CreateProposalEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateProposalEvent> {
      return TYPE.apply();
    }
  }

  export type CreateProposalEventInstance =
    TypedEventInstance<CreateProposalEvent> & {
      data_decoded: CreateProposalEvent;
      type_arguments: [];
    };

  export interface Vote {
    voter: MoveAddressType;
    proposal_id: bigint;
    delegation_pool: MoveAddressType;
    num_votes: bigint;
    should_pass: boolean;
  }

  export namespace Vote {
    export const TYPE_QNAME = "0x1::delegation_pool::Vote";

    const TYPE = new TypeDescriptor<Vote>(Vote.TYPE_QNAME);

    export function type(): TypeDescriptor<Vote> {
      return TYPE.apply();
    }
  }

  export type VoteInstance = TypedEventInstance<Vote> & {
    data_decoded: Vote;
    type_arguments: [];
  };

  export interface VoteEvent {
    voter: MoveAddressType;
    proposal_id: bigint;
    delegation_pool: MoveAddressType;
    num_votes: bigint;
    should_pass: boolean;
  }

  export namespace VoteEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::VoteEvent";

    const TYPE = new TypeDescriptor<VoteEvent>(VoteEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<VoteEvent> {
      return TYPE.apply();
    }
  }

  export type VoteEventInstance = TypedEventInstance<VoteEvent> & {
    data_decoded: VoteEvent;
    type_arguments: [];
  };

  export interface AddStake {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_added: bigint;
    add_stake_fee: bigint;
  }

  export namespace AddStake {
    export const TYPE_QNAME = "0x1::delegation_pool::AddStake";

    const TYPE = new TypeDescriptor<AddStake>(AddStake.TYPE_QNAME);

    export function type(): TypeDescriptor<AddStake> {
      return TYPE.apply();
    }
  }

  export type AddStakeInstance = TypedEventInstance<AddStake> & {
    data_decoded: AddStake;
    type_arguments: [];
  };

  export interface AddStakeEvent {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_added: bigint;
    add_stake_fee: bigint;
  }

  export namespace AddStakeEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::AddStakeEvent";

    const TYPE = new TypeDescriptor<AddStakeEvent>(AddStakeEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<AddStakeEvent> {
      return TYPE.apply();
    }
  }

  export type AddStakeEventInstance = TypedEventInstance<AddStakeEvent> & {
    data_decoded: AddStakeEvent;
    type_arguments: [];
  };

  export interface ReactivateStake {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_reactivated: bigint;
  }

  export namespace ReactivateStake {
    export const TYPE_QNAME = "0x1::delegation_pool::ReactivateStake";

    const TYPE = new TypeDescriptor<ReactivateStake>(
      ReactivateStake.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ReactivateStake> {
      return TYPE.apply();
    }
  }

  export type ReactivateStakeInstance = TypedEventInstance<ReactivateStake> & {
    data_decoded: ReactivateStake;
    type_arguments: [];
  };

  export interface ReactivateStakeEvent {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_reactivated: bigint;
  }

  export namespace ReactivateStakeEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::ReactivateStakeEvent";

    const TYPE = new TypeDescriptor<ReactivateStakeEvent>(
      ReactivateStakeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ReactivateStakeEvent> {
      return TYPE.apply();
    }
  }

  export type ReactivateStakeEventInstance =
    TypedEventInstance<ReactivateStakeEvent> & {
      data_decoded: ReactivateStakeEvent;
      type_arguments: [];
    };

  export interface UnlockStake {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_unlocked: bigint;
  }

  export namespace UnlockStake {
    export const TYPE_QNAME = "0x1::delegation_pool::UnlockStake";

    const TYPE = new TypeDescriptor<UnlockStake>(UnlockStake.TYPE_QNAME);

    export function type(): TypeDescriptor<UnlockStake> {
      return TYPE.apply();
    }
  }

  export type UnlockStakeInstance = TypedEventInstance<UnlockStake> & {
    data_decoded: UnlockStake;
    type_arguments: [];
  };

  export interface UnlockStakeEvent {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_unlocked: bigint;
  }

  export namespace UnlockStakeEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::UnlockStakeEvent";

    const TYPE = new TypeDescriptor<UnlockStakeEvent>(
      UnlockStakeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UnlockStakeEvent> {
      return TYPE.apply();
    }
  }

  export type UnlockStakeEventInstance =
    TypedEventInstance<UnlockStakeEvent> & {
      data_decoded: UnlockStakeEvent;
      type_arguments: [];
    };

  export interface WithdrawStake {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_withdrawn: bigint;
  }

  export namespace WithdrawStake {
    export const TYPE_QNAME = "0x1::delegation_pool::WithdrawStake";

    const TYPE = new TypeDescriptor<WithdrawStake>(WithdrawStake.TYPE_QNAME);

    export function type(): TypeDescriptor<WithdrawStake> {
      return TYPE.apply();
    }
  }

  export type WithdrawStakeInstance = TypedEventInstance<WithdrawStake> & {
    data_decoded: WithdrawStake;
    type_arguments: [];
  };

  export interface WithdrawStakeEvent {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
    amount_withdrawn: bigint;
  }

  export namespace WithdrawStakeEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::WithdrawStakeEvent";

    const TYPE = new TypeDescriptor<WithdrawStakeEvent>(
      WithdrawStakeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<WithdrawStakeEvent> {
      return TYPE.apply();
    }
  }

  export type WithdrawStakeEventInstance =
    TypedEventInstance<WithdrawStakeEvent> & {
      data_decoded: WithdrawStakeEvent;
      type_arguments: [];
    };

  export interface AllowlistDelegator {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
  }

  export namespace AllowlistDelegator {
    export const TYPE_QNAME = "0x1::delegation_pool::AllowlistDelegator";

    const TYPE = new TypeDescriptor<AllowlistDelegator>(
      AllowlistDelegator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AllowlistDelegator> {
      return TYPE.apply();
    }
  }

  export type AllowlistDelegatorInstance =
    TypedEventInstance<AllowlistDelegator> & {
      data_decoded: AllowlistDelegator;
      type_arguments: [];
    };

  export interface BeneficiaryForOperator {
    beneficiary_for_operator: MoveAddressType;
  }

  export namespace BeneficiaryForOperator {
    export const TYPE_QNAME = "0x1::delegation_pool::BeneficiaryForOperator";

    const TYPE = new TypeDescriptor<BeneficiaryForOperator>(
      BeneficiaryForOperator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<BeneficiaryForOperator> {
      return TYPE.apply();
    }
  }

  export interface CommissionPercentageChange {
    pool_address: MoveAddressType;
    owner: MoveAddressType;
    commission_percentage_next_lockup_cycle: bigint;
  }

  export namespace CommissionPercentageChange {
    export const TYPE_QNAME =
      "0x1::delegation_pool::CommissionPercentageChange";

    const TYPE = new TypeDescriptor<CommissionPercentageChange>(
      CommissionPercentageChange.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CommissionPercentageChange> {
      return TYPE.apply();
    }
  }

  export type CommissionPercentageChangeInstance =
    TypedEventInstance<CommissionPercentageChange> & {
      data_decoded: CommissionPercentageChange;
      type_arguments: [];
    };

  export interface DelegateVotingPower {
    pool_address: MoveAddressType;
    delegator: MoveAddressType;
    voter: MoveAddressType;
  }

  export namespace DelegateVotingPower {
    export const TYPE_QNAME = "0x1::delegation_pool::DelegateVotingPower";

    const TYPE = new TypeDescriptor<DelegateVotingPower>(
      DelegateVotingPower.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DelegateVotingPower> {
      return TYPE.apply();
    }
  }

  export type DelegateVotingPowerInstance =
    TypedEventInstance<DelegateVotingPower> & {
      data_decoded: DelegateVotingPower;
      type_arguments: [];
    };

  export interface DelegateVotingPowerEvent {
    pool_address: MoveAddressType;
    delegator: MoveAddressType;
    voter: MoveAddressType;
  }

  export namespace DelegateVotingPowerEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::DelegateVotingPowerEvent";

    const TYPE = new TypeDescriptor<DelegateVotingPowerEvent>(
      DelegateVotingPowerEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DelegateVotingPowerEvent> {
      return TYPE.apply();
    }
  }

  export type DelegateVotingPowerEventInstance =
    TypedEventInstance<DelegateVotingPowerEvent> & {
      data_decoded: DelegateVotingPowerEvent;
      type_arguments: [];
    };

  export interface DelegatedVotes {
    active_shares: bigint;
    pending_inactive_shares: bigint;
    active_shares_next_lockup: bigint;
    last_locked_until_secs: bigint;
  }

  export namespace DelegatedVotes {
    export const TYPE_QNAME = "0x1::delegation_pool::DelegatedVotes";

    const TYPE = new TypeDescriptor<DelegatedVotes>(DelegatedVotes.TYPE_QNAME);

    export function type(): TypeDescriptor<DelegatedVotes> {
      return TYPE.apply();
    }
  }

  export interface DelegationPermission {}

  export namespace DelegationPermission {
    export const TYPE_QNAME = "0x1::delegation_pool::DelegationPermission";

    const TYPE = new TypeDescriptor<DelegationPermission>(
      DelegationPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DelegationPermission> {
      return TYPE.apply();
    }
  }

  export interface DelegationPool {
    active_shares: pool_u64_unbound.Pool;
    observed_lockup_cycle: delegation_pool.ObservedLockupCycle;
    inactive_shares: table.Table<
      delegation_pool.ObservedLockupCycle,
      pool_u64_unbound.Pool
    >;
    pending_withdrawals: table.Table<
      MoveAddressType,
      delegation_pool.ObservedLockupCycle
    >;
    stake_pool_signer_cap: account.SignerCapability;
    total_coins_inactive: bigint;
    operator_commission_percentage: bigint;
    add_stake_events: event.EventHandle<delegation_pool.AddStakeEvent>;
    reactivate_stake_events: event.EventHandle<delegation_pool.ReactivateStakeEvent>;
    unlock_stake_events: event.EventHandle<delegation_pool.UnlockStakeEvent>;
    withdraw_stake_events: event.EventHandle<delegation_pool.WithdrawStakeEvent>;
    distribute_commission_events: event.EventHandle<delegation_pool.DistributeCommissionEvent>;
  }

  export namespace DelegationPool {
    export const TYPE_QNAME = "0x1::delegation_pool::DelegationPool";

    const TYPE = new TypeDescriptor<DelegationPool>(DelegationPool.TYPE_QNAME);

    export function type(): TypeDescriptor<DelegationPool> {
      return TYPE.apply();
    }
  }

  export interface DelegationPoolAllowlisting {
    allowlist: smart_table.SmartTable<MoveAddressType, boolean>;
  }

  export namespace DelegationPoolAllowlisting {
    export const TYPE_QNAME =
      "0x1::delegation_pool::DelegationPoolAllowlisting";

    const TYPE = new TypeDescriptor<DelegationPoolAllowlisting>(
      DelegationPoolAllowlisting.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DelegationPoolAllowlisting> {
      return TYPE.apply();
    }
  }

  export interface DelegationPoolOwnership {
    pool_address: MoveAddressType;
  }

  export namespace DelegationPoolOwnership {
    export const TYPE_QNAME = "0x1::delegation_pool::DelegationPoolOwnership";

    const TYPE = new TypeDescriptor<DelegationPoolOwnership>(
      DelegationPoolOwnership.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DelegationPoolOwnership> {
      return TYPE.apply();
    }
  }

  export interface DisableDelegatorsAllowlisting {
    pool_address: MoveAddressType;
  }

  export namespace DisableDelegatorsAllowlisting {
    export const TYPE_QNAME =
      "0x1::delegation_pool::DisableDelegatorsAllowlisting";

    const TYPE = new TypeDescriptor<DisableDelegatorsAllowlisting>(
      DisableDelegatorsAllowlisting.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DisableDelegatorsAllowlisting> {
      return TYPE.apply();
    }
  }

  export type DisableDelegatorsAllowlistingInstance =
    TypedEventInstance<DisableDelegatorsAllowlisting> & {
      data_decoded: DisableDelegatorsAllowlisting;
      type_arguments: [];
    };

  export interface DistributeCommission {
    pool_address: MoveAddressType;
    operator: MoveAddressType;
    beneficiary: MoveAddressType;
    commission_active: bigint;
    commission_pending_inactive: bigint;
  }

  export namespace DistributeCommission {
    export const TYPE_QNAME = "0x1::delegation_pool::DistributeCommission";

    const TYPE = new TypeDescriptor<DistributeCommission>(
      DistributeCommission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DistributeCommission> {
      return TYPE.apply();
    }
  }

  export type DistributeCommissionInstance =
    TypedEventInstance<DistributeCommission> & {
      data_decoded: DistributeCommission;
      type_arguments: [];
    };

  export interface DistributeCommissionEvent {
    pool_address: MoveAddressType;
    operator: MoveAddressType;
    commission_active: bigint;
    commission_pending_inactive: bigint;
  }

  export namespace DistributeCommissionEvent {
    export const TYPE_QNAME = "0x1::delegation_pool::DistributeCommissionEvent";

    const TYPE = new TypeDescriptor<DistributeCommissionEvent>(
      DistributeCommissionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DistributeCommissionEvent> {
      return TYPE.apply();
    }
  }

  export type DistributeCommissionEventInstance =
    TypedEventInstance<DistributeCommissionEvent> & {
      data_decoded: DistributeCommissionEvent;
      type_arguments: [];
    };

  export interface EnableDelegatorsAllowlisting {
    pool_address: MoveAddressType;
  }

  export namespace EnableDelegatorsAllowlisting {
    export const TYPE_QNAME =
      "0x1::delegation_pool::EnableDelegatorsAllowlisting";

    const TYPE = new TypeDescriptor<EnableDelegatorsAllowlisting>(
      EnableDelegatorsAllowlisting.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<EnableDelegatorsAllowlisting> {
      return TYPE.apply();
    }
  }

  export type EnableDelegatorsAllowlistingInstance =
    TypedEventInstance<EnableDelegatorsAllowlisting> & {
      data_decoded: EnableDelegatorsAllowlisting;
      type_arguments: [];
    };

  export interface EvictDelegator {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
  }

  export namespace EvictDelegator {
    export const TYPE_QNAME = "0x1::delegation_pool::EvictDelegator";

    const TYPE = new TypeDescriptor<EvictDelegator>(EvictDelegator.TYPE_QNAME);

    export function type(): TypeDescriptor<EvictDelegator> {
      return TYPE.apply();
    }
  }

  export type EvictDelegatorInstance = TypedEventInstance<EvictDelegator> & {
    data_decoded: EvictDelegator;
    type_arguments: [];
  };

  export interface GovernanceRecords {
    votes: smart_table.SmartTable<delegation_pool.VotingRecordKey, bigint>;
    votes_per_proposal: smart_table.SmartTable<bigint, bigint>;
    vote_delegation: smart_table.SmartTable<
      MoveAddressType,
      delegation_pool.VoteDelegation
    >;
    delegated_votes: smart_table.SmartTable<
      MoveAddressType,
      delegation_pool.DelegatedVotes
    >;
    vote_events: event.EventHandle<delegation_pool.VoteEvent>;
    create_proposal_events: event.EventHandle<delegation_pool.CreateProposalEvent>;
    delegate_voting_power_events: event.EventHandle<delegation_pool.DelegateVotingPowerEvent>;
  }

  export namespace GovernanceRecords {
    export const TYPE_QNAME = "0x1::delegation_pool::GovernanceRecords";

    const TYPE = new TypeDescriptor<GovernanceRecords>(
      GovernanceRecords.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GovernanceRecords> {
      return TYPE.apply();
    }
  }

  export interface NextCommissionPercentage {
    commission_percentage_next_lockup_cycle: bigint;
    effective_after_secs: bigint;
  }

  export namespace NextCommissionPercentage {
    export const TYPE_QNAME = "0x1::delegation_pool::NextCommissionPercentage";

    const TYPE = new TypeDescriptor<NextCommissionPercentage>(
      NextCommissionPercentage.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<NextCommissionPercentage> {
      return TYPE.apply();
    }
  }

  export interface ObservedLockupCycle {
    index: bigint;
  }

  export namespace ObservedLockupCycle {
    export const TYPE_QNAME = "0x1::delegation_pool::ObservedLockupCycle";

    const TYPE = new TypeDescriptor<ObservedLockupCycle>(
      ObservedLockupCycle.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ObservedLockupCycle> {
      return TYPE.apply();
    }
  }

  export interface RemoveDelegatorFromAllowlist {
    pool_address: MoveAddressType;
    delegator_address: MoveAddressType;
  }

  export namespace RemoveDelegatorFromAllowlist {
    export const TYPE_QNAME =
      "0x1::delegation_pool::RemoveDelegatorFromAllowlist";

    const TYPE = new TypeDescriptor<RemoveDelegatorFromAllowlist>(
      RemoveDelegatorFromAllowlist.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RemoveDelegatorFromAllowlist> {
      return TYPE.apply();
    }
  }

  export type RemoveDelegatorFromAllowlistInstance =
    TypedEventInstance<RemoveDelegatorFromAllowlist> & {
      data_decoded: RemoveDelegatorFromAllowlist;
      type_arguments: [];
    };

  export interface SetBeneficiaryForOperator {
    operator: MoveAddressType;
    old_beneficiary: MoveAddressType;
    new_beneficiary: MoveAddressType;
  }

  export namespace SetBeneficiaryForOperator {
    export const TYPE_QNAME = "0x1::delegation_pool::SetBeneficiaryForOperator";

    const TYPE = new TypeDescriptor<SetBeneficiaryForOperator>(
      SetBeneficiaryForOperator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SetBeneficiaryForOperator> {
      return TYPE.apply();
    }
  }

  export type SetBeneficiaryForOperatorInstance =
    TypedEventInstance<SetBeneficiaryForOperator> & {
      data_decoded: SetBeneficiaryForOperator;
      type_arguments: [];
    };

  export interface VoteDelegation {
    voter: MoveAddressType;
    pending_voter: MoveAddressType;
    last_locked_until_secs: bigint;
  }

  export namespace VoteDelegation {
    export const TYPE_QNAME = "0x1::delegation_pool::VoteDelegation";

    const TYPE = new TypeDescriptor<VoteDelegation>(VoteDelegation.TYPE_QNAME);

    export function type(): TypeDescriptor<VoteDelegation> {
      return TYPE.apply();
    }
  }

  export interface VotingRecordKey {
    voter: MoveAddressType;
    proposal_id: bigint;
  }

  export namespace VotingRecordKey {
    export const TYPE_QNAME = "0x1::delegation_pool::VotingRecordKey";

    const TYPE = new TypeDescriptor<VotingRecordKey>(
      VotingRecordKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<VotingRecordKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function withdraw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::withdraw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createProposal(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string, string, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::create_proposal",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function vote(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint, bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::vote",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function addStake(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::add_stake",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function reactivateStake(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::reactivate_stake",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setDelegatedVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::set_delegated_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::set_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function unlock(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::unlock",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function allowlistDelegator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::allowlist_delegator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function delegateVotingPower(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::delegate_voting_power",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function disableDelegatorsAllowlisting(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::disable_delegators_allowlisting",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function enableDelegatorsAllowlisting(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::enable_delegators_allowlisting",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function enablePartialGovernanceVoting(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::enable_partial_governance_voting",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function evictDelegator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::evict_delegator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function initializeDelegationPool(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::initialize_delegation_pool",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function removeDelegatorFromAllowlist(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::remove_delegator_from_allowlist",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function setBeneficiaryForOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::set_beneficiary_for_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function synchronizeDelegationPool(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::synchronize_delegation_pool",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateCommissionPercentage(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::delegation_pool::update_commission_percentage",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function partialGovernanceVotingEnabled(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::partial_governance_voting_enabled",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::partial_governance_voting_enabled",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function getOwnedPoolAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::get_owned_pool_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::get_owned_pool_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getStake(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint, bigint, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::get_stake",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::get_stake",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function ownerCapExists(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::owner_cap_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::owner_cap_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function allowlistingEnabled(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::allowlisting_enabled",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::allowlisting_enabled",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function beneficiaryForOperator(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::beneficiary_for_operator",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::beneficiary_for_operator",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function calculateAndUpdateDelegatorVoter(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::calculate_and_update_delegator_voter",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::calculate_and_update_delegator_voter",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function calculateAndUpdateRemainingVotingPower(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::delegation_pool::calculate_and_update_remaining_voting_power",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::calculate_and_update_remaining_voting_power",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function calculateAndUpdateVoterTotalVotingPower(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::delegation_pool::calculate_and_update_voter_total_voting_power",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::calculate_and_update_voter_total_voting_power",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function calculateAndUpdateVotingDelegation(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType, MoveAddressType, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::delegation_pool::calculate_and_update_voting_delegation",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::calculate_and_update_voting_delegation",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function canWithdrawPendingInactive(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::can_withdraw_pending_inactive",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::can_withdraw_pending_inactive",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function delegationPoolExists(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::delegation_pool_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::delegation_pool_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function delegatorAllowlisted(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::delegator_allowlisted",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::delegator_allowlisted",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function getAddStakeFee(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::get_add_stake_fee",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::get_add_stake_fee",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getDelegationPoolStake(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint, bigint, bigint, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::get_delegation_pool_stake",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::get_delegation_pool_stake",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getDelegatorsAllowlist(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType[]]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::get_delegators_allowlist",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::get_delegators_allowlist",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getExpectedStakePoolAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, string];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::get_expected_stake_pool_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::get_expected_stake_pool_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getPendingWithdrawal(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::get_pending_withdrawal",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::get_pending_withdrawal",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function operatorCommissionPercentage(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::operator_commission_percentage",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::operator_commission_percentage",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isNextCommissionPercentageEffective(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::delegation_pool::is_next_commission_percentage_effective",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::is_next_commission_percentage_effective",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function minRemainingSecsForCommissionChange(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::delegation_pool::min_remaining_secs_for_commission_change",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::min_remaining_secs_for_commission_change",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function observedLockupCycle(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::observed_lockup_cycle",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::observed_lockup_cycle",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function operatorCommissionPercentageNextLockupCycle(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::delegation_pool::operator_commission_percentage_next_lockup_cycle",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::operator_commission_percentage_next_lockup_cycle",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function shareholdersCountActivePool(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::delegation_pool::shareholders_count_active_pool",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::delegation_pool::shareholders_count_active_pool",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface WithdrawPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface CreateProposalPayload
    extends TypedFunctionPayload<
      [MoveAddressType, string, string, string, boolean]
    > {
    arguments_decoded: [MoveAddressType, string, string, string, boolean];
    type_arguments: [];
  }

  export interface VotePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, boolean]> {
    arguments_decoded: [MoveAddressType, bigint, bigint, boolean];
    type_arguments: [];
  }

  export interface AddStakePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface ReactivateStakePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface SetDelegatedVoterPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface SetOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UnlockPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface AllowlistDelegatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface DelegateVotingPowerPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface DisableDelegatorsAllowlistingPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface EnableDelegatorsAllowlistingPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface EnablePartialGovernanceVotingPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface EvictDelegatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface InitializeDelegationPoolPayload
    extends TypedFunctionPayload<[bigint, string]> {
    arguments_decoded: [bigint, string];
    type_arguments: [];
  }

  export interface RemoveDelegatorFromAllowlistPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface SetBeneficiaryForOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface SynchronizeDelegationPoolPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UpdateCommissionPercentagePayload
    extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }
}

export class keyless_account extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("keyless_account", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): keyless_account {
    return new keyless_account({
      ...keyless_account.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryRegisterEkAndEncryptDk(
    func: (
      call: keyless_account.RegisterEkAndEncryptDkPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      keyless_account.RegisterEkAndEncryptDkPayload
    >,
  ): keyless_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "keyless_account::register_ek_and_encrypt_dk",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace keyless_account {
  export interface Configuration {
    override_aud_vals: string[];
    max_signatures_per_txn: number;
    max_exp_horizon_secs: bigint;
    training_wheels_pubkey: option.Option<string>;
    max_commited_epk_bytes: number;
    max_iss_val_bytes: number;
    max_extra_field_bytes: number;
    max_jwt_header_b64_bytes: number;
  }

  export namespace Configuration {
    export const TYPE_QNAME = "0x1::keyless_account::Configuration";

    const TYPE = new TypeDescriptor<Configuration>(Configuration.TYPE_QNAME);

    export function type(): TypeDescriptor<Configuration> {
      return TYPE.apply();
    }
  }

  export interface Group {
    dummy_field: boolean;
  }

  export namespace Group {
    export const TYPE_QNAME = "0x1::keyless_account::Group";

    const TYPE = new TypeDescriptor<Group>(Group.TYPE_QNAME);

    export function type(): TypeDescriptor<Group> {
      return TYPE.apply();
    }
  }

  export interface Groth16VerificationKey {
    alpha_g1: string;
    beta_g2: string;
    gamma_g2: string;
    delta_g2: string;
    gamma_abc_g1: string[];
  }

  export namespace Groth16VerificationKey {
    export const TYPE_QNAME = "0x1::keyless_account::Groth16VerificationKey";

    const TYPE = new TypeDescriptor<Groth16VerificationKey>(
      Groth16VerificationKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<Groth16VerificationKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function registerEkAndEncryptDk(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          string,
          string,
          object$.Object<fungible_asset.Metadata>,
          string,
          string[],
          string[],
          string,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::keyless_account::register_ek_and_encrypt_dk",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface RegisterEkAndEncryptDkPayload
    extends TypedFunctionPayload<
      [
        string,
        string,
        object$.Object<fungible_asset.Metadata>,
        string,
        string[],
        string[],
        string,
      ]
    > {
    arguments_decoded: [
      string,
      string,
      object$.Object<fungible_asset.Metadata>,
      string,
      string[],
      string[],
      string,
    ];
    type_arguments: [];
  }
}

export class reconfiguration extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("reconfiguration", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): reconfiguration {
    return new reconfiguration({
      ...reconfiguration.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEventNewEpoch(
    func: (event: reconfiguration.NewEpochInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      reconfiguration.NewEpochInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): reconfiguration {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "reconfiguration::NewEpoch" },
      handlerOptions,
    );
    return this;
  }

  onEventNewEpochEvent(
    func: (
      event: reconfiguration.NewEpochEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      reconfiguration.NewEpochEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): reconfiguration {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "reconfiguration::NewEpochEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace reconfiguration {
  export interface Configuration {
    epoch: bigint;
    last_reconfiguration_time: bigint;
    events: event.EventHandle<reconfiguration.NewEpochEvent>;
  }

  export namespace Configuration {
    export const TYPE_QNAME = "0x1::reconfiguration::Configuration";

    const TYPE = new TypeDescriptor<Configuration>(Configuration.TYPE_QNAME);

    export function type(): TypeDescriptor<Configuration> {
      return TYPE.apply();
    }
  }

  export interface DisableReconfiguration {
    dummy_field: boolean;
  }

  export namespace DisableReconfiguration {
    export const TYPE_QNAME = "0x1::reconfiguration::DisableReconfiguration";

    const TYPE = new TypeDescriptor<DisableReconfiguration>(
      DisableReconfiguration.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DisableReconfiguration> {
      return TYPE.apply();
    }
  }

  export interface NewEpoch {
    epoch: bigint;
  }

  export namespace NewEpoch {
    export const TYPE_QNAME = "0x1::reconfiguration::NewEpoch";

    const TYPE = new TypeDescriptor<NewEpoch>(NewEpoch.TYPE_QNAME);

    export function type(): TypeDescriptor<NewEpoch> {
      return TYPE.apply();
    }
  }

  export type NewEpochInstance = TypedEventInstance<NewEpoch> & {
    data_decoded: NewEpoch;
    type_arguments: [];
  };

  export interface NewEpochEvent {
    epoch: bigint;
  }

  export namespace NewEpochEvent {
    export const TYPE_QNAME = "0x1::reconfiguration::NewEpochEvent";

    const TYPE = new TypeDescriptor<NewEpochEvent>(NewEpochEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<NewEpochEvent> {
      return TYPE.apply();
    }
  }

  export type NewEpochEventInstance = TypedEventInstance<NewEpochEvent> & {
    data_decoded: NewEpochEvent;
    type_arguments: [];
  };

  export namespace entry {}
  export namespace view {}
}

export class transaction_fee extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("transaction_fee", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): transaction_fee {
    return new transaction_fee({
      ...transaction_fee.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryConvertToAptosFaBurnRef(
    func: (
      call: transaction_fee.ConvertToAptosFaBurnRefPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      transaction_fee.ConvertToAptosFaBurnRefPayload
    >,
  ): transaction_fee {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "transaction_fee::convert_to_aptos_fa_burn_ref",
      },
      handlerOptions,
    );
    return this;
  }

  onEventFeeStatement(
    func: (
      event: transaction_fee.FeeStatementInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      transaction_fee.FeeStatementInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): transaction_fee {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "transaction_fee::FeeStatement" },
      handlerOptions,
    );
    return this;
  }
}

export namespace transaction_fee {
  export interface AptosCoinCapabilities {
    burn_cap: coin.BurnCapability<aptos_coin.AptosCoin>;
  }

  export namespace AptosCoinCapabilities {
    export const TYPE_QNAME = "0x1::transaction_fee::AptosCoinCapabilities";

    const TYPE = new TypeDescriptor<AptosCoinCapabilities>(
      AptosCoinCapabilities.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AptosCoinCapabilities> {
      return TYPE.apply();
    }
  }

  export interface AptosCoinMintCapability {
    mint_cap: coin.MintCapability<aptos_coin.AptosCoin>;
  }

  export namespace AptosCoinMintCapability {
    export const TYPE_QNAME = "0x1::transaction_fee::AptosCoinMintCapability";

    const TYPE = new TypeDescriptor<AptosCoinMintCapability>(
      AptosCoinMintCapability.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AptosCoinMintCapability> {
      return TYPE.apply();
    }
  }

  export interface AptosFABurnCapabilities {
    burn_ref: fungible_asset.BurnRef;
  }

  export namespace AptosFABurnCapabilities {
    export const TYPE_QNAME = "0x1::transaction_fee::AptosFABurnCapabilities";

    const TYPE = new TypeDescriptor<AptosFABurnCapabilities>(
      AptosFABurnCapabilities.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AptosFABurnCapabilities> {
      return TYPE.apply();
    }
  }

  export interface CollectedFeesPerBlock {
    amount: coin.AggregatableCoin<aptos_coin.AptosCoin>;
    proposer: option.Option<MoveAddressType>;
    burn_percentage: number;
  }

  export namespace CollectedFeesPerBlock {
    export const TYPE_QNAME = "0x1::transaction_fee::CollectedFeesPerBlock";

    const TYPE = new TypeDescriptor<CollectedFeesPerBlock>(
      CollectedFeesPerBlock.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CollectedFeesPerBlock> {
      return TYPE.apply();
    }
  }

  export interface FeeStatement {
    total_charge_gas_units: bigint;
    execution_gas_units: bigint;
    io_gas_units: bigint;
    storage_fee_octas: bigint;
    storage_fee_refund_octas: bigint;
  }

  export namespace FeeStatement {
    export const TYPE_QNAME = "0x1::transaction_fee::FeeStatement";

    const TYPE = new TypeDescriptor<FeeStatement>(FeeStatement.TYPE_QNAME);

    export function type(): TypeDescriptor<FeeStatement> {
      return TYPE.apply();
    }
  }

  export type FeeStatementInstance = TypedEventInstance<FeeStatement> & {
    data_decoded: FeeStatement;
    type_arguments: [];
  };

  export namespace entry {
    export async function convertToAptosFaBurnRef(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::transaction_fee::convert_to_aptos_fa_burn_ref",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface ConvertToAptosFaBurnRefPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }
}

export class aptos_governance extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("aptos_governance", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): aptos_governance {
    return new aptos_governance({
      ...aptos_governance.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryCreateProposal(
    func: (
      call: aptos_governance.CreateProposalPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.CreateProposalPayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::create_proposal",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateProposalV2(
    func: (
      call: aptos_governance.CreateProposalV2Payload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.CreateProposalV2Payload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::create_proposal_v2",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryVote(
    func: (call: aptos_governance.VotePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.VotePayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::vote",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryReconfigure(
    func: (
      call: aptos_governance.ReconfigurePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.ReconfigurePayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::reconfigure",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddApprovedScriptHashScript(
    func: (
      call: aptos_governance.AddApprovedScriptHashScriptPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.AddApprovedScriptHashScriptPayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::add_approved_script_hash_script",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryBatchPartialVote(
    func: (
      call: aptos_governance.BatchPartialVotePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.BatchPartialVotePayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::batch_partial_vote",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryBatchVote(
    func: (call: aptos_governance.BatchVotePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.BatchVotePayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::batch_vote",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryForceEndEpoch(
    func: (
      call: aptos_governance.ForceEndEpochPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.ForceEndEpochPayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::force_end_epoch",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryForceEndEpochTestOnly(
    func: (
      call: aptos_governance.ForceEndEpochTestOnlyPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.ForceEndEpochTestOnlyPayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::force_end_epoch_test_only",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryPartialVote(
    func: (
      call: aptos_governance.PartialVotePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.PartialVotePayload
    >,
  ): aptos_governance {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "aptos_governance::partial_vote",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCreateProposal(
    func: (
      event: aptos_governance.CreateProposalInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.CreateProposalInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_governance {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aptos_governance::CreateProposal" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateProposalEvent(
    func: (
      event: aptos_governance.CreateProposalEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.CreateProposalEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_governance {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aptos_governance::CreateProposalEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventVote(
    func: (event: aptos_governance.VoteInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.VoteInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_governance {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aptos_governance::Vote" },
      handlerOptions,
    );
    return this;
  }

  onEventVoteEvent(
    func: (
      event: aptos_governance.VoteEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.VoteEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_governance {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aptos_governance::VoteEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateConfig(
    func: (
      event: aptos_governance.UpdateConfigInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.UpdateConfigInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_governance {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aptos_governance::UpdateConfig" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateConfigEvent(
    func: (
      event: aptos_governance.UpdateConfigEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      aptos_governance.UpdateConfigEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): aptos_governance {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "aptos_governance::UpdateConfigEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace aptos_governance {
  export interface CreateProposal {
    proposer: MoveAddressType;
    stake_pool: MoveAddressType;
    proposal_id: bigint;
    execution_hash: string;
    proposal_metadata: simple_map.SimpleMap<string, string>;
  }

  export namespace CreateProposal {
    export const TYPE_QNAME = "0x1::aptos_governance::CreateProposal";

    const TYPE = new TypeDescriptor<CreateProposal>(CreateProposal.TYPE_QNAME);

    export function type(): TypeDescriptor<CreateProposal> {
      return TYPE.apply();
    }
  }

  export type CreateProposalInstance = TypedEventInstance<CreateProposal> & {
    data_decoded: CreateProposal;
    type_arguments: [];
  };

  export interface CreateProposalEvent {
    proposer: MoveAddressType;
    stake_pool: MoveAddressType;
    proposal_id: bigint;
    execution_hash: string;
    proposal_metadata: simple_map.SimpleMap<string, string>;
  }

  export namespace CreateProposalEvent {
    export const TYPE_QNAME = "0x1::aptos_governance::CreateProposalEvent";

    const TYPE = new TypeDescriptor<CreateProposalEvent>(
      CreateProposalEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateProposalEvent> {
      return TYPE.apply();
    }
  }

  export type CreateProposalEventInstance =
    TypedEventInstance<CreateProposalEvent> & {
      data_decoded: CreateProposalEvent;
      type_arguments: [];
    };

  export interface Vote {
    proposal_id: bigint;
    voter: MoveAddressType;
    stake_pool: MoveAddressType;
    num_votes: bigint;
    should_pass: boolean;
  }

  export namespace Vote {
    export const TYPE_QNAME = "0x1::aptos_governance::Vote";

    const TYPE = new TypeDescriptor<Vote>(Vote.TYPE_QNAME);

    export function type(): TypeDescriptor<Vote> {
      return TYPE.apply();
    }
  }

  export type VoteInstance = TypedEventInstance<Vote> & {
    data_decoded: Vote;
    type_arguments: [];
  };

  export interface VoteEvent {
    proposal_id: bigint;
    voter: MoveAddressType;
    stake_pool: MoveAddressType;
    num_votes: bigint;
    should_pass: boolean;
  }

  export namespace VoteEvent {
    export const TYPE_QNAME = "0x1::aptos_governance::VoteEvent";

    const TYPE = new TypeDescriptor<VoteEvent>(VoteEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<VoteEvent> {
      return TYPE.apply();
    }
  }

  export type VoteEventInstance = TypedEventInstance<VoteEvent> & {
    data_decoded: VoteEvent;
    type_arguments: [];
  };

  export interface ApprovedExecutionHashes {
    hashes: simple_map.SimpleMap<bigint, string>;
  }

  export namespace ApprovedExecutionHashes {
    export const TYPE_QNAME = "0x1::aptos_governance::ApprovedExecutionHashes";

    const TYPE = new TypeDescriptor<ApprovedExecutionHashes>(
      ApprovedExecutionHashes.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ApprovedExecutionHashes> {
      return TYPE.apply();
    }
  }

  export interface GovernanceConfig {
    min_voting_threshold: bigint;
    required_proposer_stake: bigint;
    voting_duration_secs: bigint;
  }

  export namespace GovernanceConfig {
    export const TYPE_QNAME = "0x1::aptos_governance::GovernanceConfig";

    const TYPE = new TypeDescriptor<GovernanceConfig>(
      GovernanceConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GovernanceConfig> {
      return TYPE.apply();
    }
  }

  export interface GovernanceEvents {
    create_proposal_events: event.EventHandle<aptos_governance.CreateProposalEvent>;
    update_config_events: event.EventHandle<aptos_governance.UpdateConfigEvent>;
    vote_events: event.EventHandle<aptos_governance.VoteEvent>;
  }

  export namespace GovernanceEvents {
    export const TYPE_QNAME = "0x1::aptos_governance::GovernanceEvents";

    const TYPE = new TypeDescriptor<GovernanceEvents>(
      GovernanceEvents.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GovernanceEvents> {
      return TYPE.apply();
    }
  }

  export interface GovernancePermission {
    dummy_field: boolean;
  }

  export namespace GovernancePermission {
    export const TYPE_QNAME = "0x1::aptos_governance::GovernancePermission";

    const TYPE = new TypeDescriptor<GovernancePermission>(
      GovernancePermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GovernancePermission> {
      return TYPE.apply();
    }
  }

  export interface GovernanceResponsbility {
    signer_caps: simple_map.SimpleMap<
      MoveAddressType,
      account.SignerCapability
    >;
  }

  export namespace GovernanceResponsbility {
    export const TYPE_QNAME = "0x1::aptos_governance::GovernanceResponsbility";

    const TYPE = new TypeDescriptor<GovernanceResponsbility>(
      GovernanceResponsbility.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GovernanceResponsbility> {
      return TYPE.apply();
    }
  }

  export interface RecordKey {
    stake_pool: MoveAddressType;
    proposal_id: bigint;
  }

  export namespace RecordKey {
    export const TYPE_QNAME = "0x1::aptos_governance::RecordKey";

    const TYPE = new TypeDescriptor<RecordKey>(RecordKey.TYPE_QNAME);

    export function type(): TypeDescriptor<RecordKey> {
      return TYPE.apply();
    }
  }

  export interface UpdateConfig {
    min_voting_threshold: bigint;
    required_proposer_stake: bigint;
    voting_duration_secs: bigint;
  }

  export namespace UpdateConfig {
    export const TYPE_QNAME = "0x1::aptos_governance::UpdateConfig";

    const TYPE = new TypeDescriptor<UpdateConfig>(UpdateConfig.TYPE_QNAME);

    export function type(): TypeDescriptor<UpdateConfig> {
      return TYPE.apply();
    }
  }

  export type UpdateConfigInstance = TypedEventInstance<UpdateConfig> & {
    data_decoded: UpdateConfig;
    type_arguments: [];
  };

  export interface UpdateConfigEvent {
    min_voting_threshold: bigint;
    required_proposer_stake: bigint;
    voting_duration_secs: bigint;
  }

  export namespace UpdateConfigEvent {
    export const TYPE_QNAME = "0x1::aptos_governance::UpdateConfigEvent";

    const TYPE = new TypeDescriptor<UpdateConfigEvent>(
      UpdateConfigEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateConfigEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateConfigEventInstance =
    TypedEventInstance<UpdateConfigEvent> & {
      data_decoded: UpdateConfigEvent;
      type_arguments: [];
    };

  export interface VotingRecords {
    votes: table.Table<aptos_governance.RecordKey, boolean>;
  }

  export namespace VotingRecords {
    export const TYPE_QNAME = "0x1::aptos_governance::VotingRecords";

    const TYPE = new TypeDescriptor<VotingRecords>(VotingRecords.TYPE_QNAME);

    export function type(): TypeDescriptor<VotingRecords> {
      return TYPE.apply();
    }
  }

  export interface VotingRecordsV2 {
    votes: smart_table.SmartTable<aptos_governance.RecordKey, bigint>;
  }

  export namespace VotingRecordsV2 {
    export const TYPE_QNAME = "0x1::aptos_governance::VotingRecordsV2";

    const TYPE = new TypeDescriptor<VotingRecordsV2>(
      VotingRecordsV2.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<VotingRecordsV2> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function createProposal(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::create_proposal",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createProposalV2(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string, string, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::create_proposal_v2",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function vote(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::vote",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function reconfigure(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::reconfigure",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function addApprovedScriptHashScript(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::add_approved_script_hash_script",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function batchPartialVote(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint, bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::batch_partial_vote",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function batchVote(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::batch_vote",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function forceEndEpoch(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::force_end_epoch",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function forceEndEpochTestOnly(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::force_end_epoch_test_only",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function partialVote(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint, bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::aptos_governance::partial_vote",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function getVotingPower(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::aptos_governance::get_voting_power",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::aptos_governance::get_voting_power",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function getMinVotingThreshold(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::aptos_governance::get_min_voting_threshold",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::aptos_governance::get_min_voting_threshold",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getRemainingVotingPower(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::aptos_governance::get_remaining_voting_power",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::aptos_governance::get_remaining_voting_power",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getRequiredProposerStake(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::aptos_governance::get_required_proposer_stake",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::aptos_governance::get_required_proposer_stake",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function getVotingDurationSecs(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::aptos_governance::get_voting_duration_secs",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::aptos_governance::get_voting_duration_secs",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function hasEntirelyVoted(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::aptos_governance::has_entirely_voted",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::aptos_governance::has_entirely_voted",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface CreateProposalPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string, string]> {
    arguments_decoded: [MoveAddressType, string, string, string];
    type_arguments: [];
  }

  export interface CreateProposalV2Payload
    extends TypedFunctionPayload<
      [MoveAddressType, string, string, string, boolean]
    > {
    arguments_decoded: [MoveAddressType, string, string, string, boolean];
    type_arguments: [];
  }

  export interface VotePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint, boolean]> {
    arguments_decoded: [MoveAddressType, bigint, boolean];
    type_arguments: [];
  }

  export interface ReconfigurePayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface AddApprovedScriptHashScriptPayload
    extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface BatchPartialVotePayload
    extends TypedFunctionPayload<[MoveAddressType[], bigint, bigint, boolean]> {
    arguments_decoded: [MoveAddressType[], bigint, bigint, boolean];
    type_arguments: [];
  }

  export interface BatchVotePayload
    extends TypedFunctionPayload<[MoveAddressType[], bigint, boolean]> {
    arguments_decoded: [MoveAddressType[], bigint, boolean];
    type_arguments: [];
  }

  export interface ForceEndEpochPayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface ForceEndEpochTestOnlyPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface PartialVotePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, boolean]> {
    arguments_decoded: [MoveAddressType, bigint, bigint, boolean];
    type_arguments: [];
  }
}

export namespace bls12381_algebra {
  export interface FormatFq12LscLsb {
    dummy_field: boolean;
  }

  export namespace FormatFq12LscLsb {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatFq12LscLsb";

    const TYPE = new TypeDescriptor<FormatFq12LscLsb>(
      FormatFq12LscLsb.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FormatFq12LscLsb> {
      return TYPE.apply();
    }
  }

  export interface FormatFrLsb {
    dummy_field: boolean;
  }

  export namespace FormatFrLsb {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrLsb";

    const TYPE = new TypeDescriptor<FormatFrLsb>(FormatFrLsb.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatFrLsb> {
      return TYPE.apply();
    }
  }

  export interface FormatFrMsb {
    dummy_field: boolean;
  }

  export namespace FormatFrMsb {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatFrMsb";

    const TYPE = new TypeDescriptor<FormatFrMsb>(FormatFrMsb.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatFrMsb> {
      return TYPE.apply();
    }
  }

  export interface FormatG1Compr {
    dummy_field: boolean;
  }

  export namespace FormatG1Compr {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Compr";

    const TYPE = new TypeDescriptor<FormatG1Compr>(FormatG1Compr.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatG1Compr> {
      return TYPE.apply();
    }
  }

  export interface FormatG1Uncompr {
    dummy_field: boolean;
  }

  export namespace FormatG1Uncompr {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatG1Uncompr";

    const TYPE = new TypeDescriptor<FormatG1Uncompr>(
      FormatG1Uncompr.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FormatG1Uncompr> {
      return TYPE.apply();
    }
  }

  export interface FormatG2Compr {
    dummy_field: boolean;
  }

  export namespace FormatG2Compr {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Compr";

    const TYPE = new TypeDescriptor<FormatG2Compr>(FormatG2Compr.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatG2Compr> {
      return TYPE.apply();
    }
  }

  export interface FormatG2Uncompr {
    dummy_field: boolean;
  }

  export namespace FormatG2Uncompr {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatG2Uncompr";

    const TYPE = new TypeDescriptor<FormatG2Uncompr>(
      FormatG2Uncompr.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FormatG2Uncompr> {
      return TYPE.apply();
    }
  }

  export interface FormatGt {
    dummy_field: boolean;
  }

  export namespace FormatGt {
    export const TYPE_QNAME = "0x1::bls12381_algebra::FormatGt";

    const TYPE = new TypeDescriptor<FormatGt>(FormatGt.TYPE_QNAME);

    export function type(): TypeDescriptor<FormatGt> {
      return TYPE.apply();
    }
  }

  export interface Fq12 {
    dummy_field: boolean;
  }

  export namespace Fq12 {
    export const TYPE_QNAME = "0x1::bls12381_algebra::Fq12";

    const TYPE = new TypeDescriptor<Fq12>(Fq12.TYPE_QNAME);

    export function type(): TypeDescriptor<Fq12> {
      return TYPE.apply();
    }
  }

  export interface Fr {
    dummy_field: boolean;
  }

  export namespace Fr {
    export const TYPE_QNAME = "0x1::bls12381_algebra::Fr";

    const TYPE = new TypeDescriptor<Fr>(Fr.TYPE_QNAME);

    export function type(): TypeDescriptor<Fr> {
      return TYPE.apply();
    }
  }

  export interface G1 {
    dummy_field: boolean;
  }

  export namespace G1 {
    export const TYPE_QNAME = "0x1::bls12381_algebra::G1";

    const TYPE = new TypeDescriptor<G1>(G1.TYPE_QNAME);

    export function type(): TypeDescriptor<G1> {
      return TYPE.apply();
    }
  }

  export interface G2 {
    dummy_field: boolean;
  }

  export namespace G2 {
    export const TYPE_QNAME = "0x1::bls12381_algebra::G2";

    const TYPE = new TypeDescriptor<G2>(G2.TYPE_QNAME);

    export function type(): TypeDescriptor<G2> {
      return TYPE.apply();
    }
  }

  export interface Gt {
    dummy_field: boolean;
  }

  export namespace Gt {
    export const TYPE_QNAME = "0x1::bls12381_algebra::Gt";

    const TYPE = new TypeDescriptor<Gt>(Gt.TYPE_QNAME);

    export function type(): TypeDescriptor<Gt> {
      return TYPE.apply();
    }
  }

  export interface HashG1XmdSha256SswuRo {
    dummy_field: boolean;
  }

  export namespace HashG1XmdSha256SswuRo {
    export const TYPE_QNAME = "0x1::bls12381_algebra::HashG1XmdSha256SswuRo";

    const TYPE = new TypeDescriptor<HashG1XmdSha256SswuRo>(
      HashG1XmdSha256SswuRo.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<HashG1XmdSha256SswuRo> {
      return TYPE.apply();
    }
  }

  export interface HashG2XmdSha256SswuRo {
    dummy_field: boolean;
  }

  export namespace HashG2XmdSha256SswuRo {
    export const TYPE_QNAME = "0x1::bls12381_algebra::HashG2XmdSha256SswuRo";

    const TYPE = new TypeDescriptor<HashG2XmdSha256SswuRo>(
      HashG2XmdSha256SswuRo.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<HashG2XmdSha256SswuRo> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace consensus_config {
  export interface ConsensusConfig {
    config: string;
  }

  export namespace ConsensusConfig {
    export const TYPE_QNAME = "0x1::consensus_config::ConsensusConfig";

    const TYPE = new TypeDescriptor<ConsensusConfig>(
      ConsensusConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ConsensusConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace execution_config {
  export interface ExecutionConfig {
    config: string;
  }

  export namespace ExecutionConfig {
    export const TYPE_QNAME = "0x1::execution_config::ExecutionConfig";

    const TYPE = new TypeDescriptor<ExecutionConfig>(
      ExecutionConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ExecutionConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class multisig_account extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("multisig_account", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): multisig_account {
    return new multisig_account({
      ...multisig_account.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryCreate(
    func: (call: multisig_account.CreatePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreatePayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::create",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddOwner(
    func: (call: multisig_account.AddOwnerPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.AddOwnerPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::add_owner",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddOwners(
    func: (call: multisig_account.AddOwnersPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.AddOwnersPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::add_owners",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddOwnersAndUpdateSignaturesRequired(
    func: (
      call: multisig_account.AddOwnersAndUpdateSignaturesRequiredPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.AddOwnersAndUpdateSignaturesRequiredPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::add_owners_and_update_signatures_required",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryApproveTransaction(
    func: (
      call: multisig_account.ApproveTransactionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.ApproveTransactionPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::approve_transaction",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateTransaction(
    func: (
      call: multisig_account.CreateTransactionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateTransactionPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::create_transaction",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateTransactionWithHash(
    func: (
      call: multisig_account.CreateTransactionWithHashPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateTransactionWithHashPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::create_transaction_with_hash",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateWithExistingAccount(
    func: (
      call: multisig_account.CreateWithExistingAccountPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateWithExistingAccountPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::create_with_existing_account",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateWithExistingAccountAndRevokeAuthKey(
    func: (
      call: multisig_account.CreateWithExistingAccountAndRevokeAuthKeyPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateWithExistingAccountAndRevokeAuthKeyPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "multisig_account::create_with_existing_account_and_revoke_auth_key",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateWithExistingAccountAndRevokeAuthKeyCall(
    func: (
      call: multisig_account.CreateWithExistingAccountAndRevokeAuthKeyCallPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateWithExistingAccountAndRevokeAuthKeyCallPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "multisig_account::create_with_existing_account_and_revoke_auth_key_call",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateWithExistingAccountCall(
    func: (
      call: multisig_account.CreateWithExistingAccountCallPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateWithExistingAccountCallPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::create_with_existing_account_call",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateWithOwners(
    func: (
      call: multisig_account.CreateWithOwnersPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateWithOwnersPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::create_with_owners",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateWithOwnersAndTimelock(
    func: (
      call: multisig_account.CreateWithOwnersAndTimelockPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateWithOwnersAndTimelockPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::create_with_owners_and_timelock",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateWithOwnersThenRemoveBootstrapper(
    func: (
      call: multisig_account.CreateWithOwnersThenRemoveBootstrapperPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateWithOwnersThenRemoveBootstrapperPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "multisig_account::create_with_owners_then_remove_bootstrapper",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryExecuteRejectedTransaction(
    func: (
      call: multisig_account.ExecuteRejectedTransactionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.ExecuteRejectedTransactionPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::execute_rejected_transaction",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryExecuteRejectedTransactions(
    func: (
      call: multisig_account.ExecuteRejectedTransactionsPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.ExecuteRejectedTransactionsPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::execute_rejected_transactions",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRejectTransaction(
    func: (
      call: multisig_account.RejectTransactionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.RejectTransactionPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::reject_transaction",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveOwner(
    func: (
      call: multisig_account.RemoveOwnerPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.RemoveOwnerPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::remove_owner",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveOwners(
    func: (
      call: multisig_account.RemoveOwnersPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.RemoveOwnersPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::remove_owners",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveTimelock(
    func: (
      call: multisig_account.RemoveTimelockPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.RemoveTimelockPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::remove_timelock",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySwapOwner(
    func: (call: multisig_account.SwapOwnerPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.SwapOwnerPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::swap_owner",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySwapOwners(
    func: (call: multisig_account.SwapOwnersPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.SwapOwnersPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::swap_owners",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySwapOwnersAndUpdateSignaturesRequired(
    func: (
      call: multisig_account.SwapOwnersAndUpdateSignaturesRequiredPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.SwapOwnersAndUpdateSignaturesRequiredPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "multisig_account::swap_owners_and_update_signatures_required",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateMetadata(
    func: (
      call: multisig_account.UpdateMetadataPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.UpdateMetadataPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::update_metadata",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateSignaturesRequired(
    func: (
      call: multisig_account.UpdateSignaturesRequiredPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.UpdateSignaturesRequiredPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::update_signatures_required",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpsertTimelock(
    func: (
      call: multisig_account.UpsertTimelockPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.UpsertTimelockPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::upsert_timelock",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryVoteTransaction(
    func: (
      call: multisig_account.VoteTransactionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.VoteTransactionPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::vote_transaction",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryVoteTransactions(
    func: (
      call: multisig_account.VoteTransactionsPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.VoteTransactionsPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::vote_transactions",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryVoteTransanction(
    func: (
      call: multisig_account.VoteTransanctionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.VoteTransanctionPayload
    >,
  ): multisig_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "multisig_account::vote_transanction",
      },
      handlerOptions,
    );
    return this;
  }

  onEventVote(
    func: (event: multisig_account.VoteInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.VoteInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::Vote" },
      handlerOptions,
    );
    return this;
  }

  onEventVoteEvent(
    func: (
      event: multisig_account.VoteEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.VoteEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::VoteEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventAddOwners(
    func: (
      event: multisig_account.AddOwnersInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.AddOwnersInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::AddOwners" },
      handlerOptions,
    );
    return this;
  }

  onEventAddOwnersEvent(
    func: (
      event: multisig_account.AddOwnersEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.AddOwnersEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::AddOwnersEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateTransaction(
    func: (
      event: multisig_account.CreateTransactionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateTransactionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::CreateTransaction" },
      handlerOptions,
    );
    return this;
  }

  onEventCreateTransactionEvent(
    func: (
      event: multisig_account.CreateTransactionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.CreateTransactionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::CreateTransactionEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventExecuteRejectedTransaction(
    func: (
      event: multisig_account.ExecuteRejectedTransactionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.ExecuteRejectedTransactionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::ExecuteRejectedTransaction",
      },
      handlerOptions,
    );
    return this;
  }

  onEventExecuteRejectedTransactionEvent(
    func: (
      event: multisig_account.ExecuteRejectedTransactionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.ExecuteRejectedTransactionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::ExecuteRejectedTransactionEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventMetadataUpdated(
    func: (
      event: multisig_account.MetadataUpdatedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.MetadataUpdatedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::MetadataUpdated" },
      handlerOptions,
    );
    return this;
  }

  onEventMetadataUpdatedEvent(
    func: (
      event: multisig_account.MetadataUpdatedEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.MetadataUpdatedEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::MetadataUpdatedEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventRemoveOwners(
    func: (
      event: multisig_account.RemoveOwnersInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.RemoveOwnersInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::RemoveOwners" },
      handlerOptions,
    );
    return this;
  }

  onEventRemoveOwnersEvent(
    func: (
      event: multisig_account.RemoveOwnersEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.RemoveOwnersEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::RemoveOwnersEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventTimelockRemoved(
    func: (
      event: multisig_account.TimelockRemovedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.TimelockRemovedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::TimelockRemoved" },
      handlerOptions,
    );
    return this;
  }

  onEventTimelockUpdated(
    func: (
      event: multisig_account.TimelockUpdatedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.TimelockUpdatedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "multisig_account::TimelockUpdated" },
      handlerOptions,
    );
    return this;
  }

  onEventTransactionExecutionFailed(
    func: (
      event: multisig_account.TransactionExecutionFailedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.TransactionExecutionFailedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::TransactionExecutionFailed",
      },
      handlerOptions,
    );
    return this;
  }

  onEventTransactionExecutionFailedEvent(
    func: (
      event: multisig_account.TransactionExecutionFailedEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.TransactionExecutionFailedEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::TransactionExecutionFailedEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventTransactionExecutionSucceeded(
    func: (
      event: multisig_account.TransactionExecutionSucceededInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.TransactionExecutionSucceededInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::TransactionExecutionSucceeded",
      },
      handlerOptions,
    );
    return this;
  }

  onEventTransactionExecutionSucceededEvent(
    func: (
      event: multisig_account.TransactionExecutionSucceededEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.TransactionExecutionSucceededEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::TransactionExecutionSucceededEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateSignaturesRequired(
    func: (
      event: multisig_account.UpdateSignaturesRequiredInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.UpdateSignaturesRequiredInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::UpdateSignaturesRequired",
      },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateSignaturesRequiredEvent(
    func: (
      event: multisig_account.UpdateSignaturesRequiredEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      multisig_account.UpdateSignaturesRequiredEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): multisig_account {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "multisig_account::UpdateSignaturesRequiredEvent",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace multisig_account {
  export interface Vote {
    multisig_account: MoveAddressType;
    owner: MoveAddressType;
    sequence_number: bigint;
    approved: boolean;
  }

  export namespace Vote {
    export const TYPE_QNAME = "0x1::multisig_account::Vote";

    const TYPE = new TypeDescriptor<Vote>(Vote.TYPE_QNAME);

    export function type(): TypeDescriptor<Vote> {
      return TYPE.apply();
    }
  }

  export type VoteInstance = TypedEventInstance<Vote> & {
    data_decoded: Vote;
    type_arguments: [];
  };

  export interface VoteEvent {
    owner: MoveAddressType;
    sequence_number: bigint;
    approved: boolean;
  }

  export namespace VoteEvent {
    export const TYPE_QNAME = "0x1::multisig_account::VoteEvent";

    const TYPE = new TypeDescriptor<VoteEvent>(VoteEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<VoteEvent> {
      return TYPE.apply();
    }
  }

  export type VoteEventInstance = TypedEventInstance<VoteEvent> & {
    data_decoded: VoteEvent;
    type_arguments: [];
  };

  export interface AddOwners {
    multisig_account: MoveAddressType;
    owners_added: MoveAddressType[];
  }

  export namespace AddOwners {
    export const TYPE_QNAME = "0x1::multisig_account::AddOwners";

    const TYPE = new TypeDescriptor<AddOwners>(AddOwners.TYPE_QNAME);

    export function type(): TypeDescriptor<AddOwners> {
      return TYPE.apply();
    }
  }

  export type AddOwnersInstance = TypedEventInstance<AddOwners> & {
    data_decoded: AddOwners;
    type_arguments: [];
  };

  export interface AddOwnersEvent {
    owners_added: MoveAddressType[];
  }

  export namespace AddOwnersEvent {
    export const TYPE_QNAME = "0x1::multisig_account::AddOwnersEvent";

    const TYPE = new TypeDescriptor<AddOwnersEvent>(AddOwnersEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<AddOwnersEvent> {
      return TYPE.apply();
    }
  }

  export type AddOwnersEventInstance = TypedEventInstance<AddOwnersEvent> & {
    data_decoded: AddOwnersEvent;
    type_arguments: [];
  };

  export interface CreateTransaction {
    multisig_account: MoveAddressType;
    creator: MoveAddressType;
    sequence_number: bigint;
    transaction: multisig_account.MultisigTransaction;
  }

  export namespace CreateTransaction {
    export const TYPE_QNAME = "0x1::multisig_account::CreateTransaction";

    const TYPE = new TypeDescriptor<CreateTransaction>(
      CreateTransaction.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateTransaction> {
      return TYPE.apply();
    }
  }

  export type CreateTransactionInstance =
    TypedEventInstance<CreateTransaction> & {
      data_decoded: CreateTransaction;
      type_arguments: [];
    };

  export interface CreateTransactionEvent {
    creator: MoveAddressType;
    sequence_number: bigint;
    transaction: multisig_account.MultisigTransaction;
  }

  export namespace CreateTransactionEvent {
    export const TYPE_QNAME = "0x1::multisig_account::CreateTransactionEvent";

    const TYPE = new TypeDescriptor<CreateTransactionEvent>(
      CreateTransactionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateTransactionEvent> {
      return TYPE.apply();
    }
  }

  export type CreateTransactionEventInstance =
    TypedEventInstance<CreateTransactionEvent> & {
      data_decoded: CreateTransactionEvent;
      type_arguments: [];
    };

  export interface ExecuteRejectedTransaction {
    multisig_account: MoveAddressType;
    sequence_number: bigint;
    num_rejections: bigint;
    executor: MoveAddressType;
  }

  export namespace ExecuteRejectedTransaction {
    export const TYPE_QNAME =
      "0x1::multisig_account::ExecuteRejectedTransaction";

    const TYPE = new TypeDescriptor<ExecuteRejectedTransaction>(
      ExecuteRejectedTransaction.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ExecuteRejectedTransaction> {
      return TYPE.apply();
    }
  }

  export type ExecuteRejectedTransactionInstance =
    TypedEventInstance<ExecuteRejectedTransaction> & {
      data_decoded: ExecuteRejectedTransaction;
      type_arguments: [];
    };

  export interface ExecuteRejectedTransactionEvent {
    sequence_number: bigint;
    num_rejections: bigint;
    executor: MoveAddressType;
  }

  export namespace ExecuteRejectedTransactionEvent {
    export const TYPE_QNAME =
      "0x1::multisig_account::ExecuteRejectedTransactionEvent";

    const TYPE = new TypeDescriptor<ExecuteRejectedTransactionEvent>(
      ExecuteRejectedTransactionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ExecuteRejectedTransactionEvent> {
      return TYPE.apply();
    }
  }

  export type ExecuteRejectedTransactionEventInstance =
    TypedEventInstance<ExecuteRejectedTransactionEvent> & {
      data_decoded: ExecuteRejectedTransactionEvent;
      type_arguments: [];
    };

  export interface ExecutionError {
    abort_location: string;
    error_type: string;
    error_code: bigint;
  }

  export namespace ExecutionError {
    export const TYPE_QNAME = "0x1::multisig_account::ExecutionError";

    const TYPE = new TypeDescriptor<ExecutionError>(ExecutionError.TYPE_QNAME);

    export function type(): TypeDescriptor<ExecutionError> {
      return TYPE.apply();
    }
  }

  export interface MetadataUpdated {
    multisig_account: MoveAddressType;
    old_metadata: simple_map.SimpleMap<string, string>;
    new_metadata: simple_map.SimpleMap<string, string>;
  }

  export namespace MetadataUpdated {
    export const TYPE_QNAME = "0x1::multisig_account::MetadataUpdated";

    const TYPE = new TypeDescriptor<MetadataUpdated>(
      MetadataUpdated.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MetadataUpdated> {
      return TYPE.apply();
    }
  }

  export type MetadataUpdatedInstance = TypedEventInstance<MetadataUpdated> & {
    data_decoded: MetadataUpdated;
    type_arguments: [];
  };

  export interface MetadataUpdatedEvent {
    old_metadata: simple_map.SimpleMap<string, string>;
    new_metadata: simple_map.SimpleMap<string, string>;
  }

  export namespace MetadataUpdatedEvent {
    export const TYPE_QNAME = "0x1::multisig_account::MetadataUpdatedEvent";

    const TYPE = new TypeDescriptor<MetadataUpdatedEvent>(
      MetadataUpdatedEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MetadataUpdatedEvent> {
      return TYPE.apply();
    }
  }

  export type MetadataUpdatedEventInstance =
    TypedEventInstance<MetadataUpdatedEvent> & {
      data_decoded: MetadataUpdatedEvent;
      type_arguments: [];
    };

  export interface MultisigAccount {
    owners: MoveAddressType[];
    num_signatures_required: bigint;
    transactions: table.Table<bigint, multisig_account.MultisigTransaction>;
    last_executed_sequence_number: bigint;
    next_sequence_number: bigint;
    signer_cap: option.Option<account.SignerCapability>;
    metadata: simple_map.SimpleMap<string, string>;
    add_owners_events: event.EventHandle<multisig_account.AddOwnersEvent>;
    remove_owners_events: event.EventHandle<multisig_account.RemoveOwnersEvent>;
    update_signature_required_events: event.EventHandle<multisig_account.UpdateSignaturesRequiredEvent>;
    create_transaction_events: event.EventHandle<multisig_account.CreateTransactionEvent>;
    vote_events: event.EventHandle<multisig_account.VoteEvent>;
    execute_rejected_transaction_events: event.EventHandle<multisig_account.ExecuteRejectedTransactionEvent>;
    execute_transaction_events: event.EventHandle<multisig_account.TransactionExecutionSucceededEvent>;
    transaction_execution_failed_events: event.EventHandle<multisig_account.TransactionExecutionFailedEvent>;
    metadata_updated_events: event.EventHandle<multisig_account.MetadataUpdatedEvent>;
  }

  export namespace MultisigAccount {
    export const TYPE_QNAME = "0x1::multisig_account::MultisigAccount";

    const TYPE = new TypeDescriptor<MultisigAccount>(
      MultisigAccount.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MultisigAccount> {
      return TYPE.apply();
    }
  }

  export interface MultisigAccountCreationMessage {
    chain_id: number;
    account_address: MoveAddressType;
    sequence_number: bigint;
    owners: MoveAddressType[];
    num_signatures_required: bigint;
  }

  export namespace MultisigAccountCreationMessage {
    export const TYPE_QNAME =
      "0x1::multisig_account::MultisigAccountCreationMessage";

    const TYPE = new TypeDescriptor<MultisigAccountCreationMessage>(
      MultisigAccountCreationMessage.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MultisigAccountCreationMessage> {
      return TYPE.apply();
    }
  }

  export interface MultisigAccountCreationWithAuthKeyRevocationMessage {
    chain_id: number;
    account_address: MoveAddressType;
    sequence_number: bigint;
    owners: MoveAddressType[];
    num_signatures_required: bigint;
  }

  export namespace MultisigAccountCreationWithAuthKeyRevocationMessage {
    export const TYPE_QNAME =
      "0x1::multisig_account::MultisigAccountCreationWithAuthKeyRevocationMessage";

    const TYPE =
      new TypeDescriptor<MultisigAccountCreationWithAuthKeyRevocationMessage>(
        MultisigAccountCreationWithAuthKeyRevocationMessage.TYPE_QNAME,
      );

    export function type(): TypeDescriptor<MultisigAccountCreationWithAuthKeyRevocationMessage> {
      return TYPE.apply();
    }
  }

  export interface MultisigAccountTimeLock {}

  export namespace MultisigAccountTimeLock {
    export const TYPE_QNAME = "0x1::multisig_account::MultisigAccountTimeLock";

    const TYPE = new TypeDescriptor<MultisigAccountTimeLock>(
      MultisigAccountTimeLock.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MultisigAccountTimeLock> {
      return TYPE.apply();
    }
  }

  export interface MultisigTransaction {
    payload: option.Option<string>;
    payload_hash: option.Option<string>;
    votes: simple_map.SimpleMap<MoveAddressType, boolean>;
    creator: MoveAddressType;
    creation_time_secs: bigint;
  }

  export namespace MultisigTransaction {
    export const TYPE_QNAME = "0x1::multisig_account::MultisigTransaction";

    const TYPE = new TypeDescriptor<MultisigTransaction>(
      MultisigTransaction.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MultisigTransaction> {
      return TYPE.apply();
    }
  }

  export interface RemoveOwners {
    multisig_account: MoveAddressType;
    owners_removed: MoveAddressType[];
  }

  export namespace RemoveOwners {
    export const TYPE_QNAME = "0x1::multisig_account::RemoveOwners";

    const TYPE = new TypeDescriptor<RemoveOwners>(RemoveOwners.TYPE_QNAME);

    export function type(): TypeDescriptor<RemoveOwners> {
      return TYPE.apply();
    }
  }

  export type RemoveOwnersInstance = TypedEventInstance<RemoveOwners> & {
    data_decoded: RemoveOwners;
    type_arguments: [];
  };

  export interface RemoveOwnersEvent {
    owners_removed: MoveAddressType[];
  }

  export namespace RemoveOwnersEvent {
    export const TYPE_QNAME = "0x1::multisig_account::RemoveOwnersEvent";

    const TYPE = new TypeDescriptor<RemoveOwnersEvent>(
      RemoveOwnersEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RemoveOwnersEvent> {
      return TYPE.apply();
    }
  }

  export type RemoveOwnersEventInstance =
    TypedEventInstance<RemoveOwnersEvent> & {
      data_decoded: RemoveOwnersEvent;
      type_arguments: [];
    };

  export interface TimelockRemoved {
    multisig_account: MoveAddressType;
  }

  export namespace TimelockRemoved {
    export const TYPE_QNAME = "0x1::multisig_account::TimelockRemoved";

    const TYPE = new TypeDescriptor<TimelockRemoved>(
      TimelockRemoved.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TimelockRemoved> {
      return TYPE.apply();
    }
  }

  export type TimelockRemovedInstance = TypedEventInstance<TimelockRemoved> & {
    data_decoded: TimelockRemoved;
    type_arguments: [];
  };

  export interface TimelockUpdated {
    multisig_account: MoveAddressType;
    timelock_period: bigint;
    override_threshold: option.Option<bigint>;
  }

  export namespace TimelockUpdated {
    export const TYPE_QNAME = "0x1::multisig_account::TimelockUpdated";

    const TYPE = new TypeDescriptor<TimelockUpdated>(
      TimelockUpdated.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TimelockUpdated> {
      return TYPE.apply();
    }
  }

  export type TimelockUpdatedInstance = TypedEventInstance<TimelockUpdated> & {
    data_decoded: TimelockUpdated;
    type_arguments: [];
  };

  export interface TransactionExecutionFailed {
    multisig_account: MoveAddressType;
    executor: MoveAddressType;
    sequence_number: bigint;
    transaction_payload: string;
    num_approvals: bigint;
    execution_error: multisig_account.ExecutionError;
  }

  export namespace TransactionExecutionFailed {
    export const TYPE_QNAME =
      "0x1::multisig_account::TransactionExecutionFailed";

    const TYPE = new TypeDescriptor<TransactionExecutionFailed>(
      TransactionExecutionFailed.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransactionExecutionFailed> {
      return TYPE.apply();
    }
  }

  export type TransactionExecutionFailedInstance =
    TypedEventInstance<TransactionExecutionFailed> & {
      data_decoded: TransactionExecutionFailed;
      type_arguments: [];
    };

  export interface TransactionExecutionFailedEvent {
    executor: MoveAddressType;
    sequence_number: bigint;
    transaction_payload: string;
    num_approvals: bigint;
    execution_error: multisig_account.ExecutionError;
  }

  export namespace TransactionExecutionFailedEvent {
    export const TYPE_QNAME =
      "0x1::multisig_account::TransactionExecutionFailedEvent";

    const TYPE = new TypeDescriptor<TransactionExecutionFailedEvent>(
      TransactionExecutionFailedEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransactionExecutionFailedEvent> {
      return TYPE.apply();
    }
  }

  export type TransactionExecutionFailedEventInstance =
    TypedEventInstance<TransactionExecutionFailedEvent> & {
      data_decoded: TransactionExecutionFailedEvent;
      type_arguments: [];
    };

  export interface TransactionExecutionSucceeded {
    multisig_account: MoveAddressType;
    executor: MoveAddressType;
    sequence_number: bigint;
    transaction_payload: string;
    num_approvals: bigint;
  }

  export namespace TransactionExecutionSucceeded {
    export const TYPE_QNAME =
      "0x1::multisig_account::TransactionExecutionSucceeded";

    const TYPE = new TypeDescriptor<TransactionExecutionSucceeded>(
      TransactionExecutionSucceeded.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransactionExecutionSucceeded> {
      return TYPE.apply();
    }
  }

  export type TransactionExecutionSucceededInstance =
    TypedEventInstance<TransactionExecutionSucceeded> & {
      data_decoded: TransactionExecutionSucceeded;
      type_arguments: [];
    };

  export interface TransactionExecutionSucceededEvent {
    executor: MoveAddressType;
    sequence_number: bigint;
    transaction_payload: string;
    num_approvals: bigint;
  }

  export namespace TransactionExecutionSucceededEvent {
    export const TYPE_QNAME =
      "0x1::multisig_account::TransactionExecutionSucceededEvent";

    const TYPE = new TypeDescriptor<TransactionExecutionSucceededEvent>(
      TransactionExecutionSucceededEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransactionExecutionSucceededEvent> {
      return TYPE.apply();
    }
  }

  export type TransactionExecutionSucceededEventInstance =
    TypedEventInstance<TransactionExecutionSucceededEvent> & {
      data_decoded: TransactionExecutionSucceededEvent;
      type_arguments: [];
    };

  export interface UpdateSignaturesRequired {
    multisig_account: MoveAddressType;
    old_num_signatures_required: bigint;
    new_num_signatures_required: bigint;
  }

  export namespace UpdateSignaturesRequired {
    export const TYPE_QNAME = "0x1::multisig_account::UpdateSignaturesRequired";

    const TYPE = new TypeDescriptor<UpdateSignaturesRequired>(
      UpdateSignaturesRequired.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateSignaturesRequired> {
      return TYPE.apply();
    }
  }

  export type UpdateSignaturesRequiredInstance =
    TypedEventInstance<UpdateSignaturesRequired> & {
      data_decoded: UpdateSignaturesRequired;
      type_arguments: [];
    };

  export interface UpdateSignaturesRequiredEvent {
    old_num_signatures_required: bigint;
    new_num_signatures_required: bigint;
  }

  export namespace UpdateSignaturesRequiredEvent {
    export const TYPE_QNAME =
      "0x1::multisig_account::UpdateSignaturesRequiredEvent";

    const TYPE = new TypeDescriptor<UpdateSignaturesRequiredEvent>(
      UpdateSignaturesRequiredEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateSignaturesRequiredEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateSignaturesRequiredEventInstance =
    TypedEventInstance<UpdateSignaturesRequiredEvent> & {
      data_decoded: UpdateSignaturesRequiredEvent;
      type_arguments: [];
    };

  export namespace entry {
    export async function create(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint, string[], string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::create",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function addOwner(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::add_owner",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function addOwners(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::add_owners",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function addOwnersAndUpdateSignaturesRequired(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::multisig_account::add_owners_and_update_signatures_required",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function approveTransaction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::approve_transaction",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function createTransaction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::create_transaction",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createTransactionWithHash(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::create_transaction_with_hash",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createWithExistingAccount(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType[],
          bigint,
          number,
          string,
          string,
          string[],
          string[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::create_with_existing_account",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function createWithExistingAccountAndRevokeAuthKey(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType[],
          bigint,
          number,
          string,
          string,
          string[],
          string[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::multisig_account::create_with_existing_account_and_revoke_auth_key",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createWithExistingAccountAndRevokeAuthKeyCall(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint, string[], string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::multisig_account::create_with_existing_account_and_revoke_auth_key_call",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createWithExistingAccountCall(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint, string[], string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::create_with_existing_account_call",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createWithOwners(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint, string[], string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::create_with_owners",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createWithOwnersAndTimelock(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType[],
          bigint,
          string[],
          string[],
          option.Option<bigint>,
          option.Option<bigint>,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::create_with_owners_and_timelock",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function createWithOwnersThenRemoveBootstrapper(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], bigint, string[], string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::multisig_account::create_with_owners_then_remove_bootstrapper",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function executeRejectedTransaction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::execute_rejected_transaction",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function executeRejectedTransactions(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::execute_rejected_transactions",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function rejectTransaction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::reject_transaction",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function removeOwner(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::remove_owner",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function removeOwners(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::remove_owners",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function removeTimelock(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::remove_timelock",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function swapOwner(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::swap_owner",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function swapOwners(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], MoveAddressType[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::swap_owners",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function swapOwnersAndUpdateSignaturesRequired(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType[], MoveAddressType[], bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::multisig_account::swap_owners_and_update_signatures_required",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function updateMetadata(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string[], string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::update_metadata",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateSignaturesRequired(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::update_signatures_required",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function upsertTimelock(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint, option.Option<bigint>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::upsert_timelock",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function voteTransaction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::vote_transaction",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function voteTransactions(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint, bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::vote_transactions",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function voteTransanction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::multisig_account::vote_transanction",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function isOwner(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::is_owner",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::is_owner",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function metadata(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[simple_map.SimpleMap<string, string>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::metadata",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::metadata",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function vote(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, bigint, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean, boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::vote",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::multisig_account::vote");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function availableTransactionQueueCapacity(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::available_transaction_queue_capacity",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::available_transaction_queue_capacity",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function canBeExecuted(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::can_be_executed",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::can_be_executed",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function canBeRejected(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::can_be_rejected",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::can_be_rejected",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function canExecute(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::can_execute",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::can_execute",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function canReject(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::can_reject",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::can_reject",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function numSignaturesRequired(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::num_signatures_required",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::num_signatures_required",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function owners(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType[]]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::owners",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction("0x1::multisig_account::owners");
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function timelockPeriod(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::timelock_period",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::timelock_period",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function getNextMultisigAccountAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::get_next_multisig_account_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::get_next_multisig_account_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getNextTransactionPayload(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, string];
      },
      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::get_next_transaction_payload",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::get_next_transaction_payload",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getPendingTransactions(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[multisig_account.MultisigTransaction[]]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::get_pending_transactions",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::get_pending_transactions",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getTransaction(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, bigint];
      },
      version?: bigint,
    ): Promise<[multisig_account.MultisigTransaction]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::get_transaction",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::get_transaction",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function lastResolvedSequenceNumber(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::last_resolved_sequence_number",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::last_resolved_sequence_number",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function nextSequenceNumber(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::next_sequence_number",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::next_sequence_number",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function timelockOverrideThreshold(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[option.Option<bigint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::multisig_account::timelock_override_threshold",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::multisig_account::timelock_override_threshold",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface CreatePayload
    extends TypedFunctionPayload<[bigint, string[], string[]]> {
    arguments_decoded: [bigint, string[], string[]];
    type_arguments: [];
  }

  export interface AddOwnerPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface AddOwnersPayload
    extends TypedFunctionPayload<[MoveAddressType[]]> {
    arguments_decoded: [MoveAddressType[]];
    type_arguments: [];
  }

  export interface AddOwnersAndUpdateSignaturesRequiredPayload
    extends TypedFunctionPayload<[MoveAddressType[], bigint]> {
    arguments_decoded: [MoveAddressType[], bigint];
    type_arguments: [];
  }

  export interface ApproveTransactionPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface CreateTransactionPayload
    extends TypedFunctionPayload<[MoveAddressType, string]> {
    arguments_decoded: [MoveAddressType, string];
    type_arguments: [];
  }

  export interface CreateTransactionWithHashPayload
    extends TypedFunctionPayload<[MoveAddressType, string]> {
    arguments_decoded: [MoveAddressType, string];
    type_arguments: [];
  }

  export interface CreateWithExistingAccountPayload
    extends TypedFunctionPayload<
      [
        MoveAddressType,
        MoveAddressType[],
        bigint,
        number,
        string,
        string,
        string[],
        string[],
      ]
    > {
    arguments_decoded: [
      MoveAddressType,
      MoveAddressType[],
      bigint,
      number,
      string,
      string,
      string[],
      string[],
    ];
    type_arguments: [];
  }

  export interface CreateWithExistingAccountAndRevokeAuthKeyPayload
    extends TypedFunctionPayload<
      [
        MoveAddressType,
        MoveAddressType[],
        bigint,
        number,
        string,
        string,
        string[],
        string[],
      ]
    > {
    arguments_decoded: [
      MoveAddressType,
      MoveAddressType[],
      bigint,
      number,
      string,
      string,
      string[],
      string[],
    ];
    type_arguments: [];
  }

  export interface CreateWithExistingAccountAndRevokeAuthKeyCallPayload
    extends TypedFunctionPayload<
      [MoveAddressType[], bigint, string[], string[]]
    > {
    arguments_decoded: [MoveAddressType[], bigint, string[], string[]];
    type_arguments: [];
  }

  export interface CreateWithExistingAccountCallPayload
    extends TypedFunctionPayload<
      [MoveAddressType[], bigint, string[], string[]]
    > {
    arguments_decoded: [MoveAddressType[], bigint, string[], string[]];
    type_arguments: [];
  }

  export interface CreateWithOwnersPayload
    extends TypedFunctionPayload<
      [MoveAddressType[], bigint, string[], string[]]
    > {
    arguments_decoded: [MoveAddressType[], bigint, string[], string[]];
    type_arguments: [];
  }

  export interface CreateWithOwnersAndTimelockPayload
    extends TypedFunctionPayload<
      [
        MoveAddressType[],
        bigint,
        string[],
        string[],
        option.Option<bigint>,
        option.Option<bigint>,
      ]
    > {
    arguments_decoded: [
      MoveAddressType[],
      bigint,
      string[],
      string[],
      option.Option<bigint>,
      option.Option<bigint>,
    ];
    type_arguments: [];
  }

  export interface CreateWithOwnersThenRemoveBootstrapperPayload
    extends TypedFunctionPayload<
      [MoveAddressType[], bigint, string[], string[]]
    > {
    arguments_decoded: [MoveAddressType[], bigint, string[], string[]];
    type_arguments: [];
  }

  export interface ExecuteRejectedTransactionPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface ExecuteRejectedTransactionsPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface RejectTransactionPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface RemoveOwnerPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface RemoveOwnersPayload
    extends TypedFunctionPayload<[MoveAddressType[]]> {
    arguments_decoded: [MoveAddressType[]];
    type_arguments: [];
  }

  export interface RemoveTimelockPayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface SwapOwnerPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface SwapOwnersPayload
    extends TypedFunctionPayload<[MoveAddressType[], MoveAddressType[]]> {
    arguments_decoded: [MoveAddressType[], MoveAddressType[]];
    type_arguments: [];
  }

  export interface SwapOwnersAndUpdateSignaturesRequiredPayload
    extends TypedFunctionPayload<
      [MoveAddressType[], MoveAddressType[], bigint]
    > {
    arguments_decoded: [MoveAddressType[], MoveAddressType[], bigint];
    type_arguments: [];
  }

  export interface UpdateMetadataPayload
    extends TypedFunctionPayload<[string[], string[]]> {
    arguments_decoded: [string[], string[]];
    type_arguments: [];
  }

  export interface UpdateSignaturesRequiredPayload
    extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface UpsertTimelockPayload
    extends TypedFunctionPayload<[bigint, option.Option<bigint>]> {
    arguments_decoded: [bigint, option.Option<bigint>];
    type_arguments: [];
  }

  export interface VoteTransactionPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint, boolean]> {
    arguments_decoded: [MoveAddressType, bigint, boolean];
    type_arguments: [];
  }

  export interface VoteTransactionsPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint, bigint, boolean]> {
    arguments_decoded: [MoveAddressType, bigint, bigint, boolean];
    type_arguments: [];
  }

  export interface VoteTransanctionPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint, boolean]> {
    arguments_decoded: [MoveAddressType, bigint, boolean];
    type_arguments: [];
  }
}

export class nonce_validation extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("nonce_validation", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): nonce_validation {
    return new nonce_validation({
      ...nonce_validation.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryAddNonceBuckets(
    func: (
      call: nonce_validation.AddNonceBucketsPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      nonce_validation.AddNonceBucketsPayload
    >,
  ): nonce_validation {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "nonce_validation::add_nonce_buckets",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryInitializeNonceTable(
    func: (
      call: nonce_validation.InitializeNonceTablePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      nonce_validation.InitializeNonceTablePayload
    >,
  ): nonce_validation {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "nonce_validation::initialize_nonce_table",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace nonce_validation {
  export interface Bucket {
    nonces_ordered_by_exp_time: big_ordered_map.BigOrderedMap<
      nonce_validation.NonceKeyWithExpTime,
      boolean
    >;
    nonce_to_exp_time_map: big_ordered_map.BigOrderedMap<
      nonce_validation.NonceKey,
      bigint
    >;
  }

  export namespace Bucket {
    export const TYPE_QNAME = "0x1::nonce_validation::Bucket";

    const TYPE = new TypeDescriptor<Bucket>(Bucket.TYPE_QNAME);

    export function type(): TypeDescriptor<Bucket> {
      return TYPE.apply();
    }
  }

  export interface NonceHistory {
    nonce_table: table.Table<bigint, nonce_validation.Bucket>;
    next_key: bigint;
  }

  export namespace NonceHistory {
    export const TYPE_QNAME = "0x1::nonce_validation::NonceHistory";

    const TYPE = new TypeDescriptor<NonceHistory>(NonceHistory.TYPE_QNAME);

    export function type(): TypeDescriptor<NonceHistory> {
      return TYPE.apply();
    }
  }

  export interface NonceKey {
    sender_address: MoveAddressType;
    nonce: bigint;
  }

  export namespace NonceKey {
    export const TYPE_QNAME = "0x1::nonce_validation::NonceKey";

    const TYPE = new TypeDescriptor<NonceKey>(NonceKey.TYPE_QNAME);

    export function type(): TypeDescriptor<NonceKey> {
      return TYPE.apply();
    }
  }

  export interface NonceKeyWithExpTime {
    txn_expiration_time: bigint;
    sender_address: MoveAddressType;
    nonce: bigint;
  }

  export namespace NonceKeyWithExpTime {
    export const TYPE_QNAME = "0x1::nonce_validation::NonceKeyWithExpTime";

    const TYPE = new TypeDescriptor<NonceKeyWithExpTime>(
      NonceKeyWithExpTime.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<NonceKeyWithExpTime> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function addNonceBuckets(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::nonce_validation::add_nonce_buckets",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function initializeNonceTable(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::nonce_validation::initialize_nonce_table",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface AddNonceBucketsPayload
    extends TypedFunctionPayload<[bigint]> {
    arguments_decoded: [bigint];
    type_arguments: [];
  }

  export interface InitializeNonceTablePayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }
}

export namespace pool_u64_unbound {
  export interface Pool {
    total_coins: bigint;
    total_shares: bigint;
    shares: table_with_length.TableWithLength<MoveAddressType, bigint>;
    scaling_factor: bigint;
  }

  export namespace Pool {
    export const TYPE_QNAME = "0x1::pool_u64_unbound::Pool";

    const TYPE = new TypeDescriptor<Pool>(Pool.TYPE_QNAME);

    export function type(): TypeDescriptor<Pool> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class resource_account extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("resource_account", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): resource_account {
    return new resource_account({
      ...resource_account.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryCreateResourceAccount(
    func: (
      call: resource_account.CreateResourceAccountPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      resource_account.CreateResourceAccountPayload
    >,
  ): resource_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "resource_account::create_resource_account",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateResourceAccountAndFund(
    func: (
      call: resource_account.CreateResourceAccountAndFundPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      resource_account.CreateResourceAccountAndFundPayload
    >,
  ): resource_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "resource_account::create_resource_account_and_fund",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateResourceAccountAndPublishPackage(
    func: (
      call: resource_account.CreateResourceAccountAndPublishPackagePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      resource_account.CreateResourceAccountAndPublishPackagePayload
    >,
  ): resource_account {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "resource_account::create_resource_account_and_publish_package",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace resource_account {
  export interface Container {
    store: simple_map.SimpleMap<MoveAddressType, account.SignerCapability>;
  }

  export namespace Container {
    export const TYPE_QNAME = "0x1::resource_account::Container";

    const TYPE = new TypeDescriptor<Container>(Container.TYPE_QNAME);

    export function type(): TypeDescriptor<Container> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function createResourceAccount(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::resource_account::create_resource_account",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createResourceAccountAndFund(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::resource_account::create_resource_account_and_fund",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function createResourceAccountAndPublishPackage(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string, string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::resource_account::create_resource_account_and_publish_package",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface CreateResourceAccountPayload
    extends TypedFunctionPayload<[string, string]> {
    arguments_decoded: [string, string];
    type_arguments: [];
  }

  export interface CreateResourceAccountAndFundPayload
    extends TypedFunctionPayload<[string, string, bigint]> {
    arguments_decoded: [string, string, bigint];
    type_arguments: [];
  }

  export interface CreateResourceAccountAndPublishPackagePayload
    extends TypedFunctionPayload<[string, string, string[]]> {
    arguments_decoded: [string, string, string[]];
    type_arguments: [];
  }
}

export class staking_contract extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("staking_contract", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): staking_contract {
    return new staking_contract({
      ...staking_contract.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryAddStake(
    func: (call: staking_contract.AddStakePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.AddStakePayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::add_stake",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetBeneficiaryForOperator(
    func: (
      call: staking_contract.SetBeneficiaryForOperatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.SetBeneficiaryForOperatorPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::set_beneficiary_for_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryCreateStakingContract(
    func: (
      call: staking_contract.CreateStakingContractPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.CreateStakingContractPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::create_staking_contract",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryDistribute(
    func: (call: staking_contract.DistributePayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.DistributePayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::distribute",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRequestCommission(
    func: (
      call: staking_contract.RequestCommissionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.RequestCommissionPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::request_commission",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryResetLockup(
    func: (
      call: staking_contract.ResetLockupPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.ResetLockupPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::reset_lockup",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySwitchOperator(
    func: (
      call: staking_contract.SwitchOperatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.SwitchOperatorPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::switch_operator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySwitchOperatorWithSameCommission(
    func: (
      call: staking_contract.SwitchOperatorWithSameCommissionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.SwitchOperatorWithSameCommissionPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::switch_operator_with_same_commission",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnlockRewards(
    func: (
      call: staking_contract.UnlockRewardsPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UnlockRewardsPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::unlock_rewards",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUnlockStake(
    func: (
      call: staking_contract.UnlockStakePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UnlockStakePayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::unlock_stake",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateCommision(
    func: (
      call: staking_contract.UpdateCommisionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UpdateCommisionPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::update_commision",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpdateVoter(
    func: (
      call: staking_contract.UpdateVoterPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UpdateVoterPayload
    >,
  ): staking_contract {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "staking_contract::update_voter",
      },
      handlerOptions,
    );
    return this;
  }

  onEventAddStake(
    func: (event: staking_contract.AddStakeInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.AddStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::AddStake" },
      handlerOptions,
    );
    return this;
  }

  onEventAddStakeEvent(
    func: (
      event: staking_contract.AddStakeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.AddStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::AddStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockStake(
    func: (
      event: staking_contract.UnlockStakeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UnlockStakeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::UnlockStake" },
      handlerOptions,
    );
    return this;
  }

  onEventUnlockStakeEvent(
    func: (
      event: staking_contract.UnlockStakeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UnlockStakeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::UnlockStakeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventSetBeneficiaryForOperator(
    func: (
      event: staking_contract.SetBeneficiaryForOperatorInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.SetBeneficiaryForOperatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "staking_contract::SetBeneficiaryForOperator",
      },
      handlerOptions,
    );
    return this;
  }

  onEventAddDistribution(
    func: (
      event: staking_contract.AddDistributionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.AddDistributionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::AddDistribution" },
      handlerOptions,
    );
    return this;
  }

  onEventAddDistributionEvent(
    func: (
      event: staking_contract.AddDistributionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.AddDistributionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "staking_contract::AddDistributionEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCreateStakingContract(
    func: (
      event: staking_contract.CreateStakingContractInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.CreateStakingContractInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "staking_contract::CreateStakingContract",
      },
      handlerOptions,
    );
    return this;
  }

  onEventCreateStakingContractEvent(
    func: (
      event: staking_contract.CreateStakingContractEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.CreateStakingContractEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "staking_contract::CreateStakingContractEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDistribute(
    func: (
      event: staking_contract.DistributeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.DistributeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::Distribute" },
      handlerOptions,
    );
    return this;
  }

  onEventDistributeEvent(
    func: (
      event: staking_contract.DistributeEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.DistributeEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::DistributeEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventRequestCommission(
    func: (
      event: staking_contract.RequestCommissionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.RequestCommissionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::RequestCommission" },
      handlerOptions,
    );
    return this;
  }

  onEventRequestCommissionEvent(
    func: (
      event: staking_contract.RequestCommissionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.RequestCommissionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "staking_contract::RequestCommissionEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventResetLockup(
    func: (
      event: staking_contract.ResetLockupInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.ResetLockupInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::ResetLockup" },
      handlerOptions,
    );
    return this;
  }

  onEventResetLockupEvent(
    func: (
      event: staking_contract.ResetLockupEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.ResetLockupEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::ResetLockupEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventStakingGroupUpdateCommissionEvent(
    func: (
      event: staking_contract.StakingGroupUpdateCommissionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.StakingGroupUpdateCommissionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "staking_contract::StakingGroupUpdateCommissionEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventSwitchOperator(
    func: (
      event: staking_contract.SwitchOperatorInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.SwitchOperatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::SwitchOperator" },
      handlerOptions,
    );
    return this;
  }

  onEventSwitchOperatorEvent(
    func: (
      event: staking_contract.SwitchOperatorEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.SwitchOperatorEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::SwitchOperatorEvent" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateCommission(
    func: (
      event: staking_contract.UpdateCommissionInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UpdateCommissionInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::UpdateCommission" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateCommissionEvent(
    func: (
      event: staking_contract.UpdateCommissionEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UpdateCommissionEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "staking_contract::UpdateCommissionEvent",
      },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateVoter(
    func: (
      event: staking_contract.UpdateVoterInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UpdateVoterInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::UpdateVoter" },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateVoterEvent(
    func: (
      event: staking_contract.UpdateVoterEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      staking_contract.UpdateVoterEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): staking_contract {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "staking_contract::UpdateVoterEvent" },
      handlerOptions,
    );
    return this;
  }
}

export namespace staking_contract {
  export interface AddStake {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace AddStake {
    export const TYPE_QNAME = "0x1::staking_contract::AddStake";

    const TYPE = new TypeDescriptor<AddStake>(AddStake.TYPE_QNAME);

    export function type(): TypeDescriptor<AddStake> {
      return TYPE.apply();
    }
  }

  export type AddStakeInstance = TypedEventInstance<AddStake> & {
    data_decoded: AddStake;
    type_arguments: [];
  };

  export interface AddStakeEvent {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace AddStakeEvent {
    export const TYPE_QNAME = "0x1::staking_contract::AddStakeEvent";

    const TYPE = new TypeDescriptor<AddStakeEvent>(AddStakeEvent.TYPE_QNAME);

    export function type(): TypeDescriptor<AddStakeEvent> {
      return TYPE.apply();
    }
  }

  export type AddStakeEventInstance = TypedEventInstance<AddStakeEvent> & {
    data_decoded: AddStakeEvent;
    type_arguments: [];
  };

  export interface UnlockStake {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    amount: bigint;
    commission_paid: bigint;
  }

  export namespace UnlockStake {
    export const TYPE_QNAME = "0x1::staking_contract::UnlockStake";

    const TYPE = new TypeDescriptor<UnlockStake>(UnlockStake.TYPE_QNAME);

    export function type(): TypeDescriptor<UnlockStake> {
      return TYPE.apply();
    }
  }

  export type UnlockStakeInstance = TypedEventInstance<UnlockStake> & {
    data_decoded: UnlockStake;
    type_arguments: [];
  };

  export interface UnlockStakeEvent {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    amount: bigint;
    commission_paid: bigint;
  }

  export namespace UnlockStakeEvent {
    export const TYPE_QNAME = "0x1::staking_contract::UnlockStakeEvent";

    const TYPE = new TypeDescriptor<UnlockStakeEvent>(
      UnlockStakeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UnlockStakeEvent> {
      return TYPE.apply();
    }
  }

  export type UnlockStakeEventInstance =
    TypedEventInstance<UnlockStakeEvent> & {
      data_decoded: UnlockStakeEvent;
      type_arguments: [];
    };

  export interface BeneficiaryForOperator {
    beneficiary_for_operator: MoveAddressType;
  }

  export namespace BeneficiaryForOperator {
    export const TYPE_QNAME = "0x1::staking_contract::BeneficiaryForOperator";

    const TYPE = new TypeDescriptor<BeneficiaryForOperator>(
      BeneficiaryForOperator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<BeneficiaryForOperator> {
      return TYPE.apply();
    }
  }

  export interface SetBeneficiaryForOperator {
    operator: MoveAddressType;
    old_beneficiary: MoveAddressType;
    new_beneficiary: MoveAddressType;
  }

  export namespace SetBeneficiaryForOperator {
    export const TYPE_QNAME =
      "0x1::staking_contract::SetBeneficiaryForOperator";

    const TYPE = new TypeDescriptor<SetBeneficiaryForOperator>(
      SetBeneficiaryForOperator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SetBeneficiaryForOperator> {
      return TYPE.apply();
    }
  }

  export type SetBeneficiaryForOperatorInstance =
    TypedEventInstance<SetBeneficiaryForOperator> & {
      data_decoded: SetBeneficiaryForOperator;
      type_arguments: [];
    };

  export interface AddDistribution {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace AddDistribution {
    export const TYPE_QNAME = "0x1::staking_contract::AddDistribution";

    const TYPE = new TypeDescriptor<AddDistribution>(
      AddDistribution.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AddDistribution> {
      return TYPE.apply();
    }
  }

  export type AddDistributionInstance = TypedEventInstance<AddDistribution> & {
    data_decoded: AddDistribution;
    type_arguments: [];
  };

  export interface AddDistributionEvent {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    amount: bigint;
  }

  export namespace AddDistributionEvent {
    export const TYPE_QNAME = "0x1::staking_contract::AddDistributionEvent";

    const TYPE = new TypeDescriptor<AddDistributionEvent>(
      AddDistributionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AddDistributionEvent> {
      return TYPE.apply();
    }
  }

  export type AddDistributionEventInstance =
    TypedEventInstance<AddDistributionEvent> & {
      data_decoded: AddDistributionEvent;
      type_arguments: [];
    };

  export interface CreateStakingContract {
    operator: MoveAddressType;
    voter: MoveAddressType;
    pool_address: MoveAddressType;
    principal: bigint;
    commission_percentage: bigint;
  }

  export namespace CreateStakingContract {
    export const TYPE_QNAME = "0x1::staking_contract::CreateStakingContract";

    const TYPE = new TypeDescriptor<CreateStakingContract>(
      CreateStakingContract.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateStakingContract> {
      return TYPE.apply();
    }
  }

  export type CreateStakingContractInstance =
    TypedEventInstance<CreateStakingContract> & {
      data_decoded: CreateStakingContract;
      type_arguments: [];
    };

  export interface CreateStakingContractEvent {
    operator: MoveAddressType;
    voter: MoveAddressType;
    pool_address: MoveAddressType;
    principal: bigint;
    commission_percentage: bigint;
  }

  export namespace CreateStakingContractEvent {
    export const TYPE_QNAME =
      "0x1::staking_contract::CreateStakingContractEvent";

    const TYPE = new TypeDescriptor<CreateStakingContractEvent>(
      CreateStakingContractEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CreateStakingContractEvent> {
      return TYPE.apply();
    }
  }

  export type CreateStakingContractEventInstance =
    TypedEventInstance<CreateStakingContractEvent> & {
      data_decoded: CreateStakingContractEvent;
      type_arguments: [];
    };

  export interface Distribute {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    recipient: MoveAddressType;
    amount: bigint;
  }

  export namespace Distribute {
    export const TYPE_QNAME = "0x1::staking_contract::Distribute";

    const TYPE = new TypeDescriptor<Distribute>(Distribute.TYPE_QNAME);

    export function type(): TypeDescriptor<Distribute> {
      return TYPE.apply();
    }
  }

  export type DistributeInstance = TypedEventInstance<Distribute> & {
    data_decoded: Distribute;
    type_arguments: [];
  };

  export interface DistributeEvent {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    recipient: MoveAddressType;
    amount: bigint;
  }

  export namespace DistributeEvent {
    export const TYPE_QNAME = "0x1::staking_contract::DistributeEvent";

    const TYPE = new TypeDescriptor<DistributeEvent>(
      DistributeEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DistributeEvent> {
      return TYPE.apply();
    }
  }

  export type DistributeEventInstance = TypedEventInstance<DistributeEvent> & {
    data_decoded: DistributeEvent;
    type_arguments: [];
  };

  export interface RequestCommission {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    accumulated_rewards: bigint;
    commission_amount: bigint;
  }

  export namespace RequestCommission {
    export const TYPE_QNAME = "0x1::staking_contract::RequestCommission";

    const TYPE = new TypeDescriptor<RequestCommission>(
      RequestCommission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RequestCommission> {
      return TYPE.apply();
    }
  }

  export type RequestCommissionInstance =
    TypedEventInstance<RequestCommission> & {
      data_decoded: RequestCommission;
      type_arguments: [];
    };

  export interface RequestCommissionEvent {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    accumulated_rewards: bigint;
    commission_amount: bigint;
  }

  export namespace RequestCommissionEvent {
    export const TYPE_QNAME = "0x1::staking_contract::RequestCommissionEvent";

    const TYPE = new TypeDescriptor<RequestCommissionEvent>(
      RequestCommissionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RequestCommissionEvent> {
      return TYPE.apply();
    }
  }

  export type RequestCommissionEventInstance =
    TypedEventInstance<RequestCommissionEvent> & {
      data_decoded: RequestCommissionEvent;
      type_arguments: [];
    };

  export interface ResetLockup {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
  }

  export namespace ResetLockup {
    export const TYPE_QNAME = "0x1::staking_contract::ResetLockup";

    const TYPE = new TypeDescriptor<ResetLockup>(ResetLockup.TYPE_QNAME);

    export function type(): TypeDescriptor<ResetLockup> {
      return TYPE.apply();
    }
  }

  export type ResetLockupInstance = TypedEventInstance<ResetLockup> & {
    data_decoded: ResetLockup;
    type_arguments: [];
  };

  export interface ResetLockupEvent {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
  }

  export namespace ResetLockupEvent {
    export const TYPE_QNAME = "0x1::staking_contract::ResetLockupEvent";

    const TYPE = new TypeDescriptor<ResetLockupEvent>(
      ResetLockupEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ResetLockupEvent> {
      return TYPE.apply();
    }
  }

  export type ResetLockupEventInstance =
    TypedEventInstance<ResetLockupEvent> & {
      data_decoded: ResetLockupEvent;
      type_arguments: [];
    };

  export interface Staker {
    staker: MoveAddressType;
  }

  export namespace Staker {
    export const TYPE_QNAME = "0x1::staking_contract::Staker";

    const TYPE = new TypeDescriptor<Staker>(Staker.TYPE_QNAME);

    export function type(): TypeDescriptor<Staker> {
      return TYPE.apply();
    }
  }

  export interface StakingContract {
    principal: bigint;
    pool_address: MoveAddressType;
    owner_cap: stake.OwnerCapability;
    commission_percentage: bigint;
    distribution_pool: pool_u64.Pool;
    signer_cap: account.SignerCapability;
  }

  export namespace StakingContract {
    export const TYPE_QNAME = "0x1::staking_contract::StakingContract";

    const TYPE = new TypeDescriptor<StakingContract>(
      StakingContract.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StakingContract> {
      return TYPE.apply();
    }
  }

  export interface StakingGroupContainer {
    dummy_field: boolean;
  }

  export namespace StakingGroupContainer {
    export const TYPE_QNAME = "0x1::staking_contract::StakingGroupContainer";

    const TYPE = new TypeDescriptor<StakingGroupContainer>(
      StakingGroupContainer.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StakingGroupContainer> {
      return TYPE.apply();
    }
  }

  export interface StakingGroupUpdateCommissionEvent {
    update_commission_events: event.EventHandle<staking_contract.UpdateCommissionEvent>;
  }

  export namespace StakingGroupUpdateCommissionEvent {
    export const TYPE_QNAME =
      "0x1::staking_contract::StakingGroupUpdateCommissionEvent";

    const TYPE = new TypeDescriptor<StakingGroupUpdateCommissionEvent>(
      StakingGroupUpdateCommissionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StakingGroupUpdateCommissionEvent> {
      return TYPE.apply();
    }
  }

  export type StakingGroupUpdateCommissionEventInstance =
    TypedEventInstance<StakingGroupUpdateCommissionEvent> & {
      data_decoded: StakingGroupUpdateCommissionEvent;
      type_arguments: [];
    };

  export interface Store {
    staking_contracts: simple_map.SimpleMap<
      MoveAddressType,
      staking_contract.StakingContract
    >;
    create_staking_contract_events: event.EventHandle<staking_contract.CreateStakingContractEvent>;
    update_voter_events: event.EventHandle<staking_contract.UpdateVoterEvent>;
    reset_lockup_events: event.EventHandle<staking_contract.ResetLockupEvent>;
    add_stake_events: event.EventHandle<staking_contract.AddStakeEvent>;
    request_commission_events: event.EventHandle<staking_contract.RequestCommissionEvent>;
    unlock_stake_events: event.EventHandle<staking_contract.UnlockStakeEvent>;
    switch_operator_events: event.EventHandle<staking_contract.SwitchOperatorEvent>;
    add_distribution_events: event.EventHandle<staking_contract.AddDistributionEvent>;
    distribute_events: event.EventHandle<staking_contract.DistributeEvent>;
  }

  export namespace Store {
    export const TYPE_QNAME = "0x1::staking_contract::Store";

    const TYPE = new TypeDescriptor<Store>(Store.TYPE_QNAME);

    export function type(): TypeDescriptor<Store> {
      return TYPE.apply();
    }
  }

  export interface SwitchOperator {
    old_operator: MoveAddressType;
    new_operator: MoveAddressType;
    pool_address: MoveAddressType;
  }

  export namespace SwitchOperator {
    export const TYPE_QNAME = "0x1::staking_contract::SwitchOperator";

    const TYPE = new TypeDescriptor<SwitchOperator>(SwitchOperator.TYPE_QNAME);

    export function type(): TypeDescriptor<SwitchOperator> {
      return TYPE.apply();
    }
  }

  export type SwitchOperatorInstance = TypedEventInstance<SwitchOperator> & {
    data_decoded: SwitchOperator;
    type_arguments: [];
  };

  export interface SwitchOperatorEvent {
    old_operator: MoveAddressType;
    new_operator: MoveAddressType;
    pool_address: MoveAddressType;
  }

  export namespace SwitchOperatorEvent {
    export const TYPE_QNAME = "0x1::staking_contract::SwitchOperatorEvent";

    const TYPE = new TypeDescriptor<SwitchOperatorEvent>(
      SwitchOperatorEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SwitchOperatorEvent> {
      return TYPE.apply();
    }
  }

  export type SwitchOperatorEventInstance =
    TypedEventInstance<SwitchOperatorEvent> & {
      data_decoded: SwitchOperatorEvent;
      type_arguments: [];
    };

  export interface UpdateCommission {
    staker: MoveAddressType;
    operator: MoveAddressType;
    old_commission_percentage: bigint;
    new_commission_percentage: bigint;
  }

  export namespace UpdateCommission {
    export const TYPE_QNAME = "0x1::staking_contract::UpdateCommission";

    const TYPE = new TypeDescriptor<UpdateCommission>(
      UpdateCommission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateCommission> {
      return TYPE.apply();
    }
  }

  export type UpdateCommissionInstance =
    TypedEventInstance<UpdateCommission> & {
      data_decoded: UpdateCommission;
      type_arguments: [];
    };

  export interface UpdateCommissionEvent {
    staker: MoveAddressType;
    operator: MoveAddressType;
    old_commission_percentage: bigint;
    new_commission_percentage: bigint;
  }

  export namespace UpdateCommissionEvent {
    export const TYPE_QNAME = "0x1::staking_contract::UpdateCommissionEvent";

    const TYPE = new TypeDescriptor<UpdateCommissionEvent>(
      UpdateCommissionEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateCommissionEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateCommissionEventInstance =
    TypedEventInstance<UpdateCommissionEvent> & {
      data_decoded: UpdateCommissionEvent;
      type_arguments: [];
    };

  export interface UpdateVoter {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    old_voter: MoveAddressType;
    new_voter: MoveAddressType;
  }

  export namespace UpdateVoter {
    export const TYPE_QNAME = "0x1::staking_contract::UpdateVoter";

    const TYPE = new TypeDescriptor<UpdateVoter>(UpdateVoter.TYPE_QNAME);

    export function type(): TypeDescriptor<UpdateVoter> {
      return TYPE.apply();
    }
  }

  export type UpdateVoterInstance = TypedEventInstance<UpdateVoter> & {
    data_decoded: UpdateVoter;
    type_arguments: [];
  };

  export interface UpdateVoterEvent {
    operator: MoveAddressType;
    pool_address: MoveAddressType;
    old_voter: MoveAddressType;
    new_voter: MoveAddressType;
  }

  export namespace UpdateVoterEvent {
    export const TYPE_QNAME = "0x1::staking_contract::UpdateVoterEvent";

    const TYPE = new TypeDescriptor<UpdateVoterEvent>(
      UpdateVoterEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateVoterEvent> {
      return TYPE.apply();
    }
  }

  export type UpdateVoterEventInstance =
    TypedEventInstance<UpdateVoterEvent> & {
      data_decoded: UpdateVoterEvent;
      type_arguments: [];
    };

  export namespace entry {
    export async function addStake(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::add_stake",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function setBeneficiaryForOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::set_beneficiary_for_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function createStakingContract(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          MoveAddressType,
          MoveAddressType,
          bigint,
          bigint,
          string,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::create_staking_contract",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function distribute(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::distribute",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function requestCommission(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::request_commission",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function resetLockup(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::reset_lockup",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function switchOperator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::switch_operator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function switchOperatorWithSameCommission(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::staking_contract::switch_operator_with_same_commission",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function unlockRewards(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::unlock_rewards",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function unlockStake(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::unlock_stake",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateCommision(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::update_commision",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function updateVoter(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::staking_contract::update_voter",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function beneficiaryForOperator(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::beneficiary_for_operator",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::beneficiary_for_operator",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getExpectedStakePoolAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType, string];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::get_expected_stake_pool_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::get_expected_stake_pool_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function commissionPercentage(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::commission_percentage",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::commission_percentage",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function lastRecordedPrincipal(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::last_recorded_principal",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::last_recorded_principal",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function pendingAttributionSnapshot(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::pending_attribution_snapshot",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::pending_attribution_snapshot",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function pendingDistributionCounts(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::pending_distribution_counts",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::pending_distribution_counts",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function stakePoolAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::stake_pool_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::stake_pool_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function stakerAddress(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[option.Option<MoveAddressType>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::staker_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::staker_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function stakingContractAmounts(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[bigint, bigint, bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::staking_contract_amounts",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::staking_contract_amounts",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function stakingContractExists(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::staking_contract::staking_contract_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::staking_contract::staking_contract_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface AddStakePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface SetBeneficiaryForOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface CreateStakingContractPayload
    extends TypedFunctionPayload<
      [MoveAddressType, MoveAddressType, bigint, bigint, string]
    > {
    arguments_decoded: [
      MoveAddressType,
      MoveAddressType,
      bigint,
      bigint,
      string,
    ];
    type_arguments: [];
  }

  export interface DistributePayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface RequestCommissionPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface ResetLockupPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface SwitchOperatorPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface SwitchOperatorWithSameCommissionPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }

  export interface UnlockRewardsPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }

  export interface UnlockStakePayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface UpdateCommisionPayload
    extends TypedFunctionPayload<[MoveAddressType, bigint]> {
    arguments_decoded: [MoveAddressType, bigint];
    type_arguments: [];
  }

  export interface UpdateVoterPayload
    extends TypedFunctionPayload<[MoveAddressType, MoveAddressType]> {
    arguments_decoded: [MoveAddressType, MoveAddressType];
    type_arguments: [];
  }
}

export namespace system_addresses {
  export namespace entry {}
  export namespace view {}
}

export namespace chunky_dkg_config {
  export interface ConfigOff {
    dummy_field: boolean;
  }

  export namespace ConfigOff {
    export const TYPE_QNAME = "0x1::chunky_dkg_config::ConfigOff";

    const TYPE = new TypeDescriptor<ConfigOff>(ConfigOff.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigOff> {
      return TYPE.apply();
    }
  }

  export interface ConfigV1 {
    secrecy_threshold: fixed_point64.FixedPoint64;
    reconstruction_threshold: fixed_point64.FixedPoint64;
  }

  export namespace ConfigV1 {
    export const TYPE_QNAME = "0x1::chunky_dkg_config::ConfigV1";

    const TYPE = new TypeDescriptor<ConfigV1>(ConfigV1.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigV1> {
      return TYPE.apply();
    }
  }

  export interface ChunkyDKGConfig {
    variant: copyable_any.Any;
  }

  export namespace ChunkyDKGConfig {
    export const TYPE_QNAME = "0x1::chunky_dkg_config::ChunkyDKGConfig";

    const TYPE = new TypeDescriptor<ChunkyDKGConfig>(
      ChunkyDKGConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ChunkyDKGConfig> {
      return TYPE.apply();
    }
  }

  export interface ConfigShadowV1 {
    secrecy_threshold: fixed_point64.FixedPoint64;
    reconstruction_threshold: fixed_point64.FixedPoint64;
    grace_period_secs: bigint;
  }

  export namespace ConfigShadowV1 {
    export const TYPE_QNAME = "0x1::chunky_dkg_config::ConfigShadowV1";

    const TYPE = new TypeDescriptor<ConfigShadowV1>(ConfigShadowV1.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigShadowV1> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace federated_keyless {
  export interface PublicKey {
    jwk_address: MoveAddressType;
    keyless_public_key: keyless.PublicKey;
  }

  export namespace PublicKey {
    export const TYPE_QNAME = "0x1::federated_keyless::PublicKey";

    const TYPE = new TypeDescriptor<PublicKey>(PublicKey.TYPE_QNAME);

    export function type(): TypeDescriptor<PublicKey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace randomness_config {
  export interface ConfigOff {
    dummy_field: boolean;
  }

  export namespace ConfigOff {
    export const TYPE_QNAME = "0x1::randomness_config::ConfigOff";

    const TYPE = new TypeDescriptor<ConfigOff>(ConfigOff.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigOff> {
      return TYPE.apply();
    }
  }

  export interface ConfigV1 {
    secrecy_threshold: fixed_point64.FixedPoint64;
    reconstruction_threshold: fixed_point64.FixedPoint64;
  }

  export namespace ConfigV1 {
    export const TYPE_QNAME = "0x1::randomness_config::ConfigV1";

    const TYPE = new TypeDescriptor<ConfigV1>(ConfigV1.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigV1> {
      return TYPE.apply();
    }
  }

  export interface ConfigV2 {
    secrecy_threshold: fixed_point64.FixedPoint64;
    reconstruction_threshold: fixed_point64.FixedPoint64;
    fast_path_secrecy_threshold: fixed_point64.FixedPoint64;
  }

  export namespace ConfigV2 {
    export const TYPE_QNAME = "0x1::randomness_config::ConfigV2";

    const TYPE = new TypeDescriptor<ConfigV2>(ConfigV2.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigV2> {
      return TYPE.apply();
    }
  }

  export interface RandomnessConfig {
    variant: copyable_any.Any;
  }

  export namespace RandomnessConfig {
    export const TYPE_QNAME = "0x1::randomness_config::RandomnessConfig";

    const TYPE = new TypeDescriptor<RandomnessConfig>(
      RandomnessConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RandomnessConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace table_with_length {
  export interface TableWithLength<T0, T1> {
    inner: table.Table<T0, T1>;
    length: bigint;
  }

  export namespace TableWithLength {
    export const TYPE_QNAME = "0x1::table_with_length::TableWithLength";

    const TYPE = new TypeDescriptor<TableWithLength<any, any>>(
      TableWithLength.TYPE_QNAME,
    );

    export function type<T0, T1>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
      arg1: TypeDescriptor<T1> = ANY_TYPE,
    ): TypeDescriptor<TableWithLength<T0, T1>> {
      return TYPE.apply(arg0, arg1);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace aggregator_factory {
  export interface AggregatorFactory {
    phantom_table: table.Table<MoveAddressType, bigint>;
  }

  export namespace AggregatorFactory {
    export const TYPE_QNAME = "0x1::aggregator_factory::AggregatorFactory";

    const TYPE = new TypeDescriptor<AggregatorFactory>(
      AggregatorFactory.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AggregatorFactory> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class confidential_asset extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("confidential_asset", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): confidential_asset {
    return new confidential_asset({
      ...confidential_asset.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryDeposit(
    func: (call: confidential_asset.DepositPayload, ctx: AptosContext) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.DepositPayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::deposit",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryConfidentialTransferRaw(
    func: (
      call: confidential_asset.ConfidentialTransferRawPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.ConfidentialTransferRawPayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::confidential_transfer_raw",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryNormalizeRaw(
    func: (
      call: confidential_asset.NormalizeRawPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.NormalizeRawPayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::normalize_raw",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRegisterRaw(
    func: (
      call: confidential_asset.RegisterRawPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.RegisterRawPayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::register_raw",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRolloverPendingBalance(
    func: (
      call: confidential_asset.RolloverPendingBalancePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.RolloverPendingBalancePayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::rollover_pending_balance",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRolloverPendingBalanceAndPause(
    func: (
      call: confidential_asset.RolloverPendingBalanceAndPausePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.RolloverPendingBalanceAndPausePayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::rollover_pending_balance_and_pause",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRotateEncryptionKeyRaw(
    func: (
      call: confidential_asset.RotateEncryptionKeyRawPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.RotateEncryptionKeyRawPayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::rotate_encryption_key_raw",
      },
      handlerOptions,
    );
    return this;
  }

  onEntrySetIncomingTransfersPaused(
    func: (
      call: confidential_asset.SetIncomingTransfersPausedPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.SetIncomingTransfersPausedPayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::set_incoming_transfers_paused",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryWithdrawToRaw(
    func: (
      call: confidential_asset.WithdrawToRawPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.WithdrawToRawPayload
    >,
  ): confidential_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "confidential_asset::withdraw_to_raw",
      },
      handlerOptions,
    );
    return this;
  }

  onEventAllowListingChanged(
    func: (
      event: confidential_asset.AllowListingChangedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.AllowListingChangedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "confidential_asset::AllowListingChanged",
      },
      handlerOptions,
    );
    return this;
  }

  onEventAssetSpecificAuditorChanged(
    func: (
      event: confidential_asset.AssetSpecificAuditorChangedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.AssetSpecificAuditorChangedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "confidential_asset::AssetSpecificAuditorChanged",
      },
      handlerOptions,
    );
    return this;
  }

  onEventConfidentialityForAssetTypeChanged(
    func: (
      event: confidential_asset.ConfidentialityForAssetTypeChangedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.ConfidentialityForAssetTypeChangedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "confidential_asset::ConfidentialityForAssetTypeChanged",
      },
      handlerOptions,
    );
    return this;
  }

  onEventDeposited(
    func: (
      event: confidential_asset.DepositedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.DepositedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "confidential_asset::Deposited" },
      handlerOptions,
    );
    return this;
  }

  onEventEmergencyPauseChanged(
    func: (
      event: confidential_asset.EmergencyPauseChangedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.EmergencyPauseChangedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "confidential_asset::EmergencyPauseChanged",
      },
      handlerOptions,
    );
    return this;
  }

  onEventGlobalAuditorChanged(
    func: (
      event: confidential_asset.GlobalAuditorChangedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.GlobalAuditorChangedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "confidential_asset::GlobalAuditorChanged",
      },
      handlerOptions,
    );
    return this;
  }

  onEventIncomingTransfersPauseChanged(
    func: (
      event: confidential_asset.IncomingTransfersPauseChangedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.IncomingTransfersPauseChangedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "confidential_asset::IncomingTransfersPauseChanged",
      },
      handlerOptions,
    );
    return this;
  }

  onEventKeyRotated(
    func: (
      event: confidential_asset.KeyRotatedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.KeyRotatedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "confidential_asset::KeyRotated" },
      handlerOptions,
    );
    return this;
  }

  onEventNormalized(
    func: (
      event: confidential_asset.NormalizedInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.NormalizedInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "confidential_asset::Normalized" },
      handlerOptions,
    );
    return this;
  }

  onEventRegistered(
    func: (
      event: confidential_asset.RegisteredInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.RegisteredInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "confidential_asset::Registered" },
      handlerOptions,
    );
    return this;
  }

  onEventRolledOver(
    func: (
      event: confidential_asset.RolledOverInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.RolledOverInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "confidential_asset::RolledOver" },
      handlerOptions,
    );
    return this;
  }

  onEventTransferred(
    func: (
      event: confidential_asset.TransferredInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.TransferredInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "confidential_asset::Transferred" },
      handlerOptions,
    );
    return this;
  }

  onEventWithdrawn(
    func: (
      event: confidential_asset.WithdrawnInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      confidential_asset.WithdrawnInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): confidential_asset {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "confidential_asset::Withdrawn" },
      handlerOptions,
    );
    return this;
  }
}

export namespace confidential_asset {
  export interface AllowListingChanged {}

  export namespace AllowListingChanged {
    export const TYPE_QNAME = "0x1::confidential_asset::AllowListingChanged";

    const TYPE = new TypeDescriptor<AllowListingChanged>(
      AllowListingChanged.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AllowListingChanged> {
      return TYPE.apply();
    }
  }

  export type AllowListingChangedInstance =
    TypedEventInstance<AllowListingChanged> & {
      data_decoded: AllowListingChanged;
      type_arguments: [];
    };

  export interface AssetConfig {}

  export namespace AssetConfig {
    export const TYPE_QNAME = "0x1::confidential_asset::AssetConfig";

    const TYPE = new TypeDescriptor<AssetConfig>(AssetConfig.TYPE_QNAME);

    export function type(): TypeDescriptor<AssetConfig> {
      return TYPE.apply();
    }
  }

  export interface AssetSpecificAuditorChanged {}

  export namespace AssetSpecificAuditorChanged {
    export const TYPE_QNAME =
      "0x1::confidential_asset::AssetSpecificAuditorChanged";

    const TYPE = new TypeDescriptor<AssetSpecificAuditorChanged>(
      AssetSpecificAuditorChanged.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AssetSpecificAuditorChanged> {
      return TYPE.apply();
    }
  }

  export type AssetSpecificAuditorChangedInstance =
    TypedEventInstance<AssetSpecificAuditorChanged> & {
      data_decoded: AssetSpecificAuditorChanged;
      type_arguments: [];
    };

  export interface AuditorConfig {}

  export namespace AuditorConfig {
    export const TYPE_QNAME = "0x1::confidential_asset::AuditorConfig";

    const TYPE = new TypeDescriptor<AuditorConfig>(AuditorConfig.TYPE_QNAME);

    export function type(): TypeDescriptor<AuditorConfig> {
      return TYPE.apply();
    }
  }

  export interface ConfidentialStore {}

  export namespace ConfidentialStore {
    export const TYPE_QNAME = "0x1::confidential_asset::ConfidentialStore";

    const TYPE = new TypeDescriptor<ConfidentialStore>(
      ConfidentialStore.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ConfidentialStore> {
      return TYPE.apply();
    }
  }

  export interface ConfidentialityForAssetTypeChanged {}

  export namespace ConfidentialityForAssetTypeChanged {
    export const TYPE_QNAME =
      "0x1::confidential_asset::ConfidentialityForAssetTypeChanged";

    const TYPE = new TypeDescriptor<ConfidentialityForAssetTypeChanged>(
      ConfidentialityForAssetTypeChanged.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ConfidentialityForAssetTypeChanged> {
      return TYPE.apply();
    }
  }

  export type ConfidentialityForAssetTypeChangedInstance =
    TypedEventInstance<ConfidentialityForAssetTypeChanged> & {
      data_decoded: ConfidentialityForAssetTypeChanged;
      type_arguments: [];
    };

  export interface Deposited {}

  export namespace Deposited {
    export const TYPE_QNAME = "0x1::confidential_asset::Deposited";

    const TYPE = new TypeDescriptor<Deposited>(Deposited.TYPE_QNAME);

    export function type(): TypeDescriptor<Deposited> {
      return TYPE.apply();
    }
  }

  export type DepositedInstance = TypedEventInstance<Deposited> & {
    data_decoded: Deposited;
    type_arguments: [];
  };

  export interface EffectiveAuditorConfig {}

  export namespace EffectiveAuditorConfig {
    export const TYPE_QNAME = "0x1::confidential_asset::EffectiveAuditorConfig";

    const TYPE = new TypeDescriptor<EffectiveAuditorConfig>(
      EffectiveAuditorConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<EffectiveAuditorConfig> {
      return TYPE.apply();
    }
  }

  export interface EffectiveAuditorHint {}

  export namespace EffectiveAuditorHint {
    export const TYPE_QNAME = "0x1::confidential_asset::EffectiveAuditorHint";

    const TYPE = new TypeDescriptor<EffectiveAuditorHint>(
      EffectiveAuditorHint.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<EffectiveAuditorHint> {
      return TYPE.apply();
    }
  }

  export interface EmergencyPauseChanged {}

  export namespace EmergencyPauseChanged {
    export const TYPE_QNAME = "0x1::confidential_asset::EmergencyPauseChanged";

    const TYPE = new TypeDescriptor<EmergencyPauseChanged>(
      EmergencyPauseChanged.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<EmergencyPauseChanged> {
      return TYPE.apply();
    }
  }

  export type EmergencyPauseChangedInstance =
    TypedEventInstance<EmergencyPauseChanged> & {
      data_decoded: EmergencyPauseChanged;
      type_arguments: [];
    };

  export interface GlobalAuditorChanged {}

  export namespace GlobalAuditorChanged {
    export const TYPE_QNAME = "0x1::confidential_asset::GlobalAuditorChanged";

    const TYPE = new TypeDescriptor<GlobalAuditorChanged>(
      GlobalAuditorChanged.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GlobalAuditorChanged> {
      return TYPE.apply();
    }
  }

  export type GlobalAuditorChangedInstance =
    TypedEventInstance<GlobalAuditorChanged> & {
      data_decoded: GlobalAuditorChanged;
      type_arguments: [];
    };

  export interface GlobalConfig {}

  export namespace GlobalConfig {
    export const TYPE_QNAME = "0x1::confidential_asset::GlobalConfig";

    const TYPE = new TypeDescriptor<GlobalConfig>(GlobalConfig.TYPE_QNAME);

    export function type(): TypeDescriptor<GlobalConfig> {
      return TYPE.apply();
    }
  }

  export interface IncomingTransfersPauseChanged {}

  export namespace IncomingTransfersPauseChanged {
    export const TYPE_QNAME =
      "0x1::confidential_asset::IncomingTransfersPauseChanged";

    const TYPE = new TypeDescriptor<IncomingTransfersPauseChanged>(
      IncomingTransfersPauseChanged.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<IncomingTransfersPauseChanged> {
      return TYPE.apply();
    }
  }

  export type IncomingTransfersPauseChangedInstance =
    TypedEventInstance<IncomingTransfersPauseChanged> & {
      data_decoded: IncomingTransfersPauseChanged;
      type_arguments: [];
    };

  export interface KeyRotated {}

  export namespace KeyRotated {
    export const TYPE_QNAME = "0x1::confidential_asset::KeyRotated";

    const TYPE = new TypeDescriptor<KeyRotated>(KeyRotated.TYPE_QNAME);

    export function type(): TypeDescriptor<KeyRotated> {
      return TYPE.apply();
    }
  }

  export type KeyRotatedInstance = TypedEventInstance<KeyRotated> & {
    data_decoded: KeyRotated;
    type_arguments: [];
  };

  export interface KeyRotationProof {}

  export namespace KeyRotationProof {
    export const TYPE_QNAME = "0x1::confidential_asset::KeyRotationProof";

    const TYPE = new TypeDescriptor<KeyRotationProof>(
      KeyRotationProof.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<KeyRotationProof> {
      return TYPE.apply();
    }
  }

  export interface Normalized {}

  export namespace Normalized {
    export const TYPE_QNAME = "0x1::confidential_asset::Normalized";

    const TYPE = new TypeDescriptor<Normalized>(Normalized.TYPE_QNAME);

    export function type(): TypeDescriptor<Normalized> {
      return TYPE.apply();
    }
  }

  export type NormalizedInstance = TypedEventInstance<Normalized> & {
    data_decoded: Normalized;
    type_arguments: [];
  };

  export interface Registered {}

  export namespace Registered {
    export const TYPE_QNAME = "0x1::confidential_asset::Registered";

    const TYPE = new TypeDescriptor<Registered>(Registered.TYPE_QNAME);

    export function type(): TypeDescriptor<Registered> {
      return TYPE.apply();
    }
  }

  export type RegisteredInstance = TypedEventInstance<Registered> & {
    data_decoded: Registered;
    type_arguments: [];
  };

  export interface RegistrationProof {}

  export namespace RegistrationProof {
    export const TYPE_QNAME = "0x1::confidential_asset::RegistrationProof";

    const TYPE = new TypeDescriptor<RegistrationProof>(
      RegistrationProof.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RegistrationProof> {
      return TYPE.apply();
    }
  }

  export interface RolledOver {}

  export namespace RolledOver {
    export const TYPE_QNAME = "0x1::confidential_asset::RolledOver";

    const TYPE = new TypeDescriptor<RolledOver>(RolledOver.TYPE_QNAME);

    export function type(): TypeDescriptor<RolledOver> {
      return TYPE.apply();
    }
  }

  export type RolledOverInstance = TypedEventInstance<RolledOver> & {
    data_decoded: RolledOver;
    type_arguments: [];
  };

  export interface TransferProof {}

  export namespace TransferProof {
    export const TYPE_QNAME = "0x1::confidential_asset::TransferProof";

    const TYPE = new TypeDescriptor<TransferProof>(TransferProof.TYPE_QNAME);

    export function type(): TypeDescriptor<TransferProof> {
      return TYPE.apply();
    }
  }

  export interface Transferred {}

  export namespace Transferred {
    export const TYPE_QNAME = "0x1::confidential_asset::Transferred";

    const TYPE = new TypeDescriptor<Transferred>(Transferred.TYPE_QNAME);

    export function type(): TypeDescriptor<Transferred> {
      return TYPE.apply();
    }
  }

  export type TransferredInstance = TypedEventInstance<Transferred> & {
    data_decoded: Transferred;
    type_arguments: [];
  };

  export interface WithdrawalProof {}

  export namespace WithdrawalProof {
    export const TYPE_QNAME = "0x1::confidential_asset::WithdrawalProof";

    const TYPE = new TypeDescriptor<WithdrawalProof>(
      WithdrawalProof.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<WithdrawalProof> {
      return TYPE.apply();
    }
  }

  export interface Withdrawn {}

  export namespace Withdrawn {
    export const TYPE_QNAME = "0x1::confidential_asset::Withdrawn";

    const TYPE = new TypeDescriptor<Withdrawn>(Withdrawn.TYPE_QNAME);

    export function type(): TypeDescriptor<Withdrawn> {
      return TYPE.apply();
    }
  }

  export type WithdrawnInstance = TypedEventInstance<Withdrawn> & {
    data_decoded: Withdrawn;
    type_arguments: [];
  };

  export namespace entry {
    export async function deposit(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [object$.Object<fungible_asset.Metadata>, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::deposit",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function confidentialTransferRaw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          object$.Object<fungible_asset.Metadata>,
          MoveAddressType,
          string[],
          string[],
          string[],
          string[],
          string[],
          string[],
          string[],
          string[],
          string[][],
          string,
          string,
          string[],
          string[],
          string,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::confidential_transfer_raw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function normalizeRaw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          object$.Object<fungible_asset.Metadata>,
          string[],
          string[],
          string[],
          string,
          string[],
          string[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::normalize_raw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function registerRaw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          object$.Object<fungible_asset.Metadata>,
          string,
          string[],
          string[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::register_raw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function rolloverPendingBalance(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::rollover_pending_balance",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function rolloverPendingBalanceAndPause(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::confidential_asset::rollover_pending_balance_and_pause",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function rotateEncryptionKeyRaw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          object$.Object<fungible_asset.Metadata>,
          string,
          boolean,
          string[],
          string[],
          string[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::rotate_encryption_key_raw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function setIncomingTransfersPaused(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [object$.Object<fungible_asset.Metadata>, boolean];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::set_incoming_transfers_paused",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function withdrawToRaw(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          object$.Object<fungible_asset.Metadata>,
          MoveAddressType,
          bigint,
          string[],
          string[],
          string[],
          string,
          string[],
          string[],
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::confidential_asset::withdraw_to_raw",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function getAssetSpecificAuditorConfig(
      client: Aptos,
      request: {
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      version?: bigint,
    ): Promise<[confidential_asset.AuditorConfig]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_asset_specific_auditor_config",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_asset_specific_auditor_config",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getAvailableBalance(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<
      [confidential_balance.CompressedBalance<confidential_balance.Available>]
    > {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_available_balance",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_available_balance",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getEffectiveAuditorConfig(
      client: Aptos,
      request: {
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      version?: bigint,
    ): Promise<[confidential_asset.EffectiveAuditorConfig]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_effective_auditor_config",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_effective_auditor_config",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getEffectiveAuditorHint(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<[option.Option<confidential_asset.EffectiveAuditorHint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_effective_auditor_hint",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_effective_auditor_hint",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getEncryptionKey(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<[ristretto255.CompressedRistretto]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_encryption_key",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_encryption_key",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getGlobalAuditorConfig(
      client: Aptos,

      version?: bigint,
    ): Promise<[confidential_asset.AuditorConfig]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_global_auditor_config",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_global_auditor_config",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getMaxMemoBytes(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_max_memo_bytes",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_max_memo_bytes",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getMaxTransfersBeforeRollover(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_max_transfers_before_rollover",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_max_transfers_before_rollover",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getNumTransfersReceived(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_num_transfers_received",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_num_transfers_received",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getPendingBalance(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<
      [confidential_balance.CompressedBalance<confidential_balance.Pending>]
    > {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_pending_balance",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_pending_balance",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getTotalConfidentialSupply(
      client: Aptos,
      request: {
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::get_total_confidential_supply",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::get_total_confidential_supply",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function hasConfidentialStore(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::has_confidential_store",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::has_confidential_store",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function incomingTransfersPaused(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::incoming_transfers_paused",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::incoming_transfers_paused",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isAllowListingRequired(
      client: Aptos,

      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::is_allow_listing_required",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::is_allow_listing_required",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isConfidentialityEnabledForAssetType(
      client: Aptos,
      request: {
        functionArguments: [object$.Object<fungible_asset.Metadata>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::confidential_asset::is_confidentiality_enabled_for_asset_type",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::is_confidentiality_enabled_for_asset_type",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isEmergencyPaused(
      client: Aptos,

      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::is_emergency_paused",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::is_emergency_paused",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isNormalized(
      client: Aptos,
      request: {
        functionArguments: [
          MoveAddressType,
          object$.Object<fungible_asset.Metadata>,
        ];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_asset::is_normalized",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_asset::is_normalized",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface DepositPayload
    extends TypedFunctionPayload<
      [object$.Object<fungible_asset.Metadata>, bigint]
    > {
    arguments_decoded: [object$.Object<fungible_asset.Metadata>, bigint];
    type_arguments: [];
  }

  export interface ConfidentialTransferRawPayload
    extends TypedFunctionPayload<
      [
        object$.Object<fungible_asset.Metadata>,
        MoveAddressType,
        string[],
        string[],
        string[],
        string[],
        string[],
        string[],
        string[],
        string[],
        string[][],
        string,
        string,
        string[],
        string[],
        string,
      ]
    > {
    arguments_decoded: [
      object$.Object<fungible_asset.Metadata>,
      MoveAddressType,
      string[],
      string[],
      string[],
      string[],
      string[],
      string[],
      string[],
      string[],
      string[][],
      string,
      string,
      string[],
      string[],
      string,
    ];
    type_arguments: [];
  }

  export interface NormalizeRawPayload
    extends TypedFunctionPayload<
      [
        object$.Object<fungible_asset.Metadata>,
        string[],
        string[],
        string[],
        string,
        string[],
        string[],
      ]
    > {
    arguments_decoded: [
      object$.Object<fungible_asset.Metadata>,
      string[],
      string[],
      string[],
      string,
      string[],
      string[],
    ];
    type_arguments: [];
  }

  export interface RegisterRawPayload
    extends TypedFunctionPayload<
      [object$.Object<fungible_asset.Metadata>, string, string[], string[]]
    > {
    arguments_decoded: [
      object$.Object<fungible_asset.Metadata>,
      string,
      string[],
      string[],
    ];
    type_arguments: [];
  }

  export interface RolloverPendingBalancePayload
    extends TypedFunctionPayload<[object$.Object<fungible_asset.Metadata>]> {
    arguments_decoded: [object$.Object<fungible_asset.Metadata>];
    type_arguments: [];
  }

  export interface RolloverPendingBalanceAndPausePayload
    extends TypedFunctionPayload<[object$.Object<fungible_asset.Metadata>]> {
    arguments_decoded: [object$.Object<fungible_asset.Metadata>];
    type_arguments: [];
  }

  export interface RotateEncryptionKeyRawPayload
    extends TypedFunctionPayload<
      [
        object$.Object<fungible_asset.Metadata>,
        string,
        boolean,
        string[],
        string[],
        string[],
      ]
    > {
    arguments_decoded: [
      object$.Object<fungible_asset.Metadata>,
      string,
      boolean,
      string[],
      string[],
      string[],
    ];
    type_arguments: [];
  }

  export interface SetIncomingTransfersPausedPayload
    extends TypedFunctionPayload<
      [object$.Object<fungible_asset.Metadata>, boolean]
    > {
    arguments_decoded: [object$.Object<fungible_asset.Metadata>, boolean];
    type_arguments: [];
  }

  export interface WithdrawToRawPayload
    extends TypedFunctionPayload<
      [
        object$.Object<fungible_asset.Metadata>,
        MoveAddressType,
        bigint,
        string[],
        string[],
        string[],
        string,
        string[],
        string[],
      ]
    > {
    arguments_decoded: [
      object$.Object<fungible_asset.Metadata>,
      MoveAddressType,
      bigint,
      string[],
      string[],
      string[],
      string,
      string[],
      string[],
    ];
    type_arguments: [];
  }
}

export namespace transaction_limits {
  export interface RequestedMultipliers {}

  export namespace RequestedMultipliers {
    export const TYPE_QNAME = "0x1::transaction_limits::RequestedMultipliers";

    const TYPE = new TypeDescriptor<RequestedMultipliers>(
      RequestedMultipliers.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RequestedMultipliers> {
      return TYPE.apply();
    }
  }

  export interface TxnLimitTier {
    min_stake: bigint;
    multiplier_percent: bigint;
  }

  export namespace TxnLimitTier {
    export const TYPE_QNAME = "0x1::transaction_limits::TxnLimitTier";

    const TYPE = new TypeDescriptor<TxnLimitTier>(TxnLimitTier.TYPE_QNAME);

    export function type(): TypeDescriptor<TxnLimitTier> {
      return TYPE.apply();
    }
  }

  export interface TxnLimitsConfig {}

  export namespace TxnLimitsConfig {
    export const TYPE_QNAME = "0x1::transaction_limits::TxnLimitsConfig";

    const TYPE = new TypeDescriptor<TxnLimitsConfig>(
      TxnLimitsConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TxnLimitsConfig> {
      return TYPE.apply();
    }
  }

  export interface UserTxnLimitsRequest {}

  export namespace UserTxnLimitsRequest {
    export const TYPE_QNAME = "0x1::transaction_limits::UserTxnLimitsRequest";

    const TYPE = new TypeDescriptor<UserTxnLimitsRequest>(
      UserTxnLimitsRequest.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UserTxnLimitsRequest> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class account_abstraction extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("account_abstraction", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): account_abstraction {
    return new account_abstraction({
      ...account_abstraction.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryInitialize(
    func: (
      call: account_abstraction.InitializePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.InitializePayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account_abstraction::initialize",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddAuthenticationFunction(
    func: (
      call: account_abstraction.AddAuthenticationFunctionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.AddAuthenticationFunctionPayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account_abstraction::add_authentication_function",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryAddDispatchableAuthenticationFunction(
    func: (
      call: account_abstraction.AddDispatchableAuthenticationFunctionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.AddDispatchableAuthenticationFunctionPayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "account_abstraction::add_dispatchable_authentication_function",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRegisterDerivableAuthenticationFunction(
    func: (
      call: account_abstraction.RegisterDerivableAuthenticationFunctionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.RegisterDerivableAuthenticationFunctionPayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "account_abstraction::register_derivable_authentication_function",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveAuthenticationFunction(
    func: (
      call: account_abstraction.RemoveAuthenticationFunctionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.RemoveAuthenticationFunctionPayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account_abstraction::remove_authentication_function",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveAuthenticator(
    func: (
      call: account_abstraction.RemoveAuthenticatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.RemoveAuthenticatorPayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account_abstraction::remove_authenticator",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveDispatchableAuthenticationFunction(
    func: (
      call: account_abstraction.RemoveDispatchableAuthenticationFunctionPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.RemoveDispatchableAuthenticationFunctionPayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "account_abstraction::remove_dispatchable_authentication_function",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRemoveDispatchableAuthenticator(
    func: (
      call: account_abstraction.RemoveDispatchableAuthenticatorPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.RemoveDispatchableAuthenticatorPayload
    >,
  ): account_abstraction {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "account_abstraction::remove_dispatchable_authenticator",
      },
      handlerOptions,
    );
    return this;
  }

  onEventRemoveDispatchableAuthenticator(
    func: (
      event: account_abstraction.RemoveDispatchableAuthenticatorInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.RemoveDispatchableAuthenticatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account_abstraction {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "account_abstraction::RemoveDispatchableAuthenticator",
      },
      handlerOptions,
    );
    return this;
  }

  onEventUpdateDispatchableAuthenticator(
    func: (
      event: account_abstraction.UpdateDispatchableAuthenticatorInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      account_abstraction.UpdateDispatchableAuthenticatorInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): account_abstraction {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "account_abstraction::UpdateDispatchableAuthenticator",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace account_abstraction {
  export interface DerivableDispatchableAuthenticator {}

  export namespace DerivableDispatchableAuthenticator {
    export const TYPE_QNAME =
      "0x1::account_abstraction::DerivableDispatchableAuthenticator";

    const TYPE = new TypeDescriptor<DerivableDispatchableAuthenticator>(
      DerivableDispatchableAuthenticator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DerivableDispatchableAuthenticator> {
      return TYPE.apply();
    }
  }

  export interface DerivableRegisterValue {}

  export namespace DerivableRegisterValue {
    export const TYPE_QNAME =
      "0x1::account_abstraction::DerivableRegisterValue";

    const TYPE = new TypeDescriptor<DerivableRegisterValue>(
      DerivableRegisterValue.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DerivableRegisterValue> {
      return TYPE.apply();
    }
  }

  export interface DispatchableAuthenticator {}

  export namespace DispatchableAuthenticator {
    export const TYPE_QNAME =
      "0x1::account_abstraction::DispatchableAuthenticator";

    const TYPE = new TypeDescriptor<DispatchableAuthenticator>(
      DispatchableAuthenticator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DispatchableAuthenticator> {
      return TYPE.apply();
    }
  }

  export interface RemoveDispatchableAuthenticator {
    account: MoveAddressType;
  }

  export namespace RemoveDispatchableAuthenticator {
    export const TYPE_QNAME =
      "0x1::account_abstraction::RemoveDispatchableAuthenticator";

    const TYPE = new TypeDescriptor<RemoveDispatchableAuthenticator>(
      RemoveDispatchableAuthenticator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RemoveDispatchableAuthenticator> {
      return TYPE.apply();
    }
  }

  export type RemoveDispatchableAuthenticatorInstance =
    TypedEventInstance<RemoveDispatchableAuthenticator> & {
      data_decoded: RemoveDispatchableAuthenticator;
      type_arguments: [];
    };

  export interface UpdateDispatchableAuthenticator {
    account: MoveAddressType;
    update: string;
    auth_function: function_info.FunctionInfo;
  }

  export namespace UpdateDispatchableAuthenticator {
    export const TYPE_QNAME =
      "0x1::account_abstraction::UpdateDispatchableAuthenticator";

    const TYPE = new TypeDescriptor<UpdateDispatchableAuthenticator>(
      UpdateDispatchableAuthenticator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<UpdateDispatchableAuthenticator> {
      return TYPE.apply();
    }
  }

  export type UpdateDispatchableAuthenticatorInstance =
    TypedEventInstance<UpdateDispatchableAuthenticator> & {
      data_decoded: UpdateDispatchableAuthenticator;
      type_arguments: [];
    };

  export namespace entry {
    export async function initialize(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account_abstraction::initialize",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function addAuthenticationFunction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account_abstraction::add_authentication_function",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function addDispatchableAuthenticationFunction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::account_abstraction::add_dispatchable_authentication_function",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function registerDerivableAuthenticationFunction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::account_abstraction::register_derivable_authentication_function",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function removeAuthenticationFunction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account_abstraction::remove_authentication_function",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function removeAuthenticator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::account_abstraction::remove_authenticator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function removeDispatchableAuthenticationFunction(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType, string, string];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::account_abstraction::remove_dispatchable_authentication_function",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function removeDispatchableAuthenticator(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::account_abstraction::remove_dispatchable_authenticator",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function deriveAccountAddressView(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType, string, string, string];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account_abstraction::derive_account_address_view",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account_abstraction::derive_account_address_view",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function dispatchableAuthenticator(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[option.Option<function_info.FunctionInfo[]>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account_abstraction::dispatchable_authenticator",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account_abstraction::dispatchable_authenticator",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function usingDispatchableAuthenticator(
      client: Aptos,
      request: {
        functionArguments: [MoveAddressType];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::account_abstraction::using_dispatchable_authenticator",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::account_abstraction::using_dispatchable_authenticator",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface InitializePayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface AddAuthenticationFunctionPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string]> {
    arguments_decoded: [MoveAddressType, string, string];
    type_arguments: [];
  }

  export interface AddDispatchableAuthenticationFunctionPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string]> {
    arguments_decoded: [MoveAddressType, string, string];
    type_arguments: [];
  }

  export interface RegisterDerivableAuthenticationFunctionPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string]> {
    arguments_decoded: [MoveAddressType, string, string];
    type_arguments: [];
  }

  export interface RemoveAuthenticationFunctionPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string]> {
    arguments_decoded: [MoveAddressType, string, string];
    type_arguments: [];
  }

  export interface RemoveAuthenticatorPayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface RemoveDispatchableAuthenticationFunctionPayload
    extends TypedFunctionPayload<[MoveAddressType, string, string]> {
    arguments_decoded: [MoveAddressType, string, string];
    type_arguments: [];
  }

  export interface RemoveDispatchableAuthenticatorPayload
    extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }
}

export namespace confidential_amount {
  export interface Amount {
    P: ristretto255.RistrettoPoint[];
    R_sender: ristretto255.RistrettoPoint[];
    R_recip: ristretto255.RistrettoPoint[];
    R_eff_aud: ristretto255.RistrettoPoint[];
    R_volun_auds: ristretto255.RistrettoPoint[][];
  }

  export namespace Amount {
    export const TYPE_QNAME = "0x1::confidential_amount::Amount";

    const TYPE = new TypeDescriptor<Amount>(Amount.TYPE_QNAME);

    export function type(): TypeDescriptor<Amount> {
      return TYPE.apply();
    }
  }

  export interface CompressedAmount {
    compressed_P: ristretto255.CompressedRistretto[];
    compressed_R_sender: ristretto255.CompressedRistretto[];
    compressed_R_recip: ristretto255.CompressedRistretto[];
    compressed_R_eff_aud: ristretto255.CompressedRistretto[];
    compressed_R_volun_auds: ristretto255.CompressedRistretto[][];
  }

  export namespace CompressedAmount {
    export const TYPE_QNAME = "0x1::confidential_amount::CompressedAmount";

    const TYPE = new TypeDescriptor<CompressedAmount>(
      CompressedAmount.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CompressedAmount> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class governance_proposal extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("governance_proposal", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): governance_proposal {
    return new governance_proposal({
      ...governance_proposal.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEventGovernanceProposal(
    func: (
      event: governance_proposal.GovernanceProposalInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      governance_proposal.GovernanceProposalInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): governance_proposal {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "governance_proposal::GovernanceProposal",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace governance_proposal {
  export interface GovernanceProposal {
    dummy_field: boolean;
  }

  export namespace GovernanceProposal {
    export const TYPE_QNAME = "0x1::governance_proposal::GovernanceProposal";

    const TYPE = new TypeDescriptor<GovernanceProposal>(
      GovernanceProposal.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GovernanceProposal> {
      return TYPE.apply();
    }
  }

  export type GovernanceProposalInstance =
    TypedEventInstance<GovernanceProposal> & {
      data_decoded: GovernanceProposal;
      type_arguments: [];
    };

  export namespace entry {}
  export namespace view {}
}

export namespace optional_aggregator {
  export interface Integer {
    value: bigint;
    limit: bigint;
  }

  export namespace Integer {
    export const TYPE_QNAME = "0x1::optional_aggregator::Integer";

    const TYPE = new TypeDescriptor<Integer>(Integer.TYPE_QNAME);

    export function type(): TypeDescriptor<Integer> {
      return TYPE.apply();
    }
  }

  export interface OptionalAggregator {
    aggregator: option.Option<aggregator.Aggregator>;
    integer: option.Option<optional_aggregator.Integer>;
  }

  export namespace OptionalAggregator {
    export const TYPE_QNAME = "0x1::optional_aggregator::OptionalAggregator";

    const TYPE = new TypeDescriptor<OptionalAggregator>(
      OptionalAggregator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<OptionalAggregator> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class permissioned_signer extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("permissioned_signer", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): permissioned_signer {
    return new permissioned_signer({
      ...permissioned_signer.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryRevokeAllHandles(
    func: (
      call: permissioned_signer.RevokeAllHandlesPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      permissioned_signer.RevokeAllHandlesPayload
    >,
  ): permissioned_signer {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "permissioned_signer::revoke_all_handles",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryRevokePermissionStorageAddress(
    func: (
      call: permissioned_signer.RevokePermissionStorageAddressPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      permissioned_signer.RevokePermissionStorageAddressPayload
    >,
  ): permissioned_signer {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "permissioned_signer::revoke_permission_storage_address",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace permissioned_signer {
  export interface GrantedPermissionHandles {
    active_handles: MoveAddressType[];
  }

  export namespace GrantedPermissionHandles {
    export const TYPE_QNAME =
      "0x1::permissioned_signer::GrantedPermissionHandles";

    const TYPE = new TypeDescriptor<GrantedPermissionHandles>(
      GrantedPermissionHandles.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<GrantedPermissionHandles> {
      return TYPE.apply();
    }
  }

  export interface PermissionStorage {}

  export namespace PermissionStorage {
    export const TYPE_QNAME = "0x1::permissioned_signer::PermissionStorage";

    const TYPE = new TypeDescriptor<PermissionStorage>(
      PermissionStorage.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PermissionStorage> {
      return TYPE.apply();
    }
  }

  export interface PermissionedHandle {}

  export namespace PermissionedHandle {
    export const TYPE_QNAME = "0x1::permissioned_signer::PermissionedHandle";

    const TYPE = new TypeDescriptor<PermissionedHandle>(
      PermissionedHandle.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<PermissionedHandle> {
      return TYPE.apply();
    }
  }

  export interface RevokePermissionHandlePermission {
    dummy_field: boolean;
  }

  export namespace RevokePermissionHandlePermission {
    export const TYPE_QNAME =
      "0x1::permissioned_signer::RevokePermissionHandlePermission";

    const TYPE = new TypeDescriptor<RevokePermissionHandlePermission>(
      RevokePermissionHandlePermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RevokePermissionHandlePermission> {
      return TYPE.apply();
    }
  }

  export interface StorablePermissionedHandle {}

  export namespace StorablePermissionedHandle {
    export const TYPE_QNAME =
      "0x1::permissioned_signer::StorablePermissionedHandle";

    const TYPE = new TypeDescriptor<StorablePermissionedHandle>(
      StorablePermissionedHandle.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StorablePermissionedHandle> {
      return TYPE.apply();
    }
  }

  export interface StoredPermission {}

  export namespace StoredPermission {
    export const TYPE_QNAME = "0x1::permissioned_signer::StoredPermission";

    const TYPE = new TypeDescriptor<StoredPermission>(
      StoredPermission.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<StoredPermission> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function revokeAllHandles(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::permissioned_signer::revoke_all_handles",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function revokePermissionStorageAddress(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [MoveAddressType];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::permissioned_signer::revoke_permission_storage_address",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface RevokeAllHandlesPayload extends TypedFunctionPayload<[]> {
    arguments_decoded: [];
    type_arguments: [];
  }

  export interface RevokePermissionStorageAddressPayload
    extends TypedFunctionPayload<[MoveAddressType]> {
    arguments_decoded: [MoveAddressType];
    type_arguments: [];
  }
}

export class transaction_context extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("transaction_context", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): transaction_context {
    return new transaction_context({
      ...transaction_context.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEventAUID(
    func: (event: transaction_context.AUIDInstance, ctx: AptosContext) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      transaction_context.AUIDInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): transaction_context {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "transaction_context::AUID" },
      handlerOptions,
    );
    return this;
  }
}

export namespace transaction_context {
  export interface AUID {
    unique_address: MoveAddressType;
  }

  export namespace AUID {
    export const TYPE_QNAME = "0x1::transaction_context::AUID";

    const TYPE = new TypeDescriptor<AUID>(AUID.TYPE_QNAME);

    export function type(): TypeDescriptor<AUID> {
      return TYPE.apply();
    }
  }

  export type AUIDInstance = TypedEventInstance<AUID> & {
    data_decoded: AUID;
    type_arguments: [];
  };

  export interface EntryFunctionPayload {
    account_address: MoveAddressType;
    module_name: string;
    function_name: string;
    ty_args_names: string[];
    args: string[];
  }

  export namespace EntryFunctionPayload {
    export const TYPE_QNAME = "0x1::transaction_context::EntryFunctionPayload";

    const TYPE = new TypeDescriptor<EntryFunctionPayload>(
      EntryFunctionPayload.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<EntryFunctionPayload> {
      return TYPE.apply();
    }
  }

  export interface MultisigPayload {
    multisig_address: MoveAddressType;
    entry_function_payload: option.Option<transaction_context.EntryFunctionPayload>;
  }

  export namespace MultisigPayload {
    export const TYPE_QNAME = "0x1::transaction_context::MultisigPayload";

    const TYPE = new TypeDescriptor<MultisigPayload>(
      MultisigPayload.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<MultisigPayload> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace confidential_balance {
  export interface Available {
    dummy_field: boolean;
  }

  export namespace Available {
    export const TYPE_QNAME = "0x1::confidential_balance::Available";

    const TYPE = new TypeDescriptor<Available>(Available.TYPE_QNAME);

    export function type(): TypeDescriptor<Available> {
      return TYPE.apply();
    }
  }

  export interface Balance<T0> {}

  export namespace Balance {
    export const TYPE_QNAME = "0x1::confidential_balance::Balance";

    const TYPE = new TypeDescriptor<Balance<any>>(Balance.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Balance<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface CompressedBalance<T0> {}

  export namespace CompressedBalance {
    export const TYPE_QNAME = "0x1::confidential_balance::CompressedBalance";

    const TYPE = new TypeDescriptor<CompressedBalance<any>>(
      CompressedBalance.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<CompressedBalance<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface Pending {
    dummy_field: boolean;
  }

  export namespace Pending {
    export const TYPE_QNAME = "0x1::confidential_balance::Pending";

    const TYPE = new TypeDescriptor<Pending>(Pending.TYPE_QNAME);

    export function type(): TypeDescriptor<Pending> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {
    export async function getNumAvailableChunks(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_balance::get_num_available_chunks",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_balance::get_num_available_chunks",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function getNumPendingChunks(
      client: Aptos,

      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_balance::get_num_pending_chunks",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_balance::get_num_pending_chunks",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace epoch_timeout_config {
  export interface EpochTimeoutConfig {
    force_end_grace_period_secs: option.Option<bigint>;
  }

  export namespace EpochTimeoutConfig {
    export const TYPE_QNAME = "0x1::epoch_timeout_config::EpochTimeoutConfig";

    const TYPE = new TypeDescriptor<EpochTimeoutConfig>(
      EpochTimeoutConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<EpochTimeoutConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace jwk_consensus_config {
  export interface ConfigOff {
    dummy_field: boolean;
  }

  export namespace ConfigOff {
    export const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigOff";

    const TYPE = new TypeDescriptor<ConfigOff>(ConfigOff.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigOff> {
      return TYPE.apply();
    }
  }

  export interface ConfigV1 {
    oidc_providers: jwk_consensus_config.OIDCProvider[];
  }

  export namespace ConfigV1 {
    export const TYPE_QNAME = "0x1::jwk_consensus_config::ConfigV1";

    const TYPE = new TypeDescriptor<ConfigV1>(ConfigV1.TYPE_QNAME);

    export function type(): TypeDescriptor<ConfigV1> {
      return TYPE.apply();
    }
  }

  export interface OIDCProvider {
    name: string;
    config_url: string;
  }

  export namespace OIDCProvider {
    export const TYPE_QNAME = "0x1::jwk_consensus_config::OIDCProvider";

    const TYPE = new TypeDescriptor<OIDCProvider>(OIDCProvider.TYPE_QNAME);

    export function type(): TypeDescriptor<OIDCProvider> {
      return TYPE.apply();
    }
  }

  export interface JWKConsensusConfig {
    variant: copyable_any.Any;
  }

  export namespace JWKConsensusConfig {
    export const TYPE_QNAME = "0x1::jwk_consensus_config::JWKConsensusConfig";

    const TYPE = new TypeDescriptor<JWKConsensusConfig>(
      JWKConsensusConfig.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<JWKConsensusConfig> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace ristretto255_elgamal {
  export interface Ciphertext {
    left: ristretto255.RistrettoPoint;
    right: ristretto255.RistrettoPoint;
  }

  export namespace Ciphertext {
    export const TYPE_QNAME = "0x1::ristretto255_elgamal::Ciphertext";

    const TYPE = new TypeDescriptor<Ciphertext>(Ciphertext.TYPE_QNAME);

    export function type(): TypeDescriptor<Ciphertext> {
      return TYPE.apply();
    }
  }

  export interface CompressedCiphertext {
    left: ristretto255.CompressedRistretto;
    right: ristretto255.CompressedRistretto;
  }

  export namespace CompressedCiphertext {
    export const TYPE_QNAME = "0x1::ristretto255_elgamal::CompressedCiphertext";

    const TYPE = new TypeDescriptor<CompressedCiphertext>(
      CompressedCiphertext.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CompressedCiphertext> {
      return TYPE.apply();
    }
  }

  export interface CompressedPubkey {
    point: ristretto255.CompressedRistretto;
  }

  export namespace CompressedPubkey {
    export const TYPE_QNAME = "0x1::ristretto255_elgamal::CompressedPubkey";

    const TYPE = new TypeDescriptor<CompressedPubkey>(
      CompressedPubkey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<CompressedPubkey> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_proof {
  export interface Proof {
    comm_A: ristretto255.RistrettoPoint[];
    compressed_comm_A: ristretto255.CompressedRistretto[];
    resp_sigma: ristretto255.Scalar[];
  }

  export namespace Proof {
    export const TYPE_QNAME = "0x1::sigma_protocol_proof::Proof";

    const TYPE = new TypeDescriptor<Proof>(Proof.TYPE_QNAME);

    export function type(): TypeDescriptor<Proof> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_utils {
  export namespace entry {}
  export namespace view {}
}

export namespace reconfiguration_state {
  export interface State {
    variant: copyable_any.Any;
  }

  export namespace State {
    export const TYPE_QNAME = "0x1::reconfiguration_state::State";

    const TYPE = new TypeDescriptor<State>(State.TYPE_QNAME);

    export function type(): TypeDescriptor<State> {
      return TYPE.apply();
    }
  }

  export interface StateActive {
    start_time_secs: bigint;
  }

  export namespace StateActive {
    export const TYPE_QNAME = "0x1::reconfiguration_state::StateActive";

    const TYPE = new TypeDescriptor<StateActive>(StateActive.TYPE_QNAME);

    export function type(): TypeDescriptor<StateActive> {
      return TYPE.apply();
    }
  }

  export interface StateInactive {
    dummy_field: boolean;
  }

  export namespace StateInactive {
    export const TYPE_QNAME = "0x1::reconfiguration_state::StateInactive";

    const TYPE = new TypeDescriptor<StateInactive>(StateInactive.TYPE_QNAME);

    export function type(): TypeDescriptor<StateInactive> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace ristretto255_pedersen {
  export interface Commitment {
    point: ristretto255.RistrettoPoint;
  }

  export namespace Commitment {
    export const TYPE_QNAME = "0x1::ristretto255_pedersen::Commitment";

    const TYPE = new TypeDescriptor<Commitment>(Commitment.TYPE_QNAME);

    export function type(): TypeDescriptor<Commitment> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sui_derivable_account {
  export interface AppId {}

  export namespace AppId {
    export const TYPE_QNAME = "0x1::sui_derivable_account::AppId";

    const TYPE = new TypeDescriptor<AppId>(AppId.TYPE_QNAME);

    export function type(): TypeDescriptor<AppId> {
      return TYPE.apply();
    }
  }

  export interface Intent {
    scope: sui_derivable_account.IntentScope;
    version: sui_derivable_account.IntentVersion;
    app_id: sui_derivable_account.AppId;
  }

  export namespace Intent {
    export const TYPE_QNAME = "0x1::sui_derivable_account::Intent";

    const TYPE = new TypeDescriptor<Intent>(Intent.TYPE_QNAME);

    export function type(): TypeDescriptor<Intent> {
      return TYPE.apply();
    }
  }

  export interface IntentMessage {
    intent: sui_derivable_account.Intent;
    value: string;
  }

  export namespace IntentMessage {
    export const TYPE_QNAME = "0x1::sui_derivable_account::IntentMessage";

    const TYPE = new TypeDescriptor<IntentMessage>(IntentMessage.TYPE_QNAME);

    export function type(): TypeDescriptor<IntentMessage> {
      return TYPE.apply();
    }
  }

  export interface IntentScope {}

  export namespace IntentScope {
    export const TYPE_QNAME = "0x1::sui_derivable_account::IntentScope";

    const TYPE = new TypeDescriptor<IntentScope>(IntentScope.TYPE_QNAME);

    export function type(): TypeDescriptor<IntentScope> {
      return TYPE.apply();
    }
  }

  export interface IntentVersion {}

  export namespace IntentVersion {
    export const TYPE_QNAME = "0x1::sui_derivable_account::IntentVersion";

    const TYPE = new TypeDescriptor<IntentVersion>(IntentVersion.TYPE_QNAME);

    export function type(): TypeDescriptor<IntentVersion> {
      return TYPE.apply();
    }
  }

  export interface SuiAbstractPublicKey {
    sui_account_address: string;
    domain: string;
  }

  export namespace SuiAbstractPublicKey {
    export const TYPE_QNAME =
      "0x1::sui_derivable_account::SuiAbstractPublicKey";

    const TYPE = new TypeDescriptor<SuiAbstractPublicKey>(
      SuiAbstractPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SuiAbstractPublicKey> {
      return TYPE.apply();
    }
  }

  export interface SuiAbstractSignature {}

  export namespace SuiAbstractSignature {
    export const TYPE_QNAME =
      "0x1::sui_derivable_account::SuiAbstractSignature";

    const TYPE = new TypeDescriptor<SuiAbstractSignature>(
      SuiAbstractSignature.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SuiAbstractSignature> {
      return TYPE.apply();
    }
  }

  export interface SuiSigningScheme {}

  export namespace SuiSigningScheme {
    export const TYPE_QNAME = "0x1::sui_derivable_account::SuiSigningScheme";

    const TYPE = new TypeDescriptor<SuiSigningScheme>(
      SuiSigningScheme.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SuiSigningScheme> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class object_code_deployment extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("object_code_deployment", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): object_code_deployment {
    return new object_code_deployment({
      ...object_code_deployment.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryPublish(
    func: (
      call: object_code_deployment.PublishPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object_code_deployment.PublishPayload
    >,
  ): object_code_deployment {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object_code_deployment::publish",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryFreezeCodeObject(
    func: (
      call: object_code_deployment.FreezeCodeObjectPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object_code_deployment.FreezeCodeObjectPayload
    >,
  ): object_code_deployment {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object_code_deployment::freeze_code_object",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryUpgrade(
    func: (
      call: object_code_deployment.UpgradePayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object_code_deployment.UpgradePayload
    >,
  ): object_code_deployment {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "object_code_deployment::upgrade",
      },
      handlerOptions,
    );
    return this;
  }

  onEventFreeze(
    func: (
      event: object_code_deployment.FreezeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object_code_deployment.FreezeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object_code_deployment {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object_code_deployment::Freeze" },
      handlerOptions,
    );
    return this;
  }

  onEventPublish(
    func: (
      event: object_code_deployment.PublishInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object_code_deployment.PublishInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object_code_deployment {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object_code_deployment::Publish" },
      handlerOptions,
    );
    return this;
  }

  onEventUpgrade(
    func: (
      event: object_code_deployment.UpgradeInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      object_code_deployment.UpgradeInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): object_code_deployment {
    this.onMoveEvent(
      func,
      { ...(eventFilter ?? {}), type: "object_code_deployment::Upgrade" },
      handlerOptions,
    );
    return this;
  }
}

export namespace object_code_deployment {
  export interface Freeze {
    object_address: MoveAddressType;
  }

  export namespace Freeze {
    export const TYPE_QNAME = "0x1::object_code_deployment::Freeze";

    const TYPE = new TypeDescriptor<Freeze>(Freeze.TYPE_QNAME);

    export function type(): TypeDescriptor<Freeze> {
      return TYPE.apply();
    }
  }

  export type FreezeInstance = TypedEventInstance<Freeze> & {
    data_decoded: Freeze;
    type_arguments: [];
  };

  export interface ManagingRefs {
    extend_ref: object$.ExtendRef;
  }

  export namespace ManagingRefs {
    export const TYPE_QNAME = "0x1::object_code_deployment::ManagingRefs";

    const TYPE = new TypeDescriptor<ManagingRefs>(ManagingRefs.TYPE_QNAME);

    export function type(): TypeDescriptor<ManagingRefs> {
      return TYPE.apply();
    }
  }

  export interface Publish {
    object_address: MoveAddressType;
  }

  export namespace Publish {
    export const TYPE_QNAME = "0x1::object_code_deployment::Publish";

    const TYPE = new TypeDescriptor<Publish>(Publish.TYPE_QNAME);

    export function type(): TypeDescriptor<Publish> {
      return TYPE.apply();
    }
  }

  export type PublishInstance = TypedEventInstance<Publish> & {
    data_decoded: Publish;
    type_arguments: [];
  };

  export interface Upgrade {
    object_address: MoveAddressType;
  }

  export namespace Upgrade {
    export const TYPE_QNAME = "0x1::object_code_deployment::Upgrade";

    const TYPE = new TypeDescriptor<Upgrade>(Upgrade.TYPE_QNAME);

    export function type(): TypeDescriptor<Upgrade> {
      return TYPE.apply();
    }
  }

  export type UpgradeInstance = TypedEventInstance<Upgrade> & {
    data_decoded: Upgrade;
    type_arguments: [];
  };

  export namespace entry {
    export async function publish(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [string, string[]];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object_code_deployment::publish",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
    export async function freezeCodeObject(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [object$.Object<code.PackageRegistry>];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object_code_deployment::freeze_code_object",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function upgrade(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [];
        functionArguments: [
          string,
          string[],
          object$.Object<code.PackageRegistry>,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::object_code_deployment::upgrade",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: [],
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {}

  export interface PublishPayload
    extends TypedFunctionPayload<[string, string[]]> {
    arguments_decoded: [string, string[]];
    type_arguments: [];
  }

  export interface FreezeCodeObjectPayload
    extends TypedFunctionPayload<[object$.Object<code.PackageRegistry>]> {
    arguments_decoded: [object$.Object<code.PackageRegistry>];
    type_arguments: [];
  }

  export interface UpgradePayload
    extends TypedFunctionPayload<
      [string, string[], object$.Object<code.PackageRegistry>]
    > {
    arguments_decoded: [string, string[], object$.Object<code.PackageRegistry>];
    type_arguments: [];
  }
}

export class primary_fungible_store extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("primary_fungible_store", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(options: Partial<AptosBindOptions> = {}): primary_fungible_store {
    return new primary_fungible_store({
      ...primary_fungible_store.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryTransfer(
    func: (
      call: primary_fungible_store.TransferPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      primary_fungible_store.TransferPayload
    >,
  ): primary_fungible_store {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "primary_fungible_store::transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransferAssertMinimumDeposit(
    func: (
      call: primary_fungible_store.TransferAssertMinimumDepositPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      primary_fungible_store.TransferAssertMinimumDepositPayload
    >,
  ): primary_fungible_store {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "primary_fungible_store::transfer_assert_minimum_deposit",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace primary_fungible_store {
  export interface DeriveRefPod {
    metadata_derive_ref: object$.DeriveRef;
  }

  export namespace DeriveRefPod {
    export const TYPE_QNAME = "0x1::primary_fungible_store::DeriveRefPod";

    const TYPE = new TypeDescriptor<DeriveRefPod>(DeriveRefPod.TYPE_QNAME);

    export function type(): TypeDescriptor<DeriveRefPod> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function transfer<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, MoveAddressType, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::primary_fungible_store::transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function transferAssertMinimumDeposit<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [
          object$.Object<T0>,
          MoveAddressType,
          bigint,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::primary_fungible_store::transfer_assert_minimum_deposit",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function balance<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::primary_fungible_store::balance",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::primary_fungible_store::balance",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function isBalanceAtLeast<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, object$.Object<T0>, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::primary_fungible_store::is_balance_at_least",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::primary_fungible_store::is_balance_at_least",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isFrozen<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::primary_fungible_store::is_frozen",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::primary_fungible_store::is_frozen",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }

    export async function primaryStore<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[object$.Object<fungible_asset.FungibleStore>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::primary_fungible_store::primary_store",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::primary_fungible_store::primary_store",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function primaryStoreAddress<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[MoveAddressType]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::primary_fungible_store::primary_store_address",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::primary_fungible_store::primary_store_address",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function primaryStoreExists<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [MoveAddressType, object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::primary_fungible_store::primary_store_exists",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::primary_fungible_store::primary_store_exists",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface TransferPayload<T0 = any>
    extends TypedFunctionPayload<
      [object$.Object<T0>, MoveAddressType, bigint]
    > {
    arguments_decoded: [object$.Object<T0>, MoveAddressType, bigint];
    type_arguments: [string];
  }

  export interface TransferAssertMinimumDepositPayload<T0 = any>
    extends TypedFunctionPayload<
      [object$.Object<T0>, MoveAddressType, bigint, bigint]
    > {
    arguments_decoded: [object$.Object<T0>, MoveAddressType, bigint, bigint];
    type_arguments: [string];
  }
}

export namespace sigma_protocol_witness {
  export interface Witness {
    w: ristretto255.Scalar[];
  }

  export namespace Witness {
    export const TYPE_QNAME = "0x1::sigma_protocol_witness::Witness";

    const TYPE = new TypeDescriptor<Witness>(Witness.TYPE_QNAME);

    export function type(): TypeDescriptor<Witness> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace storage_slot_or_inline {
  export interface Dummy {
    dummy_field: boolean;
  }

  export namespace Dummy {
    export const TYPE_QNAME = "0x1::storage_slot_or_inline::Dummy";

    const TYPE = new TypeDescriptor<Dummy>(Dummy.TYPE_QNAME);

    export function type(): TypeDescriptor<Dummy> {
      return TYPE.apply();
    }
  }

  export interface StorageSlotOrInline<T0> {}

  export namespace StorageSlotOrInline {
    export const TYPE_QNAME =
      "0x1::storage_slot_or_inline::StorageSlotOrInline";

    const TYPE = new TypeDescriptor<StorageSlotOrInline<any>>(
      StorageSlotOrInline.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<StorageSlotOrInline<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace transaction_validation {
  export interface EpilogueArgs {}

  export namespace EpilogueArgs {
    export const TYPE_QNAME = "0x1::transaction_validation::EpilogueArgs";

    const TYPE = new TypeDescriptor<EpilogueArgs>(EpilogueArgs.TYPE_QNAME);

    export function type(): TypeDescriptor<EpilogueArgs> {
      return TYPE.apply();
    }
  }

  export interface GasPermission {
    dummy_field: boolean;
  }

  export namespace GasPermission {
    export const TYPE_QNAME = "0x1::transaction_validation::GasPermission";

    const TYPE = new TypeDescriptor<GasPermission>(GasPermission.TYPE_QNAME);

    export function type(): TypeDescriptor<GasPermission> {
      return TYPE.apply();
    }
  }

  export interface PrologueArgs {}

  export namespace PrologueArgs {
    export const TYPE_QNAME = "0x1::transaction_validation::PrologueArgs";

    const TYPE = new TypeDescriptor<PrologueArgs>(PrologueArgs.TYPE_QNAME);

    export function type(): TypeDescriptor<PrologueArgs> {
      return TYPE.apply();
    }
  }

  export interface ReplayProtector {}

  export namespace ReplayProtector {
    export const TYPE_QNAME = "0x1::transaction_validation::ReplayProtector";

    const TYPE = new TypeDescriptor<ReplayProtector>(
      ReplayProtector.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ReplayProtector> {
      return TYPE.apply();
    }
  }

  export interface TransactionValidation {
    module_addr: MoveAddressType;
    module_name: string;
    script_prologue_name: string;
    module_prologue_name: string;
    multi_agent_prologue_name: string;
    user_epilogue_name: string;
  }

  export namespace TransactionValidation {
    export const TYPE_QNAME =
      "0x1::transaction_validation::TransactionValidation";

    const TYPE = new TypeDescriptor<TransactionValidation>(
      TransactionValidation.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransactionValidation> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace permissioned_delegation {
  export interface AccountDelegation {}

  export namespace AccountDelegation {
    export const TYPE_QNAME = "0x1::permissioned_delegation::AccountDelegation";

    const TYPE = new TypeDescriptor<AccountDelegation>(
      AccountDelegation.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AccountDelegation> {
      return TYPE.apply();
    }
  }

  export interface DelegationKey {}

  export namespace DelegationKey {
    export const TYPE_QNAME = "0x1::permissioned_delegation::DelegationKey";

    const TYPE = new TypeDescriptor<DelegationKey>(DelegationKey.TYPE_QNAME);

    export function type(): TypeDescriptor<DelegationKey> {
      return TYPE.apply();
    }
  }

  export interface RegisteredDelegations {
    delegations: big_ordered_map.BigOrderedMap<
      permissioned_delegation.DelegationKey,
      permissioned_delegation.AccountDelegation
    >;
  }

  export namespace RegisteredDelegations {
    export const TYPE_QNAME =
      "0x1::permissioned_delegation::RegisteredDelegations";

    const TYPE = new TypeDescriptor<RegisteredDelegations>(
      RegisteredDelegations.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RegisteredDelegations> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_transfer {
  export interface Transfer {
    dummy_field: boolean;
  }

  export namespace Transfer {
    export const TYPE_QNAME = "0x1::sigma_protocol_transfer::Transfer";

    const TYPE = new TypeDescriptor<Transfer>(Transfer.TYPE_QNAME);

    export function type(): TypeDescriptor<Transfer> {
      return TYPE.apply();
    }
  }

  export interface TransferSession {
    sender: MoveAddressType;
    recipient: MoveAddressType;
    asset_type: object$.Object<fungible_asset.Metadata>;
    num_avail_chunks: bigint;
    num_transfer_chunks: bigint;
    has_effective_auditor: boolean;
    num_volun_auditors: bigint;
  }

  export namespace TransferSession {
    export const TYPE_QNAME = "0x1::sigma_protocol_transfer::TransferSession";

    const TYPE = new TypeDescriptor<TransferSession>(
      TransferSession.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransferSession> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_withdraw {
  export interface WithdrawSession {
    sender: MoveAddressType;
    asset_type: object$.Object<fungible_asset.Metadata>;
    num_chunks: bigint;
    has_auditor: boolean;
  }

  export namespace WithdrawSession {
    export const TYPE_QNAME = "0x1::sigma_protocol_withdraw::WithdrawSession";

    const TYPE = new TypeDescriptor<WithdrawSession>(
      WithdrawSession.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<WithdrawSession> {
      return TYPE.apply();
    }
  }

  export interface Withdrawal {
    dummy_field: boolean;
  }

  export namespace Withdrawal {
    export const TYPE_QNAME = "0x1::sigma_protocol_withdraw::Withdrawal";

    const TYPE = new TypeDescriptor<Withdrawal>(Withdrawal.TYPE_QNAME);

    export function type(): TypeDescriptor<Withdrawal> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace storage_slots_allocator {
  export interface Link<T0> {}

  export namespace Link {
    export const TYPE_QNAME = "0x1::storage_slots_allocator::Link";

    const TYPE = new TypeDescriptor<Link<any>>(Link.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Link<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface ReservedSlot {
    slot_index: bigint;
  }

  export namespace ReservedSlot {
    export const TYPE_QNAME = "0x1::storage_slots_allocator::ReservedSlot";

    const TYPE = new TypeDescriptor<ReservedSlot>(ReservedSlot.TYPE_QNAME);

    export function type(): TypeDescriptor<ReservedSlot> {
      return TYPE.apply();
    }
  }

  export interface StorageSlotsAllocator<T0> {}

  export namespace StorageSlotsAllocator {
    export const TYPE_QNAME =
      "0x1::storage_slots_allocator::StorageSlotsAllocator";

    const TYPE = new TypeDescriptor<StorageSlotsAllocator<any>>(
      StorageSlotsAllocator.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<StorageSlotsAllocator<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface StoredSlot {
    slot_index: bigint;
  }

  export namespace StoredSlot {
    export const TYPE_QNAME = "0x1::storage_slots_allocator::StoredSlot";

    const TYPE = new TypeDescriptor<StoredSlot>(StoredSlot.TYPE_QNAME);

    export function type(): TypeDescriptor<StoredSlot> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace chunky_dkg_config_seqnum {
  export interface ChunkyDKGConfigSeqNum {
    seq_num: bigint;
  }

  export namespace ChunkyDKGConfigSeqNum {
    export const TYPE_QNAME =
      "0x1::chunky_dkg_config_seqnum::ChunkyDKGConfigSeqNum";

    const TYPE = new TypeDescriptor<ChunkyDKGConfigSeqNum>(
      ChunkyDKGConfigSeqNum.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ChunkyDKGConfigSeqNum> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace randomness_api_v0_config {
  export interface AllowCustomMaxGasFlag {
    value: boolean;
  }

  export namespace AllowCustomMaxGasFlag {
    export const TYPE_QNAME =
      "0x1::randomness_api_v0_config::AllowCustomMaxGasFlag";

    const TYPE = new TypeDescriptor<AllowCustomMaxGasFlag>(
      AllowCustomMaxGasFlag.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<AllowCustomMaxGasFlag> {
      return TYPE.apply();
    }
  }

  export interface RequiredGasDeposit {
    gas_amount: option.Option<bigint>;
  }

  export namespace RequiredGasDeposit {
    export const TYPE_QNAME =
      "0x1::randomness_api_v0_config::RequiredGasDeposit";

    const TYPE = new TypeDescriptor<RequiredGasDeposit>(
      RequiredGasDeposit.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RequiredGasDeposit> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace randomness_config_seqnum {
  export interface RandomnessConfigSeqNum {
    seq_num: bigint;
  }

  export namespace RandomnessConfigSeqNum {
    export const TYPE_QNAME =
      "0x1::randomness_config_seqnum::RandomnessConfigSeqNum";

    const TYPE = new TypeDescriptor<RandomnessConfigSeqNum>(
      RandomnessConfigSeqNum.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RandomnessConfigSeqNum> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class reconfiguration_with_dkg extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("reconfiguration_with_dkg", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(
    options: Partial<AptosBindOptions> = {},
  ): reconfiguration_with_dkg {
    return new reconfiguration_with_dkg({
      ...reconfiguration_with_dkg.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEventForceEndEpochEvent(
    func: (
      event: reconfiguration_with_dkg.ForceEndEpochEventInstance,
      ctx: AptosContext,
    ) => void,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      reconfiguration_with_dkg.ForceEndEpochEventInstance
    >,
    eventFilter?: Omit<EventFilter, "type" | "account">,
  ): reconfiguration_with_dkg {
    this.onMoveEvent(
      func,
      {
        ...(eventFilter ?? {}),
        type: "reconfiguration_with_dkg::ForceEndEpochEvent",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace reconfiguration_with_dkg {
  export interface ForceEndEpochEvent {}

  export namespace ForceEndEpochEvent {
    export const TYPE_QNAME =
      "0x1::reconfiguration_with_dkg::ForceEndEpochEvent";

    const TYPE = new TypeDescriptor<ForceEndEpochEvent>(
      ForceEndEpochEvent.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ForceEndEpochEvent> {
      return TYPE.apply();
    }
  }

  export type ForceEndEpochEventInstance =
    TypedEventInstance<ForceEndEpochEvent> & {
      data_decoded: ForceEndEpochEvent;
      type_arguments: [];
    };

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_statement {
  export interface Statement<T0> {
    points: ristretto255.RistrettoPoint[];
    compressed_points: ristretto255.CompressedRistretto[];
    scalars: ristretto255.Scalar[];
  }

  export namespace Statement {
    export const TYPE_QNAME = "0x1::sigma_protocol_statement::Statement";

    const TYPE = new TypeDescriptor<Statement<any>>(Statement.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Statement<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace solana_derivable_account {
  export interface SIWSAbstractSignature {}

  export namespace SIWSAbstractSignature {
    export const TYPE_QNAME =
      "0x1::solana_derivable_account::SIWSAbstractSignature";

    const TYPE = new TypeDescriptor<SIWSAbstractSignature>(
      SIWSAbstractSignature.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SIWSAbstractSignature> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace validator_consensus_info {
  export interface ValidatorConsensusInfo {
    addr: MoveAddressType;
    pk_bytes: string;
    voting_power: bigint;
  }

  export namespace ValidatorConsensusInfo {
    export const TYPE_QNAME =
      "0x1::validator_consensus_info::ValidatorConsensusInfo";

    const TYPE = new TypeDescriptor<ValidatorConsensusInfo>(
      ValidatorConsensusInfo.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<ValidatorConsensusInfo> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace confidential_range_proofs {
  export namespace entry {}
  export namespace view {
    export async function getBulletproofsDst(
      client: Aptos,

      version?: bigint,
    ): Promise<[string]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::confidential_range_proofs::get_bulletproofs_dst",
        functionArguments: [],
        typeArguments: [],
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::confidential_range_proofs::get_bulletproofs_dst",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }
}

export namespace ristretto255_bulletproofs {
  export interface RangeProof {
    bytes: string;
  }

  export namespace RangeProof {
    export const TYPE_QNAME = "0x1::ristretto255_bulletproofs::RangeProof";

    const TYPE = new TypeDescriptor<RangeProof>(RangeProof.TYPE_QNAME);

    export function type(): TypeDescriptor<RangeProof> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace ethereum_derivable_account {
  export interface SIWEAbstractPublicKey {
    ethereum_address: string;
    domain: string;
  }

  export namespace SIWEAbstractPublicKey {
    export const TYPE_QNAME =
      "0x1::ethereum_derivable_account::SIWEAbstractPublicKey";

    const TYPE = new TypeDescriptor<SIWEAbstractPublicKey>(
      SIWEAbstractPublicKey.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SIWEAbstractPublicKey> {
      return TYPE.apply();
    }
  }

  export interface SIWEAbstractSignature {}

  export namespace SIWEAbstractSignature {
    export const TYPE_QNAME =
      "0x1::ethereum_derivable_account::SIWEAbstractSignature";

    const TYPE = new TypeDescriptor<SIWEAbstractSignature>(
      SIWEAbstractSignature.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<SIWEAbstractSignature> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_fiat_shamir {
  export interface DomainSeparator {}

  export namespace DomainSeparator {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_fiat_shamir::DomainSeparator";

    const TYPE = new TypeDescriptor<DomainSeparator>(
      DomainSeparator.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<DomainSeparator> {
      return TYPE.apply();
    }
  }

  export interface FiatShamirInputs {
    dst: sigma_protocol_fiat_shamir.DomainSeparator;
    type_name: string;
    k: bigint;
    stmt_X: ristretto255.CompressedRistretto[];
    stmt_x: ristretto255.Scalar[];
    proof_A: ristretto255.CompressedRistretto[];
  }

  export namespace FiatShamirInputs {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_fiat_shamir::FiatShamirInputs";

    const TYPE = new TypeDescriptor<FiatShamirInputs>(
      FiatShamirInputs.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<FiatShamirInputs> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export class dispatchable_fungible_asset extends AptosBaseProcessor {
  constructor(options: AptosBindOptions) {
    super("dispatchable_fungible_asset", options);
  }
  static DEFAULT_OPTIONS: AptosBindOptions = {
    address: "0x1",
    network: AptosNetwork.MAIN_NET,
  };

  static bind(
    options: Partial<AptosBindOptions> = {},
  ): dispatchable_fungible_asset {
    return new dispatchable_fungible_asset({
      ...dispatchable_fungible_asset.DEFAULT_OPTIONS,
      ...options,
    });
  }

  onEntryTransfer(
    func: (
      call: dispatchable_fungible_asset.TransferPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      dispatchable_fungible_asset.TransferPayload
    >,
  ): dispatchable_fungible_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function: "dispatchable_fungible_asset::transfer",
      },
      handlerOptions,
    );
    return this;
  }

  onEntryTransferAssertMinimumDeposit(
    func: (
      call: dispatchable_fungible_asset.TransferAssertMinimumDepositPayload,
      ctx: AptosContext,
    ) => void,
    filter?: CallFilter,
    handlerOptions?: HandlerOptions<
      MoveFetchConfig,
      dispatchable_fungible_asset.TransferAssertMinimumDepositPayload
    >,
  ): dispatchable_fungible_asset {
    this.onEntryFunctionCall(
      func,
      {
        ...filter,
        function:
          "dispatchable_fungible_asset::transfer_assert_minimum_deposit",
      },
      handlerOptions,
    );
    return this;
  }
}

export namespace dispatchable_fungible_asset {
  export interface TransferRefStore {
    transfer_ref: fungible_asset.TransferRef;
  }

  export namespace TransferRefStore {
    export const TYPE_QNAME =
      "0x1::dispatchable_fungible_asset::TransferRefStore";

    const TYPE = new TypeDescriptor<TransferRefStore>(
      TransferRefStore.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<TransferRefStore> {
      return TYPE.apply();
    }
  }

  export namespace entry {
    export async function transfer<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, object$.Object<T0>, bigint];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function: "0x1::dispatchable_fungible_asset::transfer",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }

    export async function transferAssertMinimumDeposit<T0 = any>(
      client: Aptos,
      account: AptosAccount,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [
          object$.Object<T0>,
          object$.Object<T0>,
          bigint,
          bigint,
        ];
      },
      options?: InputGenerateTransactionOptions,
    ): Promise<PendingTransactionResponse> {
      const coder = defaultMoveCoderForClient(client);
      const transaction = await client.transaction.build.simple({
        sender: account.accountAddress,
        data: {
          function:
            "0x1::dispatchable_fungible_asset::transfer_assert_minimum_deposit",
          functionArguments: coder.encodeArray(request.functionArguments),
          typeArguments: request.typeArguments,
        },
        options,
      });
      return await client.signAndSubmitTransaction({
        signer: account,
        transaction,
      });
    }
  }
  export namespace view {
    export async function derivedBalance<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[bigint]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::dispatchable_fungible_asset::derived_balance",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::dispatchable_fungible_asset::derived_balance",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function derivedSupply<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>];
      },
      version?: bigint,
    ): Promise<[option.Option<bigint>]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function: "0x1::dispatchable_fungible_asset::derived_supply",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::dispatchable_fungible_asset::derived_supply",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
    export async function isDerivedBalanceAtLeast<T0 = any>(
      client: Aptos,
      request: {
        typeArguments: [MoveStructId];
        functionArguments: [object$.Object<T0>, bigint];
      },
      version?: bigint,
    ): Promise<[boolean]> {
      const coder = defaultMoveCoderForClient(client);
      const data: InputViewFunctionData = {
        function:
          "0x1::dispatchable_fungible_asset::is_derived_balance_at_least",
        functionArguments: coder.encodeArray(request.functionArguments),
        typeArguments: request.typeArguments,
      };
      const res = await client.view({
        payload: data,
        options: { ledgerVersion: version },
      });
      const type = await coder.getMoveFunction(
        "0x1::dispatchable_fungible_asset::is_derived_balance_at_least",
      );
      return (await coder.decodeArray(res, type.return)) as any;
    }
  }

  export interface TransferPayload<T0 = any>
    extends TypedFunctionPayload<
      [object$.Object<T0>, object$.Object<T0>, bigint]
    > {
    arguments_decoded: [object$.Object<T0>, object$.Object<T0>, bigint];
    type_arguments: [string];
  }

  export interface TransferAssertMinimumDepositPayload<T0 = any>
    extends TypedFunctionPayload<
      [object$.Object<T0>, object$.Object<T0>, bigint, bigint]
    > {
    arguments_decoded: [object$.Object<T0>, object$.Object<T0>, bigint, bigint];
    type_arguments: [string];
  }
}

export namespace sigma_protocol_homomorphism {
  export interface Homomorphism<T0> {
    _0: unknown;
  }

  export namespace Homomorphism {
    export const TYPE_QNAME = "0x1::sigma_protocol_homomorphism::Homomorphism";

    const TYPE = new TypeDescriptor<Homomorphism<any>>(Homomorphism.TYPE_QNAME);

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<Homomorphism<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export interface TransformationFunction<T0> {
    _0: unknown;
  }

  export namespace TransformationFunction {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_homomorphism::TransformationFunction";

    const TYPE = new TypeDescriptor<TransformationFunction<any>>(
      TransformationFunction.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<TransformationFunction<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_key_rotation {
  export interface KeyRotation {
    dummy_field: boolean;
  }

  export namespace KeyRotation {
    export const TYPE_QNAME = "0x1::sigma_protocol_key_rotation::KeyRotation";

    const TYPE = new TypeDescriptor<KeyRotation>(KeyRotation.TYPE_QNAME);

    export function type(): TypeDescriptor<KeyRotation> {
      return TYPE.apply();
    }
  }

  export interface KeyRotationSession {
    sender: MoveAddressType;
    token_type: object$.Object<fungible_asset.Metadata>;
    num_chunks: bigint;
  }

  export namespace KeyRotationSession {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_key_rotation::KeyRotationSession";

    const TYPE = new TypeDescriptor<KeyRotationSession>(
      KeyRotationSession.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<KeyRotationSession> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_registration {
  export interface Registration {
    dummy_field: boolean;
  }

  export namespace Registration {
    export const TYPE_QNAME = "0x1::sigma_protocol_registration::Registration";

    const TYPE = new TypeDescriptor<Registration>(Registration.TYPE_QNAME);

    export function type(): TypeDescriptor<Registration> {
      return TYPE.apply();
    }
  }

  export interface RegistrationSession {
    sender: MoveAddressType;
    asset_type: object$.Object<fungible_asset.Metadata>;
  }

  export namespace RegistrationSession {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_registration::RegistrationSession";

    const TYPE = new TypeDescriptor<RegistrationSession>(
      RegistrationSession.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RegistrationSession> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_representation {
  export interface Representation {
    point_idxs: bigint[];
    scalars: ristretto255.Scalar[];
  }

  export namespace Representation {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_representation::Representation";

    const TYPE = new TypeDescriptor<Representation>(Representation.TYPE_QNAME);

    export function type(): TypeDescriptor<Representation> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_statement_builder {
  export interface StatementBuilder<T0> {
    points: ristretto255.RistrettoPoint[];
    compressed_points: ristretto255.CompressedRistretto[];
    scalars: ristretto255.Scalar[];
  }

  export namespace StatementBuilder {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_statement_builder::StatementBuilder";

    const TYPE = new TypeDescriptor<StatementBuilder<any>>(
      StatementBuilder.TYPE_QNAME,
    );

    export function type<T0>(
      arg0: TypeDescriptor<T0> = ANY_TYPE,
    ): TypeDescriptor<StatementBuilder<T0>> {
      return TYPE.apply(arg0);
    }
  }

  export namespace entry {}
  export namespace view {}
}

export namespace common_account_abstractions_utils {
  export namespace entry {}
  export namespace view {}
}

export namespace sigma_protocol_representation_vec {
  export interface RepresentationVec {
    v: sigma_protocol_representation.Representation[];
  }

  export namespace RepresentationVec {
    export const TYPE_QNAME =
      "0x1::sigma_protocol_representation_vec::RepresentationVec";

    const TYPE = new TypeDescriptor<RepresentationVec>(
      RepresentationVec.TYPE_QNAME,
    );

    export function type(): TypeDescriptor<RepresentationVec> {
      return TYPE.apply();
    }
  }

  export namespace entry {}
  export namespace view {}
}

const MODULES = JSON.parse(
  '[{"abi":{"address":"0x1","name":"acl","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::acl::ACL","address"],"return":["bool"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::acl::ACL","address"],"return":[]},{"name":"empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::acl::ACL"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::acl::ACL","address"],"return":[]},{"name":"assert_contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::acl::ACL","address"],"return":[]}],"structs":[{"name":"ACL","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"list","type":"vector<address>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"any","friends":["0x1::copyable_any"],"exposed_functions":[{"name":"type_name","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::any::Any"],"return":["&0x1::string::String"]},{"name":"pack","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["T0"],"return":["0x1::any::Any"]},{"name":"unpack","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::any::Any"],"return":["T0"]}],"structs":[{"name":"Any","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"type_name","type":"0x1::string::String"},{"name":"data","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"bcs","friends":[],"exposed_functions":[{"name":"constant_serialized_size","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::option::Option<u64>"]},{"name":"serialized_size","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["u64"]},{"name":"to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["vector<u8>"]}],"structs":[]}},{"abi":{"address":"0x1","name":"cmp","friends":[],"exposed_functions":[{"name":"compare","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0","&T0"],"return":["0x1::cmp::Ordering"]},{"name":"is_eq","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::cmp::Ordering"],"return":["bool"]},{"name":"is_ge","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::cmp::Ordering"],"return":["bool"]},{"name":"is_gt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::cmp::Ordering"],"return":["bool"]},{"name":"is_le","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::cmp::Ordering"],"return":["bool"]},{"name":"is_lt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::cmp::Ordering"],"return":["bool"]},{"name":"is_ne","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::cmp::Ordering"],"return":["bool"]}],"structs":[{"name":"Ordering","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"Less","fields":[]},{"name":"Equal","fields":[]},{"name":"Greater","fields":[]}]}]}},{"abi":{"address":"0x1","name":"dkg","friends":["0x1::reconfiguration_with_dkg","0x1::block"],"exposed_functions":[{"name":"start","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","0x1::randomness_config::RandomnessConfig","vector<0x1::validator_consensus_info::ValidatorConsensusInfo>","vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"finish","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":[]},{"name":"incomplete_session","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<0x1::dkg::DKGSessionState>"]},{"name":"is_session_started","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["bool"]},{"name":"last_completed_session","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<0x1::dkg::DKGSessionState>"]},{"name":"session_dealer_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::dkg::DKGSessionState"],"return":["u64"]},{"name":"try_clear_incomplete_session","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]}],"structs":[{"name":"DKGSessionMetadata","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dealer_epoch","type":"u64"},{"name":"randomness_config","type":"0x1::randomness_config::RandomnessConfig"},{"name":"dealer_validator_set","type":"vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"},{"name":"target_validator_set","type":"vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"}],"variants":[]},{"name":"DKGSessionState","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::dkg::DKGSessionMetadata"},{"name":"start_time_us","type":"u64"},{"name":"transcript","type":"vector<u8>"}],"variants":[]},{"name":"DKGStartEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"session_metadata","type":"0x1::dkg::DKGSessionMetadata"},{"name":"start_time_us","type":"u64"}],"variants":[]},{"name":"DKGState","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"last_completed","type":"0x1::option::Option<0x1::dkg::DKGSessionState>"},{"name":"in_progress","type":"0x1::option::Option<0x1::dkg::DKGSessionState>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"mem","friends":[],"exposed_functions":[{"name":"replace","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut T0","T0"],"return":["T0"]},{"name":"swap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut T0","&mut T0"],"return":[]}],"structs":[]}},{"abi":{"address":"0x1","name":"code","friends":["0x1::object_code_deployment"],"exposed_functions":[{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"can_change_upgrade_policy_to","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::code::UpgradePolicy","0x1::code::UpgradePolicy"],"return":["bool"]},{"name":"check_code_publishing_permission","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"freeze_code_object","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::code::PackageRegistry>"],"return":[]},{"name":"publish_package","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::code::PackageMetadata","vector<vector<u8>>"],"return":[]},{"name":"publish_package_txn","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<vector<u8>>"],"return":[]},{"name":"upgrade_policy_arbitrary","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::code::UpgradePolicy"]},{"name":"upgrade_policy_compat","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::code::UpgradePolicy"]},{"name":"upgrade_policy_immutable","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::code::UpgradePolicy"]}],"structs":[{"name":"AllowedDep","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"module_name","type":"0x1::string::String"}],"variants":[]},{"name":"CodePublishingPermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"ModuleMetadata","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"name","type":"0x1::string::String"},{"name":"source","type":"vector<u8>"},{"name":"source_map","type":"vector<u8>"},{"name":"extension","type":"0x1::option::Option<0x1::copyable_any::Any>"}],"variants":[]},{"name":"PackageDep","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"package_name","type":"0x1::string::String"}],"variants":[]},{"name":"PackageMetadata","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"name","type":"0x1::string::String"},{"name":"upgrade_policy","type":"0x1::code::UpgradePolicy"},{"name":"upgrade_number","type":"u64"},{"name":"source_digest","type":"0x1::string::String"},{"name":"manifest","type":"vector<u8>"},{"name":"modules","type":"vector<0x1::code::ModuleMetadata>"},{"name":"deps","type":"vector<0x1::code::PackageDep>"},{"name":"extension","type":"0x1::option::Option<0x1::copyable_any::Any>"}],"variants":[]},{"name":"PackageRegistry","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"packages","type":"vector<0x1::code::PackageMetadata>"}],"variants":[]},{"name":"PublishPackage","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"code_address","type":"address"},{"name":"is_upgrade","type":"bool"}],"variants":[]},{"name":"UpgradePolicy","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"policy","type":"u8"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"coin","friends":["0x1::aptos_coin","0x1::transaction_fee","0x1::genesis"],"exposed_functions":[{"name":"extract","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::coin::Coin<T0>","u64"],"return":["0x1::coin::Coin<T0>"]},{"name":"value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::coin::Coin<T0>"],"return":["u64"]},{"name":"merge","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::coin::Coin<T0>","0x1::coin::Coin<T0>"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","0x1::string::String","0x1::string::String","u8","bool"],"return":["0x1::coin::BurnCapability<T0>","0x1::coin::FreezeCapability<T0>","0x1::coin::MintCapability<T0>"]},{"name":"burn","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::coin::Coin<T0>","&0x1::coin::BurnCapability<T0>"],"return":[]},{"name":"name","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::string::String"]},{"name":"transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","address","u64"],"return":[]},{"name":"symbol","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::string::String"]},{"name":"decimals","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["u8"]},{"name":"balance","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":["address"],"return":["u64"]},{"name":"burn_from","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","u64","&0x1::coin::BurnCapability<T0>"],"return":[]},{"name":"deposit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","0x1::coin::Coin<T0>"],"return":[]},{"name":"destroy_zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::coin::Coin<T0>"],"return":[]},{"name":"is_balance_at_least","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":["address","u64"],"return":["bool"]},{"name":"mint","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["u64","&0x1::coin::MintCapability<T0>"],"return":["0x1::coin::Coin<T0>"]},{"name":"supply","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::option::Option<u128>"]},{"name":"withdraw","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","u64"],"return":["0x1::coin::Coin<T0>"]},{"name":"zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::coin::Coin<T0>"]},{"name":"deposit_with_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","0x1::coin::Coin<T0>"],"return":[]},{"name":"allow_supply_upgrades","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]},{"name":"burn_from_for_gas","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","u64","&0x1::coin::BurnCapability<T0>"],"return":[]},{"name":"coin_supply","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::option::Option<u128>"]},{"name":"coin_to_fungible_asset","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::coin::Coin<T0>"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"convert_and_take_paired_burn_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::coin::BurnCapability<T0>"],"return":["0x1::fungible_asset::BurnRef"]},{"name":"create_coin_conversion_map","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"create_pairing","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer"],"return":[]},{"name":"deposit_for_gas_fee","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","0x1::coin::Coin<T0>"],"return":[]},{"name":"destroy_burn_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::coin::BurnCapability<T0>"],"return":[]},{"name":"destroy_freeze_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::coin::FreezeCapability<T0>"],"return":[]},{"name":"destroy_mint_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::coin::MintCapability<T0>"],"return":[]},{"name":"ensure_paired_metadata","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"extract_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::coin::Coin<T0>"],"return":["0x1::coin::Coin<T0>"]},{"name":"freeze_coin_store","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","&0x1::coin::FreezeCapability<T0>"],"return":[]},{"name":"get_paired_burn_copy_ref","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::coin::BurnCapability<T0>"],"return":["0x1::fungible_asset::BurnRef"]},{"name":"get_paired_burn_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::coin::BurnCapability<T0>"],"return":["0x1::fungible_asset::BurnRef","0x1::coin::BurnRefReceipt"]},{"name":"get_paired_mint_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::coin::MintCapability<T0>"],"return":["0x1::fungible_asset::MintRef","0x1::coin::MintRefReceipt"]},{"name":"get_paired_transfer_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::coin::FreezeCapability<T0>"],"return":["0x1::fungible_asset::TransferRef","0x1::coin::TransferRefReceipt"]},{"name":"initialize_with_parallelizable_supply","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","0x1::string::String","0x1::string::String","u8","bool"],"return":["0x1::coin::BurnCapability<T0>","0x1::coin::FreezeCapability<T0>","0x1::coin::MintCapability<T0>"]},{"name":"is_account_registered","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":["address"],"return":["bool"]},{"name":"is_coin_initialized","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["bool"]},{"name":"is_coin_store_frozen","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":["address"],"return":["bool"]},{"name":"migrate_coin_store_to_fungible_store","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["vector<address>"],"return":[]},{"name":"migrate_to_fungible_store","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer"],"return":[]},{"name":"paired_burn_ref_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["bool"]},{"name":"paired_coin","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::option::Option<0x1::type_info::TypeInfo>"]},{"name":"paired_metadata","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::option::Option<0x1::object::Object<0x1::fungible_asset::Metadata>>"]},{"name":"paired_mint_ref_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["bool"]},{"name":"paired_transfer_ref_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":[]}],"params":[],"return":["bool"]},{"name":"register","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer"],"return":[]},{"name":"return_paired_burn_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fungible_asset::BurnRef","0x1::coin::BurnRefReceipt"],"return":[]},{"name":"return_paired_mint_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fungible_asset::MintRef","0x1::coin::MintRefReceipt"],"return":[]},{"name":"return_paired_transfer_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fungible_asset::TransferRef","0x1::coin::TransferRefReceipt"],"return":[]},{"name":"unfreeze_coin_store","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","&0x1::coin::FreezeCapability<T0>"],"return":[]},{"name":"upgrade_supply","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer"],"return":[]}],"structs":[{"name":"Deposit","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"account","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"DepositEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"amount","type":"u64"}],"variants":[]},{"name":"Withdraw","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"account","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"WithdrawEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"amount","type":"u64"}],"variants":[]},{"name":"AggregatableCoin","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"value","type":"0x1::aggregator::Aggregator"}],"variants":[]},{"name":"BurnCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"BurnRefReceipt","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"Coin","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"value","type":"u64"}],"variants":[]},{"name":"CoinConversionMap","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"coin_to_fungible_asset_map","type":"0x1::table::Table<0x1::type_info::TypeInfo, 0x1::object::Object<0x1::fungible_asset::Metadata>>"}],"variants":[]},{"name":"CoinDeposit","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"coin_type","type":"0x1::string::String"},{"name":"account","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"CoinEventHandleDeletion","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"event_handle_creation_address","type":"address"},{"name":"deleted_deposit_event_handle_creation_number","type":"u64"},{"name":"deleted_withdraw_event_handle_creation_number","type":"u64"}],"variants":[]},{"name":"CoinInfo","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"name","type":"0x1::string::String"},{"name":"symbol","type":"0x1::string::String"},{"name":"decimals","type":"u8"},{"name":"supply","type":"0x1::option::Option<0x1::optional_aggregator::OptionalAggregator>"}],"variants":[]},{"name":"CoinStore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"coin","type":"0x1::coin::Coin<T0>"},{"name":"frozen","type":"bool"},{"name":"deposit_events","type":"0x1::event::EventHandle<0x1::coin::DepositEvent>"},{"name":"withdraw_events","type":"0x1::event::EventHandle<0x1::coin::WithdrawEvent>"}],"variants":[]},{"name":"CoinStoreDeletion","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"coin_type","type":"0x1::string::String"},{"name":"event_handle_creation_address","type":"address"},{"name":"deleted_deposit_event_handle_creation_number","type":"u64"},{"name":"deleted_withdraw_event_handle_creation_number","type":"u64"}],"variants":[]},{"name":"CoinWithdraw","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"coin_type","type":"0x1::string::String"},{"name":"account","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"FreezeCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"MigrationFlag","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"MintCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"MintRefReceipt","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"PairCreation","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"coin_type","type":"0x1::type_info::TypeInfo"},{"name":"fungible_asset_metadata_address","type":"address"}],"variants":[]},{"name":"PairedCoinType","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"type","type":"0x1::type_info::TypeInfo"}],"variants":[]},{"name":"PairedFungibleAssetRefs","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"mint_ref_opt","type":"0x1::option::Option<0x1::fungible_asset::MintRef>"},{"name":"transfer_ref_opt","type":"0x1::option::Option<0x1::fungible_asset::TransferRef>"},{"name":"burn_ref_opt","type":"0x1::option::Option<0x1::fungible_asset::BurnRef>"}],"variants":[]},{"name":"SupplyConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"allow_upgrades","type":"bool"}],"variants":[]},{"name":"TransferRefReceipt","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"guid","friends":["0x1::account","0x1::object"],"exposed_functions":[{"name":"create","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","&mut u64"],"return":["0x1::guid::GUID"]},{"name":"create_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":["0x1::guid::ID"]},{"name":"creation_num","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::guid::GUID"],"return":["u64"]},{"name":"creator_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::guid::GUID"],"return":["address"]},{"name":"eq_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::guid::GUID","&0x1::guid::ID"],"return":["bool"]},{"name":"id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::guid::GUID"],"return":["0x1::guid::ID"]},{"name":"id_creation_num","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::guid::ID"],"return":["u64"]},{"name":"id_creator_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::guid::ID"],"return":["address"]}],"structs":[{"name":"GUID","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"0x1::guid::ID"}],"variants":[]},{"name":"ID","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"creation_num","type":"u64"},{"name":"addr","type":"address"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"hash","friends":[],"exposed_functions":[{"name":"sha2_256","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"sha3_256","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]}],"structs":[]}},{"abi":{"address":"0x1","name":"jwks","friends":["0x1::reconfiguration_with_dkg","0x1::genesis"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"get_patched_jwk","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","vector<u8>"],"return":["0x1::jwks::JWK"]},{"name":"initialize_with_defaults","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<0x1::jwks::OIDCProvider>","vector<0x1::jwks::Patch>"],"return":[]},{"name":"new_patch_remove_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::jwks::Patch"]},{"name":"new_patch_remove_issuer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::jwks::Patch"]},{"name":"new_patch_remove_jwk","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","vector<u8>"],"return":["0x1::jwks::Patch"]},{"name":"new_patch_upsert_jwk","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","0x1::jwks::JWK"],"return":["0x1::jwks::Patch"]},{"name":"new_rsa_jwk","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::string::String","0x1::string::String","0x1::string::String","0x1::string::String"],"return":["0x1::jwks::JWK"]},{"name":"new_unsupported_jwk","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","vector<u8>"],"return":["0x1::jwks::JWK"]},{"name":"patch_federated_jwks","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<0x1::jwks::Patch>"],"return":[]},{"name":"remove_issuer_from_observed_jwks","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":["0x1::option::Option<0x1::jwks::ProviderJWKs>"]},{"name":"remove_oidc_provider","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":["0x1::option::Option<vector<u8>>"]},{"name":"remove_oidc_provider_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":["0x1::option::Option<vector<u8>>"]},{"name":"set_patches","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<0x1::jwks::Patch>"],"return":[]},{"name":"try_get_patched_jwk","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","vector<u8>"],"return":["0x1::option::Option<0x1::jwks::JWK>"]},{"name":"update_federated_jwk_set","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<0x1::string::String>","vector<0x1::string::String>","vector<0x1::string::String>","vector<0x1::string::String>"],"return":[]},{"name":"upsert_into_observed_jwks","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<0x1::jwks::ProviderJWKs>"],"return":[]},{"name":"upsert_oidc_provider","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>"],"return":["0x1::option::Option<vector<u8>>"]},{"name":"upsert_oidc_provider_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>"],"return":["0x1::option::Option<vector<u8>>"]}],"structs":[{"name":"AllProvidersJWKs","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"entries","type":"vector<0x1::jwks::ProviderJWKs>"}],"variants":[]},{"name":"FederatedJWKs","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","key"],"generic_type_params":[],"fields":[{"name":"jwks","type":"0x1::jwks::AllProvidersJWKs"}],"variants":[]},{"name":"JWK","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"variant","type":"0x1::copyable_any::Any"}],"variants":[]},{"name":"OIDCProvider","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"name","type":"vector<u8>"},{"name":"config_url","type":"vector<u8>"}],"variants":[]},{"name":"ObservedJWKs","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"jwks","type":"0x1::jwks::AllProvidersJWKs"}],"variants":[]},{"name":"ObservedJWKsUpdated","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"},{"name":"jwks","type":"0x1::jwks::AllProvidersJWKs"}],"variants":[]},{"name":"Patch","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"variant","type":"0x1::copyable_any::Any"}],"variants":[]},{"name":"PatchRemoveAll","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"PatchRemoveIssuer","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"issuer","type":"vector<u8>"}],"variants":[]},{"name":"PatchRemoveJWK","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"issuer","type":"vector<u8>"},{"name":"jwk_id","type":"vector<u8>"}],"variants":[]},{"name":"PatchUpsertJWK","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"issuer","type":"vector<u8>"},{"name":"jwk","type":"0x1::jwks::JWK"}],"variants":[]},{"name":"PatchedJWKs","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","key"],"generic_type_params":[],"fields":[{"name":"jwks","type":"0x1::jwks::AllProvidersJWKs"}],"variants":[]},{"name":"Patches","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"patches","type":"vector<0x1::jwks::Patch>"}],"variants":[]},{"name":"ProviderJWKs","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"issuer","type":"vector<u8>"},{"name":"version","type":"u64"},{"name":"jwks","type":"vector<0x1::jwks::JWK>"}],"variants":[]},{"name":"RSA_JWK","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"kid","type":"0x1::string::String"},{"name":"kty","type":"0x1::string::String"},{"name":"alg","type":"0x1::string::String"},{"name":"e","type":"0x1::string::String"},{"name":"n","type":"0x1::string::String"}],"variants":[]},{"name":"SupportedOIDCProviders","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"providers","type":"vector<0x1::jwks::OIDCProvider>"}],"variants":[]},{"name":"UnsupportedJWK","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"id","type":"vector<u8>"},{"name":"payload","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"util","friends":["0x1::gas_schedule","0x1::code"],"exposed_functions":[{"name":"from_bytes","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["vector<u8>"],"return":["T0"]},{"name":"address_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["address"]}],"structs":[]}},{"abi":{"address":"0x1","name":"block","friends":["0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"emit_writeset_block_event","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"get_current_block_height","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_epoch_interval_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"initialize_commit_history","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u32"],"return":[]},{"name":"update_epoch_interval_microsecs","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]}],"structs":[{"name":"BlockResource","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"height","type":"u64"},{"name":"epoch_interval","type":"u64"},{"name":"new_block_events","type":"0x1::event::EventHandle<0x1::block::NewBlockEvent>"},{"name":"update_epoch_interval_events","type":"0x1::event::EventHandle<0x1::block::UpdateEpochIntervalEvent>"}],"variants":[]},{"name":"CommitHistory","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"max_capacity","type":"u32"},{"name":"next_idx","type":"u32"},{"name":"table","type":"0x1::table_with_length::TableWithLength<u32, 0x1::block::NewBlockEvent>"}],"variants":[]},{"name":"NewBlock","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"hash","type":"address"},{"name":"epoch","type":"u64"},{"name":"round","type":"u64"},{"name":"height","type":"u64"},{"name":"previous_block_votes_bitvec","type":"vector<u8>"},{"name":"proposer","type":"address"},{"name":"failed_proposer_indices","type":"vector<u64>"},{"name":"time_microseconds","type":"u64"}],"variants":[]},{"name":"NewBlockEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"hash","type":"address"},{"name":"epoch","type":"u64"},{"name":"round","type":"u64"},{"name":"height","type":"u64"},{"name":"previous_block_votes_bitvec","type":"vector<u8>"},{"name":"proposer","type":"address"},{"name":"failed_proposer_indices","type":"vector<u64>"},{"name":"time_microseconds","type":"u64"}],"variants":[]},{"name":"UpdateEpochInterval","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_epoch_interval","type":"u64"},{"name":"new_epoch_interval","type":"u64"}],"variants":[]},{"name":"UpdateEpochIntervalEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_epoch_interval","type":"u64"},{"name":"new_epoch_interval","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"debug","friends":[],"exposed_functions":[{"name":"print","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":[]},{"name":"print_stack_trace","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]}],"structs":[]}},{"abi":{"address":"0x1","name":"error","friends":[],"exposed_functions":[{"name":"aborted","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"already_exists","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"canonical","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["u64"]},{"name":"internal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"invalid_argument","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"invalid_state","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"not_found","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"not_implemented","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"out_of_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"permission_denied","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"resource_exhausted","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"unauthenticated","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]},{"name":"unavailable","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]}],"structs":[]}},{"abi":{"address":"0x1","name":"event","friends":["0x1::account","0x1::object"],"exposed_functions":[{"name":"guid","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["&0x1::event::EventHandle<T0>"],"return":["&0x1::guid::GUID"]},{"name":"counter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["&0x1::event::EventHandle<T0>"],"return":["u64"]},{"name":"destroy_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["0x1::event::EventHandle<T0>"],"return":[]},{"name":"emit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["T0"],"return":[]},{"name":"emit_event","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["&mut 0x1::event::EventHandle<T0>","T0"],"return":[]},{"name":"new_event_handle","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["0x1::guid::GUID"],"return":["0x1::event::EventHandle<T0>"]}],"structs":[{"name":"EventHandle","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":["drop","store"]}],"fields":[{"name":"counter","type":"u64"},{"name":"guid","type":"0x1::guid::GUID"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"stake","friends":["0x1::transaction_fee","0x1::reconfiguration","0x1::reconfiguration_with_dkg","0x1::block","0x1::genesis"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"withdraw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"add_stake","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"add_stake_with_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::OwnerCapability","0x1::coin::Coin<0x1::aptos_coin::AptosCoin>"],"return":[]},{"name":"configure_allowed_validators","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>"],"return":[]},{"name":"cur_validator_consensus_infos","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"]},{"name":"deposit_owner_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::stake::OwnerCapability"],"return":[]},{"name":"destroy_owner_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::stake::OwnerCapability"],"return":[]},{"name":"extract_owner_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["0x1::stake::OwnerCapability"]},{"name":"get_current_epoch_proposal_counts","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["u64"],"return":["u64","u64"]},{"name":"get_current_epoch_voting_power","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"get_delegated_voter","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"get_lockup_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"get_operator","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"get_owned_pool_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::OwnerCapability"],"return":["address"]},{"name":"get_pending_transaction_fee","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["vector<u64>"]},{"name":"get_pool_address_for_owner","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"get_remaining_lockup_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"get_stake","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64","u64","u64","u64"]},{"name":"get_validator_config","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["vector<u8>","vector<u8>","vector<u8>"]},{"name":"get_validator_index","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"get_validator_state","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"increase_lockup","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"increase_lockup_with_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::OwnerCapability"],"return":[]},{"name":"initialize_pending_transaction_fee","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize_stake_owner","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64","address","address"],"return":[]},{"name":"initialize_validator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>","vector<u8>","vector<u8>"],"return":[]},{"name":"is_current_epoch_validator","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"join_validator_set","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"join_validator_set_internal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"leave_validator_set","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"next_validator_consensus_infos","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"]},{"name":"next_validator_consensus_infos_v2","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::stake::ValidatorSet"]},{"name":"owner_cap_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"reactivate_stake","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"reactivate_stake_with_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::OwnerCapability","u64"],"return":[]},{"name":"record_fee","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u64>","vector<u64>"],"return":[]},{"name":"remove_validators","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&vector<address>"],"return":[]},{"name":"rotate_consensus_key","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>","vector<u8>"],"return":[]},{"name":"set_delegated_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"set_delegated_voter_with_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::OwnerCapability","address"],"return":[]},{"name":"set_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"set_operator_with_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::OwnerCapability","address"],"return":[]},{"name":"set_transaction_fee_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::stake::TransactionFeeConfig"],"return":[]},{"name":"set_transaction_fee_limit_per_epoch_per_pool","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"stake_pool_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"store_aptos_coin_mint_cap","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::coin::MintCapability<0x1::aptos_coin::AptosCoin>"],"return":[]},{"name":"unlock","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"unlock_with_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","&0x1::stake::OwnerCapability"],"return":[]},{"name":"update_network_and_fullnode_addresses","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>","vector<u8>"],"return":[]},{"name":"update_performance_statistics","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::option::Option<u64>","vector<u64>"],"return":[]},{"name":"validator_consensus_infos_from_validator_set","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::ValidatorSet"],"return":["vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"]},{"name":"withdraw_with_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::stake::OwnerCapability","u64"],"return":["0x1::coin::Coin<0x1::aptos_coin::AptosCoin>"]}],"structs":[{"name":"AddStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount_added","type":"u64"}],"variants":[]},{"name":"AddStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount_added","type":"u64"}],"variants":[]},{"name":"AllowedValidators","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"accounts","type":"vector<address>"}],"variants":[]},{"name":"AptosCoinCapabilities","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"mint_cap","type":"0x1::coin::MintCapability<0x1::aptos_coin::AptosCoin>"}],"variants":[]},{"name":"DistributeRewards","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"rewards_amount","type":"u64"}],"variants":[]},{"name":"DistributeRewardsEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"rewards_amount","type":"u64"}],"variants":[]},{"name":"DistributeTransactionFee","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"fee_amount","type":"u64"}],"variants":[]},{"name":"IncreaseLockup","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_locked_until_secs","type":"u64"},{"name":"new_locked_until_secs","type":"u64"}],"variants":[]},{"name":"IncreaseLockupEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_locked_until_secs","type":"u64"},{"name":"new_locked_until_secs","type":"u64"}],"variants":[]},{"name":"IndividualValidatorPerformance","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"successful_proposals","type":"u64"},{"name":"failed_proposals","type":"u64"}],"variants":[]},{"name":"JoinValidatorSet","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"JoinValidatorSetEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"LeaveValidatorSet","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"LeaveValidatorSetEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"OwnerCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["store","key"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"PendingTransactionFee","is_native":false,"is_event":false,"is_enum":false,"abilities":["store","key"],"generic_type_params":[],"fields":[{"name":"pending_fee_by_validator","type":"0x1::big_ordered_map::BigOrderedMap<u64, 0x1::aggregator_v2::Aggregator<u64>>"}],"variants":[]},{"name":"PrecomputedValidatorSet","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"validator_set","type":"0x1::stake::ValidatorSet"},{"name":"is_liveness_fallback","type":"bool"}],"variants":[]},{"name":"ReactivateStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"ReactivateStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"RegisterValidatorCandidate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"RegisterValidatorCandidateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"RotateConsensusKey","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_consensus_pubkey","type":"vector<u8>"},{"name":"new_consensus_pubkey","type":"vector<u8>"}],"variants":[]},{"name":"RotateConsensusKeyEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_consensus_pubkey","type":"vector<u8>"},{"name":"new_consensus_pubkey","type":"vector<u8>"}],"variants":[]},{"name":"SetOperator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_operator","type":"address"},{"name":"new_operator","type":"address"}],"variants":[]},{"name":"SetOperatorEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_operator","type":"address"},{"name":"new_operator","type":"address"}],"variants":[]},{"name":"StakeManagementPermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"StakePool","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"active","type":"0x1::coin::Coin<0x1::aptos_coin::AptosCoin>"},{"name":"inactive","type":"0x1::coin::Coin<0x1::aptos_coin::AptosCoin>"},{"name":"pending_active","type":"0x1::coin::Coin<0x1::aptos_coin::AptosCoin>"},{"name":"pending_inactive","type":"0x1::coin::Coin<0x1::aptos_coin::AptosCoin>"},{"name":"locked_until_secs","type":"u64"},{"name":"operator_address","type":"address"},{"name":"delegated_voter","type":"address"},{"name":"initialize_validator_events","type":"0x1::event::EventHandle<0x1::stake::RegisterValidatorCandidateEvent>"},{"name":"set_operator_events","type":"0x1::event::EventHandle<0x1::stake::SetOperatorEvent>"},{"name":"add_stake_events","type":"0x1::event::EventHandle<0x1::stake::AddStakeEvent>"},{"name":"reactivate_stake_events","type":"0x1::event::EventHandle<0x1::stake::ReactivateStakeEvent>"},{"name":"rotate_consensus_key_events","type":"0x1::event::EventHandle<0x1::stake::RotateConsensusKeyEvent>"},{"name":"update_network_and_fullnode_addresses_events","type":"0x1::event::EventHandle<0x1::stake::UpdateNetworkAndFullnodeAddressesEvent>"},{"name":"increase_lockup_events","type":"0x1::event::EventHandle<0x1::stake::IncreaseLockupEvent>"},{"name":"join_validator_set_events","type":"0x1::event::EventHandle<0x1::stake::JoinValidatorSetEvent>"},{"name":"distribute_rewards_events","type":"0x1::event::EventHandle<0x1::stake::DistributeRewardsEvent>"},{"name":"unlock_stake_events","type":"0x1::event::EventHandle<0x1::stake::UnlockStakeEvent>"},{"name":"withdraw_stake_events","type":"0x1::event::EventHandle<0x1::stake::WithdrawStakeEvent>"},{"name":"leave_validator_set_events","type":"0x1::event::EventHandle<0x1::stake::LeaveValidatorSetEvent>"}],"variants":[]},{"name":"TransactionFeeConfig","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V0","fields":[{"name":"max_fee_octa_allowed_per_epoch_per_pool","type":"u64"}]}]},{"name":"UnlockStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount_unlocked","type":"u64"}],"variants":[]},{"name":"UnlockStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount_unlocked","type":"u64"}],"variants":[]},{"name":"UpdateNetworkAndFullnodeAddresses","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_network_addresses","type":"vector<u8>"},{"name":"new_network_addresses","type":"vector<u8>"},{"name":"old_fullnode_addresses","type":"vector<u8>"},{"name":"new_fullnode_addresses","type":"vector<u8>"}],"variants":[]},{"name":"UpdateNetworkAndFullnodeAddressesEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"old_network_addresses","type":"vector<u8>"},{"name":"new_network_addresses","type":"vector<u8>"},{"name":"old_fullnode_addresses","type":"vector<u8>"},{"name":"new_fullnode_addresses","type":"vector<u8>"}],"variants":[]},{"name":"ValidatorConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"consensus_pubkey","type":"vector<u8>"},{"name":"network_addresses","type":"vector<u8>"},{"name":"fullnode_addresses","type":"vector<u8>"},{"name":"validator_index","type":"u64"}],"variants":[]},{"name":"ValidatorFees","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"fees_table","type":"0x1::table::Table<address, 0x1::coin::Coin<0x1::aptos_coin::AptosCoin>>"}],"variants":[]},{"name":"ValidatorInfo","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"addr","type":"address"},{"name":"voting_power","type":"u64"},{"name":"config","type":"0x1::stake::ValidatorConfig"}],"variants":[]},{"name":"ValidatorPerformance","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"validators","type":"vector<0x1::stake::IndividualValidatorPerformance>"}],"variants":[]},{"name":"ValidatorSet","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"consensus_scheme","type":"u8"},{"name":"active_validators","type":"vector<0x1::stake::ValidatorInfo>"},{"name":"pending_inactive","type":"vector<0x1::stake::ValidatorInfo>"},{"name":"pending_active","type":"vector<0x1::stake::ValidatorInfo>"},{"name":"total_voting_power","type":"u128"},{"name":"total_joining_power","type":"u128"}],"variants":[]},{"name":"ValidatorSetLivenessFallback","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"minimum_stake","type":"u64"},{"name":"emergency_validator_count","type":"u64"},{"name":"total_emergency_voting_power","type":"u128"}],"variants":[]},{"name":"WithdrawStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount_withdrawn","type":"u64"}],"variants":[]},{"name":"WithdrawStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"amount_withdrawn","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"table","friends":["0x1::table_with_length","0x1::storage_slots_allocator"],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::table::Table<T0, T1>","T0"],"return":["bool"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&mut 0x1::table::Table<T0, T1>","T0"],"return":["T1"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["store"]}],"params":[],"return":["0x1::table::Table<T0, T1>"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::table::Table<T0, T1>","T0"],"return":["&T1"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&mut 0x1::table::Table<T0, T1>","T0"],"return":["&mut T1"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&mut 0x1::table::Table<T0, T1>","T0","T1"],"return":[]},{"name":"borrow_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::table::Table<T0, T1>","T0","&T1"],"return":["&T1"]},{"name":"borrow_mut_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::table::Table<T0, T1>","T0","T1"],"return":["&mut T1"]},{"name":"destroy_known_empty_unsafe","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["0x1::table::Table<T0, T1>"],"return":[]},{"name":"upsert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::table::Table<T0, T1>","T0","T1"],"return":[]}],"structs":[{"name":"Box","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"val","type":"T0"}],"variants":[]},{"name":"Table","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"fields":[{"name":"handle","type":"address"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"base16","friends":["0x1::ethereum_derivable_account"],"exposed_functions":[{"name":"base16_utf8_to_vec_u8","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"hex_char_to_u8","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u8"],"return":["u8"]}],"structs":[]}},{"abi":{"address":"0x1","name":"math64","friends":[],"exposed_functions":[{"name":"max","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["u64"]},{"name":"min","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["u64"]},{"name":"average","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["u64"]},{"name":"clamp","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64","u64"],"return":["u64"]},{"name":"floor_log2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u8"]},{"name":"log2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"pow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["u64"]},{"name":"sqrt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["u64"]}],"structs":[]}},{"abi":{"address":"0x1","name":"object","friends":["0x1::primary_fungible_store","0x1::coin"],"exposed_functions":[{"name":"new_event_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["&signer"],"return":["0x1::event::EventHandle<T0>"]},{"name":"create_guid","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["0x1::guid::GUID"]},{"name":"address_from_constructor_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["address"]},{"name":"address_from_delete_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::DeleteRef"],"return":["address"]},{"name":"address_from_extend_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ExtendRef"],"return":["address"]},{"name":"address_to_object","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["address"],"return":["0x1::object::Object<T0>"]},{"name":"burn","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>"],"return":[]},{"name":"owner","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["address"]},{"name":"can_generate_delete_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["bool"]},{"name":"convert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]},{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::object::Object<T1>"]},{"name":"create_guid_object_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":["address"]},{"name":"create_named_object","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":["0x1::object::ConstructorRef"]},{"name":"create_named_unowned_onchain_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":["0x1::object::ExtendRef"]},{"name":"create_object","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["0x1::object::ConstructorRef"]},{"name":"create_object_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&address","vector<u8>"],"return":["address"]},{"name":"create_object_from_account","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["0x1::object::ConstructorRef"]},{"name":"create_object_from_object","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["0x1::object::ConstructorRef"]},{"name":"create_sticky_object","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["0x1::object::ConstructorRef"]},{"name":"create_sticky_object_at_address","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","address"],"return":["0x1::object::ConstructorRef"]},{"name":"object_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::object::Object<T0>"],"return":["address"]},{"name":"create_unique_onchain_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::object::ExtendRef"]},{"name":"create_user_derived_object","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","&0x1::object::DeriveRef"],"return":["0x1::object::ConstructorRef"]},{"name":"create_user_derived_object_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","address"],"return":["address"]},{"name":"delete","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::object::DeleteRef"],"return":[]},{"name":"disable_ungated_transfer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::TransferRef"],"return":[]},{"name":"enable_ungated_transfer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::TransferRef"],"return":[]},{"name":"generate_delete_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::object::DeleteRef"]},{"name":"generate_derive_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::object::DeriveRef"]},{"name":"generate_extend_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::object::ExtendRef"]},{"name":"generate_linear_transfer_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::TransferRef"],"return":["0x1::object::LinearTransferRef"]},{"name":"generate_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["signer"]},{"name":"generate_signer_for_extending","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ExtendRef"],"return":["signer"]},{"name":"generate_transfer_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::object::TransferRef"]},{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","&signer","0x1::object::Object<T0>"],"return":[]},{"name":"grant_permission_with_transfer_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&0x1::object::TransferRef"],"return":[]},{"name":"is_burnt","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["bool"]},{"name":"is_object","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"is_owner","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","address"],"return":["bool"]},{"name":"is_untransferable","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["bool"]},{"name":"object_exists","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["address"],"return":["bool"]},{"name":"object_from_constructor_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::object::ConstructorRef"],"return":["0x1::object::Object<T0>"]},{"name":"object_from_delete_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::object::DeleteRef"],"return":["0x1::object::Object<T0>"]},{"name":"owns","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","address"],"return":["bool"]},{"name":"root_owner","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["address"]},{"name":"set_untransferable","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":[]},{"name":"transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","address"],"return":[]},{"name":"transfer_call","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"transfer_raw","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"transfer_to_object","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]},{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","0x1::object::Object<T1>"],"return":[]},{"name":"transfer_with_constructor_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef","address"],"return":[]},{"name":"transfer_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::object::LinearTransferRef","address"],"return":[]},{"name":"unburn","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>"],"return":[]},{"name":"ungated_transfer_allowed","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["bool"]}],"structs":[{"name":"ConstructorRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"self","type":"address"},{"name":"can_delete","type":"bool"}],"variants":[]},{"name":"DeleteRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"self","type":"address"}],"variants":[]},{"name":"DeriveRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"self","type":"address"}],"variants":[]},{"name":"ExtendRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"self","type":"address"}],"variants":[]},{"name":"LinearTransferRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"self","type":"address"},{"name":"owner","type":"address"}],"variants":[]},{"name":"Object","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"inner","type":"address"}],"variants":[]},{"name":"ObjectCore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"guid_creation_num","type":"u64"},{"name":"owner","type":"address"},{"name":"allow_ungated_transfer","type":"bool"},{"name":"transfer_events","type":"0x1::event::EventHandle<0x1::object::TransferEvent>"}],"variants":[]},{"name":"ObjectGroup","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"TombStone","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"original_owner","type":"address"}],"variants":[]},{"name":"Transfer","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"object","type":"address"},{"name":"from","type":"address"},{"name":"to","type":"address"}],"variants":[]},{"name":"TransferEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"object","type":"address"},{"name":"from","type":"address"},{"name":"to","type":"address"}],"variants":[]},{"name":"TransferPermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"object","type":"address"}],"variants":[]},{"name":"TransferRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"self","type":"address"}],"variants":[]},{"name":"Untransferable","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"option","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::option::Option<T0>","&T0"],"return":["bool"]},{"name":"swap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::option::Option<T0>","T0"],"return":["T0"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::option::Option<T0>"],"return":["&T0"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::option::Option<T0>"],"return":["&mut T0"]},{"name":"borrow_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::option::Option<T0>","&T0"],"return":["&T0"]},{"name":"destroy_none","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::option::Option<T0>"],"return":[]},{"name":"destroy_some","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::option::Option<T0>"],"return":["T0"]},{"name":"destroy_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["0x1::option::Option<T0>","T0"],"return":["T0"]},{"name":"extract","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::option::Option<T0>"],"return":["T0"]},{"name":"fill","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::option::Option<T0>","T0"],"return":[]},{"name":"from_vec","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["vector<T0>"],"return":["0x1::option::Option<T0>"]},{"name":"get_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":["&0x1::option::Option<T0>","T0"],"return":["T0"]},{"name":"is_none","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::option::Option<T0>"],"return":["bool"]},{"name":"is_some","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::option::Option<T0>"],"return":["bool"]},{"name":"none","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::option::Option<T0>"]},{"name":"some","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["T0"],"return":["0x1::option::Option<T0>"]},{"name":"swap_or_fill","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::option::Option<T0>","T0"],"return":["0x1::option::Option<T0>"]},{"name":"to_vec","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::option::Option<T0>"],"return":["vector<T0>"]}],"structs":[{"name":"Option","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"vec","type":"vector<T0>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"result","friends":[],"exposed_functions":[{"name":"is_err","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::result::Result<T0, T1>"],"return":["bool"]},{"name":"is_ok","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::result::Result<T0, T1>"],"return":["bool"]},{"name":"unwrap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::result::Result<T0, T1>"],"return":["T0"]},{"name":"unwrap_err","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::result::Result<T0, T1>"],"return":["T1"]}],"structs":[{"name":"Result","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[],"variants":[{"name":"Ok","fields":[{"name":"_0","type":"T0"}]},{"name":"Err","fields":[{"name":"_0","type":"T1"}]}]}]}},{"abi":{"address":"0x1","name":"signer","friends":[],"exposed_functions":[{"name":"address_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["address"]},{"name":"borrow_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["&address"]}],"structs":[]}},{"abi":{"address":"0x1","name":"string","friends":[],"exposed_functions":[{"name":"index_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::string::String","&0x1::string::String"],"return":["u64"]},{"name":"append","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::string::String","0x1::string::String"],"return":[]},{"name":"insert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::string::String","u64","0x1::string::String"],"return":[]},{"name":"is_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::string::String"],"return":["bool"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::string::String"],"return":["u64"]},{"name":"append_utf8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::string::String","vector<u8>"],"return":[]},{"name":"bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::string::String"],"return":["&vector<u8>"]},{"name":"internal_check_utf8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<u8>"],"return":["bool"]},{"name":"into_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::string::String"],"return":["vector<u8>"]},{"name":"sub_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::string::String","u64","u64"],"return":["0x1::string::String"]},{"name":"try_utf8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::string::String>"]},{"name":"utf8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::string::String"]}],"structs":[{"name":"String","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"vector","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&vector<T0>","&T0"],"return":["bool"]},{"name":"index_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&vector<T0>","&T0"],"return":["bool","u64"]},{"name":"range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["vector<u64>"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64"],"return":["T0"]},{"name":"replace","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64","T0"],"return":["T0"]},{"name":"swap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64","u64"],"return":[]},{"name":"append","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","vector<T0>"],"return":[]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&vector<T0>","u64"],"return":["&T0"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64"],"return":["&mut T0"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["vector<T0>"],"return":[]},{"name":"empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["vector<T0>"]},{"name":"insert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64","T0"],"return":[]},{"name":"is_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&vector<T0>"],"return":["bool"]},{"name":"last","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&vector<T0>"],"return":["&T0"]},{"name":"last_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>"],"return":["&mut T0"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&vector<T0>"],"return":["u64"]},{"name":"move_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64","u64","&mut vector<T0>","u64"],"return":[]},{"name":"pop_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>"],"return":["T0"]},{"name":"push_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","T0"],"return":[]},{"name":"range_with_step","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64","u64"],"return":["vector<u64>"]},{"name":"remove_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","&T0"],"return":["vector<T0>"]},{"name":"reverse","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>"],"return":[]},{"name":"reverse_append","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","vector<T0>"],"return":[]},{"name":"reverse_slice","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64","u64"],"return":[]},{"name":"rotate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64"],"return":["u64"]},{"name":"rotate_slice","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64","u64","u64"],"return":["u64"]},{"name":"singleton","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["T0"],"return":["vector<T0>"]},{"name":"slice","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy"]}],"params":["&vector<T0>","u64","u64"],"return":["vector<T0>"]},{"name":"swap_remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64"],"return":["T0"]},{"name":"trim","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64"],"return":["vector<T0>"]},{"name":"trim_reverse","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut vector<T0>","u64"],"return":["vector<T0>"]}],"structs":[]}},{"abi":{"address":"0x1","name":"voting","friends":[],"exposed_functions":[{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"register","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&signer"],"return":[]},{"name":"can_be_resolved_early","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&0x1::voting::Proposal<T0>"],"return":["bool"]},{"name":"create_proposal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["address","address","T0","vector<u8>","u128","u64","0x1::option::Option<u128>","0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"],"return":["u64"]},{"name":"create_proposal_v2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["address","address","T0","vector<u8>","u128","u64","0x1::option::Option<u128>","0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>","bool"],"return":["u64"]},{"name":"get_early_resolution_vote_threshold","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["0x1::option::Option<u128>"]},{"name":"get_execution_hash","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["vector<u8>"]},{"name":"get_min_vote_threshold","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["u128"]},{"name":"get_proposal_creation_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["u64"]},{"name":"get_proposal_expiration_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["u64"]},{"name":"get_proposal_metadata","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"]},{"name":"get_proposal_metadata_value","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64","0x1::string::String"],"return":["vector<u8>"]},{"name":"get_proposal_state","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["u64"]},{"name":"get_proposer","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["address"]},{"name":"get_resolution_time_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["u64"]},{"name":"get_votes","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["u128","u128"]},{"name":"is_multi_step_proposal_in_execution","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["bool"]},{"name":"is_resolved","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["bool"]},{"name":"is_voting_closed","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["bool"]},{"name":"next_proposal_id","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["store"]}],"params":["address"],"return":["u64"]},{"name":"resolve","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64"],"return":["T0"]},{"name":"resolve_proposal_v2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["address","u64","vector<u8>"],"return":[]},{"name":"vote","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&T0","address","u64","u64","bool"],"return":[]}],"structs":[{"name":"CreateProposal","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"early_resolution_vote_threshold","type":"0x1::option::Option<u128>"},{"name":"execution_hash","type":"vector<u8>"},{"name":"expiration_secs","type":"u64"},{"name":"metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"},{"name":"min_vote_threshold","type":"u128"}],"variants":[]},{"name":"CreateProposalEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"early_resolution_vote_threshold","type":"0x1::option::Option<u128>"},{"name":"execution_hash","type":"vector<u8>"},{"name":"expiration_secs","type":"u64"},{"name":"metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"},{"name":"min_vote_threshold","type":"u128"}],"variants":[]},{"name":"Proposal","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":["store"]}],"fields":[{"name":"proposer","type":"address"},{"name":"execution_content","type":"0x1::option::Option<T0>"},{"name":"metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"},{"name":"creation_time_secs","type":"u64"},{"name":"execution_hash","type":"vector<u8>"},{"name":"min_vote_threshold","type":"u128"},{"name":"expiration_secs","type":"u64"},{"name":"early_resolution_vote_threshold","type":"0x1::option::Option<u128>"},{"name":"yes_votes","type":"u128"},{"name":"no_votes","type":"u128"},{"name":"is_resolved","type":"bool"},{"name":"resolution_time_secs","type":"u64"}],"variants":[]},{"name":"RegisterForum","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"hosting_account","type":"address"},{"name":"proposal_type_info","type":"0x1::type_info::TypeInfo"}],"variants":[]},{"name":"RegisterForumEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"hosting_account","type":"address"},{"name":"proposal_type_info","type":"0x1::type_info::TypeInfo"}],"variants":[]},{"name":"ResolveProposal","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"yes_votes","type":"u128"},{"name":"no_votes","type":"u128"},{"name":"resolved_early","type":"bool"}],"variants":[]},{"name":"Vote","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"num_votes","type":"u64"}],"variants":[]},{"name":"VoteEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"num_votes","type":"u64"}],"variants":[]},{"name":"VotePermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"VotingEvents","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"create_proposal_events","type":"0x1::event::EventHandle<0x1::voting::CreateProposalEvent>"},{"name":"register_forum_events","type":"0x1::event::EventHandle<0x1::voting::RegisterForumEvent>"},{"name":"resolve_proposal_events","type":"0x1::event::EventHandle<0x1::voting::ResolveProposal>"},{"name":"vote_events","type":"0x1::event::EventHandle<0x1::voting::VoteEvent>"}],"variants":[]},{"name":"VotingForum","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":["store"]}],"fields":[{"name":"proposals","type":"0x1::table::Table<u64, 0x1::voting::Proposal<T0>>"},{"name":"events","type":"0x1::voting::VotingEvents"},{"name":"next_proposal_id","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"account","friends":["0x1::coin","0x1::aptos_account","0x1::keyless_account","0x1::transaction_validation","0x1::genesis","0x1::multisig_account","0x1::resource_account"],"exposed_functions":[{"name":"new_event_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["&signer"],"return":["0x1::event::EventHandle<T0>"]},{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"create_account","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["signer"]},{"name":"create_account_if_does_not_exist","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"create_authorized_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":["signer"]},{"name":"create_framework_reserved_account","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["signer","0x1::account::SignerCapability"]},{"name":"create_guid","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["0x1::guid::GUID"]},{"name":"create_resource_account","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":["signer","0x1::account::SignerCapability"]},{"name":"create_resource_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&address","vector<u8>"],"return":["address"]},{"name":"create_signer_with_capability","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::account::SignerCapability"],"return":["signer"]},{"name":"encrypted_dk_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"exists_at","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"get_authentication_key","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["vector<u8>"]},{"name":"get_encrypted_dk","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["0x1::account::EncryptedDK"]},{"name":"get_guid_next_creation_num","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"get_rotation_capability_offer_for","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"get_sequence_number","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"get_signer_capability_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::account::SignerCapability"],"return":["address"]},{"name":"get_signer_capability_offer_for","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"grant_key_offering_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"grant_key_rotation_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"increment_sequence_number","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"is_rotation_capability_offered","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"is_signer_capability_offered","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"offer_rotation_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","u8","vector<u8>","address"],"return":[]},{"name":"offer_signer_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","u8","vector<u8>","address"],"return":[]},{"name":"originating_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["0x1::option::Option<address>"]},{"name":"register_coin","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address"],"return":[]},{"name":"revoke_any_rotation_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"revoke_any_signer_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"revoke_rotation_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"revoke_signer_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"rotate_authentication_key","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u8","vector<u8>","u8","vector<u8>","vector<u8>","vector<u8>"],"return":[]},{"name":"rotate_authentication_key_call","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"rotate_authentication_key_from_public_key","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u8","vector<u8>"],"return":[]},{"name":"rotate_authentication_key_internal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"rotate_authentication_key_with_rotation_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u8","vector<u8>","vector<u8>"],"return":[]},{"name":"set_originating_address","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"upsert_ed25519_backup_key_and_encrypt_dk","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>","vector<u8>","vector<u8>"],"return":[]},{"name":"upsert_ed25519_backup_key_on_keyless_account","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>","vector<u8>"],"return":[]},{"name":"upsert_encrypted_dk","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"verify_signed_message","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["address","u8","vector<u8>","vector<u8>","T0"],"return":[]}],"structs":[{"name":"Account","is_native":false,"is_event":false,"is_enum":false,"abilities":["store","key"],"generic_type_params":[],"fields":[{"name":"authentication_key","type":"vector<u8>"},{"name":"sequence_number","type":"u64"},{"name":"guid_creation_num","type":"u64"},{"name":"coin_register_events","type":"0x1::event::EventHandle<0x1::account::CoinRegisterEvent>"},{"name":"key_rotation_events","type":"0x1::event::EventHandle<0x1::account::KeyRotationEvent>"},{"name":"rotation_capability_offer","type":"0x1::account::CapabilityOffer<0x1::account::RotationCapability>"},{"name":"signer_capability_offer","type":"0x1::account::CapabilityOffer<0x1::account::SignerCapability>"}],"variants":[]},{"name":"AccountPermission","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"KeyRotation","fields":[]},{"name":"Offering","fields":[]}]},{"name":"CapabilityOffer","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"for","type":"0x1::option::Option<address>"}],"variants":[]},{"name":"CoinRegister","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"type_info","type":"0x1::type_info::TypeInfo"}],"variants":[]},{"name":"CoinRegisterEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"type_info","type":"0x1::type_info::TypeInfo"}],"variants":[]},{"name":"EncryptedDK","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"ciphertext","type":"vector<u8>"}]}]},{"name":"KeyRotation","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"old_authentication_key","type":"vector<u8>"},{"name":"new_authentication_key","type":"vector<u8>"}],"variants":[]},{"name":"KeyRotationEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_authentication_key","type":"vector<u8>"},{"name":"new_authentication_key","type":"vector<u8>"}],"variants":[]},{"name":"KeyRotationToPublicKey","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"verified_public_key_bit_map","type":"vector<u8>"},{"name":"public_key_scheme","type":"u8"},{"name":"public_key","type":"vector<u8>"},{"name":"old_auth_key","type":"vector<u8>"},{"name":"new_auth_key","type":"vector<u8>"}],"variants":[]},{"name":"OriginatingAddress","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"address_map","type":"0x1::table::Table<address, address>"}],"variants":[]},{"name":"RotationCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"}],"variants":[]},{"name":"RotationCapabilityOfferProofChallenge","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"sequence_number","type":"u64"},{"name":"recipient_address","type":"address"}],"variants":[]},{"name":"RotationCapabilityOfferProofChallengeV2","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"chain_id","type":"u8"},{"name":"sequence_number","type":"u64"},{"name":"source_address","type":"address"},{"name":"recipient_address","type":"address"}],"variants":[]},{"name":"RotationProofChallenge","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"sequence_number","type":"u64"},{"name":"originator","type":"address"},{"name":"current_auth_key","type":"address"},{"name":"new_public_key","type":"vector<u8>"}],"variants":[]},{"name":"SignerCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"}],"variants":[]},{"name":"SignerCapabilityOfferProofChallenge","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"sequence_number","type":"u64"},{"name":"recipient_address","type":"address"}],"variants":[]},{"name":"SignerCapabilityOfferProofChallengeV2","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"sequence_number","type":"u64"},{"name":"source_address","type":"address"},{"name":"recipient_address","type":"address"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"ed25519","friends":[],"exposed_functions":[{"name":"signature_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::Signature"],"return":["vector<u8>"]},{"name":"new_signature_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ed25519::Signature"]},{"name":"new_signed_message","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["T0"],"return":["0x1::ed25519::SignedMessage<T0>"]},{"name":"new_unvalidated_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ed25519::UnvalidatedPublicKey"]},{"name":"new_validated_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ed25519::ValidatedPublicKey>"]},{"name":"public_key_into_unvalidated","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ed25519::ValidatedPublicKey"],"return":["0x1::ed25519::UnvalidatedPublicKey"]},{"name":"public_key_to_unvalidated","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::ValidatedPublicKey"],"return":["0x1::ed25519::UnvalidatedPublicKey"]},{"name":"public_key_validate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::UnvalidatedPublicKey"],"return":["0x1::option::Option<0x1::ed25519::ValidatedPublicKey>"]},{"name":"signature_verify_strict","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::Signature","&0x1::ed25519::UnvalidatedPublicKey","vector<u8>"],"return":["bool"]},{"name":"signature_verify_strict_t","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["&0x1::ed25519::Signature","&0x1::ed25519::UnvalidatedPublicKey","T0"],"return":["bool"]},{"name":"unvalidated_public_key_to_authentication_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::UnvalidatedPublicKey"],"return":["vector<u8>"]},{"name":"unvalidated_public_key_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::UnvalidatedPublicKey"],"return":["vector<u8>"]},{"name":"validated_public_key_to_authentication_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::ValidatedPublicKey"],"return":["vector<u8>"]},{"name":"validated_public_key_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ed25519::ValidatedPublicKey"],"return":["vector<u8>"]}],"structs":[{"name":"Signature","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"SignedMessage","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"type_info","type":"0x1::type_info::TypeInfo"},{"name":"inner","type":"T0"}],"variants":[]},{"name":"UnvalidatedPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"ValidatedPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"genesis","friends":[],"exposed_functions":[],"structs":[{"name":"AccountMap","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"account_address","type":"address"},{"name":"balance","type":"u64"}],"variants":[]},{"name":"EmployeeAccountMap","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"accounts","type":"vector<address>"},{"name":"validator","type":"0x1::genesis::ValidatorConfigurationWithCommission"},{"name":"vesting_schedule_numerator","type":"vector<u64>"},{"name":"vesting_schedule_denominator","type":"u64"},{"name":"beneficiary_resetter","type":"address"}],"variants":[]},{"name":"ValidatorConfiguration","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"owner_address","type":"address"},{"name":"operator_address","type":"address"},{"name":"voter_address","type":"address"},{"name":"stake_amount","type":"u64"},{"name":"consensus_pubkey","type":"vector<u8>"},{"name":"proof_of_possession","type":"vector<u8>"},{"name":"network_addresses","type":"vector<u8>"},{"name":"full_node_network_addresses","type":"vector<u8>"}],"variants":[]},{"name":"ValidatorConfigurationWithCommission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"validator_config","type":"0x1::genesis::ValidatorConfiguration"},{"name":"commission_percentage","type":"u64"},{"name":"join_during_genesis","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"keyless","friends":["0x1::federated_keyless"],"exposed_functions":[{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::string::String","vector<u8>"],"return":["0x1::keyless::PublicKey"]},{"name":"deserialize_public_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["0x1::keyless::PublicKey"]},{"name":"get_idc","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::keyless::PublicKey"],"return":["vector<u8>"]},{"name":"get_iss","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::keyless::PublicKey"],"return":["0x1::string::String"]},{"name":"new_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::keyless::PublicKey"]}],"structs":[{"name":"PublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"iss","type":"0x1::string::String"},{"name":"idc","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"math128","friends":[],"exposed_functions":[{"name":"max","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","u128"],"return":["u128"]},{"name":"min","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","u128"],"return":["u128"]},{"name":"average","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","u128"],"return":["u128"]},{"name":"clamp","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","u128","u128"],"return":["u128"]},{"name":"floor_log2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128"],"return":["u8"]},{"name":"log2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"log2_64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"pow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","u128"],"return":["u128"]},{"name":"sqrt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128"],"return":["u128"]}],"structs":[]}},{"abi":{"address":"0x1","name":"reflect","friends":[],"exposed_functions":[{"name":"error_code","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::reflect::ReflectionError"],"return":["u64"]},{"name":"resolve","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","&0x1::string::String","&0x1::string::String"],"return":["0x1::result::Result<T0, 0x1::reflect::ReflectionError>"]}],"structs":[{"name":"ReflectionError","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"InvalidIdentifier","fields":[]},{"name":"FunctionNotFound","fields":[]},{"name":"FunctionNotAccessible","fields":[]},{"name":"FunctionIncompatibleType","fields":[]},{"name":"FunctionNotInstantiated","fields":[]}]}]}},{"abi":{"address":"0x1","name":"version","friends":["0x1::reconfiguration_with_dkg","0x1::genesis"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"set_version","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]}],"structs":[{"name":"SetVersionCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Version","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"major","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"vesting","friends":["0x1::genesis"],"exposed_functions":[{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"operator","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"voter","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"shareholder","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["address"]},{"name":"operator_commission_percentage","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"set_beneficiary_for_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"update_commission_percentage","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"beneficiary","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["address"]},{"name":"shareholders","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["vector<address>"]},{"name":"distribute","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"reset_lockup","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"stake_pool_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"unlock_rewards","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"update_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"accumulated_rewards","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["u64"]},{"name":"admin_withdraw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"create_vesting_contract","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&vector<address>","0x1::simple_map::SimpleMap<address, 0x1::coin::Coin<0x1::aptos_coin::AptosCoin>>","0x1::vesting::VestingSchedule","address","address","address","u64","vector<u8>"],"return":["address"]},{"name":"vesting_schedule","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["0x1::vesting::VestingSchedule"]},{"name":"create_vesting_schedule","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::fixed_point32::FixedPoint32>","u64","u64"],"return":["0x1::vesting::VestingSchedule"]},{"name":"distribute_many","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["vector<address>"],"return":[]},{"name":"get_role_holder","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String"],"return":["address"]},{"name":"get_vesting_account_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":["signer"]},{"name":"period_duration_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"remaining_grant","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"reset_beneficiary","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"set_beneficiary","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address","address"],"return":[]},{"name":"set_beneficiary_resetter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"set_management_role","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","address"],"return":[]},{"name":"terminate_vesting_contract","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"total_accumulated_rewards","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"unlock_rewards_many","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["vector<address>"],"return":[]},{"name":"update_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address","u64"],"return":[]},{"name":"update_operator_with_same_commission","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"vest","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"vest_many","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["vector<address>"],"return":[]},{"name":"vesting_contracts","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["vector<address>"]},{"name":"vesting_start_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]}],"structs":[{"name":"Distribute","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"DistributeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"ResetLockup","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"new_lockup_expiration_secs","type":"u64"}],"variants":[]},{"name":"ResetLockupEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"new_lockup_expiration_secs","type":"u64"}],"variants":[]},{"name":"UpdateVoter","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"old_voter","type":"address"},{"name":"new_voter","type":"address"}],"variants":[]},{"name":"UpdateVoterEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"old_voter","type":"address"},{"name":"new_voter","type":"address"}],"variants":[]},{"name":"AdminStore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"vesting_contracts","type":"vector<address>"},{"name":"nonce","type":"u64"},{"name":"create_events","type":"0x1::event::EventHandle<0x1::vesting::CreateVestingContractEvent>"}],"variants":[]},{"name":"AdminWithdraw","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"AdminWithdrawEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"CreateVestingContract","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"voter","type":"address"},{"name":"grant_amount","type":"u64"},{"name":"withdrawal_address","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"commission_percentage","type":"u64"}],"variants":[]},{"name":"CreateVestingContractEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"voter","type":"address"},{"name":"grant_amount","type":"u64"},{"name":"withdrawal_address","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"commission_percentage","type":"u64"}],"variants":[]},{"name":"SetBeneficiary","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"shareholder","type":"address"},{"name":"old_beneficiary","type":"address"},{"name":"new_beneficiary","type":"address"}],"variants":[]},{"name":"SetBeneficiaryEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"shareholder","type":"address"},{"name":"old_beneficiary","type":"address"},{"name":"new_beneficiary","type":"address"}],"variants":[]},{"name":"StakingInfo","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"operator","type":"address"},{"name":"voter","type":"address"},{"name":"commission_percentage","type":"u64"}],"variants":[]},{"name":"Terminate","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"}],"variants":[]},{"name":"TerminateEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"}],"variants":[]},{"name":"UnlockRewards","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"UnlockRewardsEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"UpdateOperator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"old_operator","type":"address"},{"name":"new_operator","type":"address"},{"name":"commission_percentage","type":"u64"}],"variants":[]},{"name":"UpdateOperatorEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"old_operator","type":"address"},{"name":"new_operator","type":"address"},{"name":"commission_percentage","type":"u64"}],"variants":[]},{"name":"Vest","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"period_vested","type":"u64"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"VestEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"admin","type":"address"},{"name":"vesting_contract_address","type":"address"},{"name":"staking_pool_address","type":"address"},{"name":"period_vested","type":"u64"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"VestPermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"VestingAccountManagement","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"roles","type":"0x1::simple_map::SimpleMap<0x1::string::String, address>"}],"variants":[]},{"name":"VestingContract","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"state","type":"u64"},{"name":"admin","type":"address"},{"name":"grant_pool","type":"0x1::pool_u64::Pool"},{"name":"beneficiaries","type":"0x1::simple_map::SimpleMap<address, address>"},{"name":"vesting_schedule","type":"0x1::vesting::VestingSchedule"},{"name":"withdrawal_address","type":"address"},{"name":"staking","type":"0x1::vesting::StakingInfo"},{"name":"remaining_grant","type":"u64"},{"name":"signer_cap","type":"0x1::account::SignerCapability"},{"name":"update_operator_events","type":"0x1::event::EventHandle<0x1::vesting::UpdateOperatorEvent>"},{"name":"update_voter_events","type":"0x1::event::EventHandle<0x1::vesting::UpdateVoterEvent>"},{"name":"reset_lockup_events","type":"0x1::event::EventHandle<0x1::vesting::ResetLockupEvent>"},{"name":"set_beneficiary_events","type":"0x1::event::EventHandle<0x1::vesting::SetBeneficiaryEvent>"},{"name":"unlock_rewards_events","type":"0x1::event::EventHandle<0x1::vesting::UnlockRewardsEvent>"},{"name":"vest_events","type":"0x1::event::EventHandle<0x1::vesting::VestEvent>"},{"name":"distribute_events","type":"0x1::event::EventHandle<0x1::vesting::DistributeEvent>"},{"name":"terminate_events","type":"0x1::event::EventHandle<0x1::vesting::TerminateEvent>"},{"name":"admin_withdraw_events","type":"0x1::event::EventHandle<0x1::vesting::AdminWithdrawEvent>"}],"variants":[]},{"name":"VestingSchedule","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"schedule","type":"vector<0x1::fixed_point32::FixedPoint32>"},{"name":"start_timestamp_secs","type":"u64"},{"name":"period_duration","type":"u64"},{"name":"last_vested_period","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"bls12381","friends":[],"exposed_functions":[{"name":"aggr_or_multi_signature_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::bls12381::AggrOrMultiSignature"]},{"name":"aggr_or_multi_signature_subgroup_check","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::AggrOrMultiSignature"],"return":["bool"]},{"name":"aggr_or_multi_signature_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::AggrOrMultiSignature"],"return":["vector<u8>"]},{"name":"aggregate_pubkey_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::AggrPublicKeysWithPoP"],"return":["vector<u8>"]},{"name":"aggregate_pubkeys","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::bls12381::PublicKeyWithPoP>"],"return":["0x1::bls12381::AggrPublicKeysWithPoP"]},{"name":"aggregate_signatures","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::bls12381::Signature>"],"return":["0x1::option::Option<0x1::bls12381::AggrOrMultiSignature>"]},{"name":"proof_of_possession_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::bls12381::ProofOfPossession"]},{"name":"proof_of_possession_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::ProofOfPossession"],"return":["vector<u8>"]},{"name":"public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::bls12381::PublicKey>"]},{"name":"public_key_from_bytes_with_pop","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","&0x1::bls12381::ProofOfPossession"],"return":["0x1::option::Option<0x1::bls12381::PublicKeyWithPoP>"]},{"name":"public_key_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::PublicKey"],"return":["vector<u8>"]},{"name":"public_key_with_pop_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::PublicKeyWithPoP"],"return":["vector<u8>"]},{"name":"public_key_with_pop_to_normal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::PublicKeyWithPoP"],"return":["0x1::bls12381::PublicKey"]},{"name":"signature_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::bls12381::Signature"]},{"name":"signature_subgroup_check","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::Signature"],"return":["bool"]},{"name":"signature_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::Signature"],"return":["vector<u8>"]},{"name":"verify_aggregate_signature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::AggrOrMultiSignature","vector<0x1::bls12381::PublicKeyWithPoP>","vector<vector<u8>>"],"return":["bool"]},{"name":"verify_multisignature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::AggrOrMultiSignature","&0x1::bls12381::AggrPublicKeysWithPoP","vector<u8>"],"return":["bool"]},{"name":"verify_normal_signature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::Signature","&0x1::bls12381::PublicKey","vector<u8>"],"return":["bool"]},{"name":"verify_signature_share","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bls12381::Signature","&0x1::bls12381::PublicKeyWithPoP","vector<u8>"],"return":["bool"]}],"structs":[{"name":"AggrOrMultiSignature","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"AggrPublicKeysWithPoP","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"ProofOfPossession","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"PublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"PublicKeyWithPoP","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"Signature","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"chain_id","friends":["0x1::genesis"],"exposed_functions":[{"name":"get","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u8"]},{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u8"],"return":[]}],"structs":[{"name":"ChainId","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"id","type":"u8"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"features","friends":[],"exposed_functions":[{"name":"abort_if_multisig_payload_mismatch_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"aggregator_snapshots_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"aggregator_v2_api_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"aggregator_v2_is_at_least_api_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"allow_vm_binary_format_v6","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"aptos_stdlib_chain_id_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"auids_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"blake2b_256_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"bls12_381_structures_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"bn254_structures_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"bulletproofs_batch_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"bulletproofs_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"change_feature_flags","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u64>","vector<u64>"],"return":[]},{"name":"change_feature_flags_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u64>","vector<u64>"],"return":[]},{"name":"code_dependency_check_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"coin_to_fungible_asset_migration_feature_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"collect_and_distribute_gas_fees","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"commission_change_delegation_pool_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"concurrent_assets_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"concurrent_fungible_assets_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"concurrent_fungible_balance_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"concurrent_token_v2_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"cryptography_algebra_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"default_to_concurrent_fungible_balance_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"delegation_pool_allowlisting_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"delegation_pool_partial_governance_voting_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"delegation_pools_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"dispatchable_fungible_asset_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"fee_payer_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"get_abort_if_multisig_payload_mismatch_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_account_abstraction_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_aggregator_snapshots_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_aggregator_v2_api_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_aptos_stdlib_chain_id_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_auids","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_blake2b_256_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_bls12_381_strutures_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_bn254_strutures_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_bulletproofs_batch_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_bulletproofs_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_calculate_transaction_fee_for_distribution_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_coin_to_fungible_asset_migration_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_collect_and_distribute_gas_fees_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_collection_owner_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_commission_change_delegation_pool_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_concurrent_assets_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_concurrent_fungible_assets_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_concurrent_fungible_balance_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_concurrent_token_v2_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_cryptography_algebra_natives_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_default_account_resource_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_default_to_concurrent_fungible_balance_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_delegation_pool_allowlisting_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_delegation_pool_partial_governance_voting","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_delegation_pools_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_dispatchable_fungible_asset_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_distribute_transaction_fee_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_encrypted_transactions_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_function_reflection_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_jwk_consensus_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_jwk_consensus_per_key_mode_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_keyless_accounts_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_keyless_accounts_with_passkeys_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_keyless_but_zkless_accounts_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_max_object_nesting_check_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_module_event_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_module_event_migration_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_monotonically_increasing_counter_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_multisig_accounts_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_multisig_timelock_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_multisig_v2_enhancement_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_native_memory_operations_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_new_accounts_default_to_fa_apt_store_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_new_accounts_default_to_fa_store_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_object_native_derived_address_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_operations_default_to_fa_apt_store_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_operator_beneficiary_change_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_orderless_transactions_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_partial_governance_voting","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_periodical_reward_rate_decrease_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_permissioned_signer_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_primary_apt_fungible_store_at_user_address_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_reconfigure_with_dkg_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_resource_groups_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_sha_512_and_ripemd_160_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_signer_native_format_fix_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_slh_dsa_sha2_128s_signature_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_sponsored_automatic_account_creation","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_transaction_context_extension_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_transaction_limits_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_transaction_simulation_enhancement_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_vm_binary_format_v6","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"is_account_abstraction_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_calculate_transaction_fee_for_distribution_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_collection_owner_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_default_account_resource_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_derivable_account_abstraction_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_distribute_transaction_fee_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_domain_account_abstraction_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_enabled","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["u64"],"return":["bool"]},{"name":"is_encrypted_transactions_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_function_reflection_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_jwk_consensus_per_key_mode_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_monotonically_increasing_counter_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_multisig_timelock_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_native_memory_operations_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_object_code_deployment_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_permissioned_signer_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_storage_slot_natives_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_transaction_limits_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"jwk_consensus_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"keyless_accounts_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"keyless_accounts_with_passkeys_feature_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"keyless_but_zkless_accounts_feature_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"max_object_nesting_check_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"module_event_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"module_event_migration_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"multi_ed25519_pk_validate_v2_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"multi_ed25519_pk_validate_v2_feature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"multisig_accounts_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"multisig_v2_enhancement_feature_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"new_accounts_default_to_fa_apt_store_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"new_accounts_default_to_fa_store_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"object_native_derived_address_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"on_new_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"operations_default_to_fa_apt_store_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"operator_beneficiary_change_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"orderless_transactions_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"partial_governance_voting_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"periodical_reward_rate_decrease_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"primary_apt_fungible_store_at_user_address_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"reconfigure_with_dkg_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"resource_groups_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"sha_512_and_ripemd_160_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"signer_native_format_fix_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"slh_dsa_sha2_128s_signature_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"sponsored_automatic_account_creation_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"transaction_context_extension_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"transaction_simulation_enhancement_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"treat_friend_as_private","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]}],"structs":[{"name":"Features","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"features","type":"vector<u8>"}],"variants":[]},{"name":"PendingFeatures","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"features","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"from_bcs","friends":["0x1::any","0x1::copyable_any"],"exposed_functions":[{"name":"to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"from_bytes","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["vector<u8>"],"return":["T0"]},{"name":"to_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["address"]},{"name":"to_bool","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["bool"]},{"name":"to_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::string::String"]},{"name":"to_u128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["u128"]},{"name":"to_u16","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["u16"]},{"name":"to_u256","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["u256"]},{"name":"to_u32","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["u32"]},{"name":"to_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["u64"]},{"name":"to_u8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["u8"]}],"structs":[]}},{"abi":{"address":"0x1","name":"pool_u64","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","address"],"return":["bool"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::pool_u64::Pool"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::pool_u64::Pool"],"return":[]},{"name":"create","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::pool_u64::Pool"]},{"name":"amount_to_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","u64"],"return":["u64"]},{"name":"amount_to_shares_with_total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","u64","u64"],"return":["u64"]},{"name":"total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool"],"return":["u64"]},{"name":"balance","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","address"],"return":["u64"]},{"name":"buy_in","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64::Pool","address","u64"],"return":["u64"]},{"name":"create_with_scaling_factor","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["0x1::pool_u64::Pool"]},{"name":"multiply_then_divide","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","u64","u64","u64"],"return":["u64"]},{"name":"redeem_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64::Pool","address","u64"],"return":["u64"]},{"name":"shareholders","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool"],"return":["vector<address>"]},{"name":"shareholders_count","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool"],"return":["u64"]},{"name":"shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","address"],"return":["u64"]},{"name":"shares_to_amount","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","u64"],"return":["u64"]},{"name":"shares_to_amount_with_total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool","u64","u64"],"return":["u64"]},{"name":"total_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64::Pool"],"return":["u64"]},{"name":"transfer_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64::Pool","address","address","u64"],"return":[]},{"name":"update_total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64::Pool","u64"],"return":[]}],"structs":[{"name":"Pool","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"shareholders_limit","type":"u64"},{"name":"total_coins","type":"u64"},{"name":"total_shares","type":"u64"},{"name":"shares","type":"0x1::simple_map::SimpleMap<address, u64>"},{"name":"shareholders","type":"vector<address>"},{"name":"scaling_factor","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"auth_data","friends":[],"exposed_functions":[{"name":"authenticator","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::auth_data::AbstractionAuthData"],"return":["&vector<u8>"]},{"name":"derivable_abstract_public_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::auth_data::AbstractionAuthData"],"return":["&vector<u8>"]},{"name":"derivable_abstract_signature","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::auth_data::AbstractionAuthData"],"return":["&vector<u8>"]},{"name":"digest","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::auth_data::AbstractionAuthData"],"return":["&vector<u8>"]},{"name":"is_derivable","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::auth_data::AbstractionAuthData"],"return":["bool"]}],"structs":[{"name":"AbstractionAuthData","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"digest","type":"vector<u8>"},{"name":"authenticator","type":"vector<u8>"}]},{"name":"DerivableV1","fields":[{"name":"digest","type":"vector<u8>"},{"name":"abstract_signature","type":"vector<u8>"},{"name":"abstract_public_key","type":"vector<u8>"}]}]}]}},{"abi":{"address":"0x1","name":"multi_key","friends":[],"exposed_functions":[{"name":"new_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::multi_key::MultiKey"]},{"name":"to_authentication_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_key::MultiKey"],"return":["vector<u8>"]},{"name":"deserialize_multi_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["0x1::multi_key::MultiKey"]},{"name":"new_multi_key_from_single_keys","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::single_key::AnyPublicKey>","u8"],"return":["0x1::multi_key::MultiKey"]}],"structs":[{"name":"MultiKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"public_keys","type":"vector<0x1::single_key::AnyPublicKey>"},{"name":"signatures_required","type":"u8"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"secp256k1","friends":[],"exposed_functions":[{"name":"ecdsa_raw_public_key_from_64_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::secp256k1::ECDSARawPublicKey"]},{"name":"ecdsa_raw_public_key_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::secp256k1::ECDSARawPublicKey"],"return":["vector<u8>"]},{"name":"ecdsa_recover","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","u8","&0x1::secp256k1::ECDSASignature"],"return":["0x1::option::Option<0x1::secp256k1::ECDSARawPublicKey>"]},{"name":"ecdsa_signature_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::secp256k1::ECDSASignature"]},{"name":"ecdsa_signature_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::secp256k1::ECDSASignature"],"return":["vector<u8>"]}],"structs":[{"name":"ECDSARawPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"ECDSASignature","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"secp256r1","friends":[],"exposed_functions":[{"name":"ecdsa_raw_public_key_from_64_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::secp256r1::ECDSARawPublicKey"]},{"name":"ecdsa_raw_public_key_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::secp256r1::ECDSARawPublicKey"],"return":["vector<u8>"]}],"structs":[{"name":"ECDSARawPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"timestamp","friends":["0x1::genesis"],"exposed_functions":[{"name":"now_microseconds","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"now_seconds","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"set_time_has_started","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"update_global_time","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]}],"structs":[{"name":"CurrentTimeMicroseconds","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"microseconds","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"type_info","friends":[],"exposed_functions":[{"name":"account_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::type_info::TypeInfo"],"return":["address"]},{"name":"chain_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u8"]},{"name":"module_name","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::type_info::TypeInfo"],"return":["vector<u8>"]},{"name":"size_of_val","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["u64"]},{"name":"struct_name","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::type_info::TypeInfo"],"return":["vector<u8>"]},{"name":"type_name","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::string::String"]},{"name":"type_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::type_info::TypeInfo"]}],"structs":[{"name":"TypeInfo","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"account_address","type":"address"},{"name":"module_name","type":"vector<u8>"},{"name":"struct_name","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"aggregator","friends":[],"exposed_functions":[{"name":"destroy","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::aggregator::Aggregator"],"return":[]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::aggregator::Aggregator","u128"],"return":[]},{"name":"limit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::aggregator::Aggregator"],"return":["u128"]},{"name":"read","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::aggregator::Aggregator"],"return":["u128"]},{"name":"sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::aggregator::Aggregator","u128"],"return":[]}],"structs":[{"name":"Aggregator","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"handle","type":"address"},{"name":"key","type":"address"},{"name":"limit","type":"u128"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"aptos_coin","friends":["0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["0x1::coin::BurnCapability<0x1::aptos_coin::AptosCoin>","0x1::coin::MintCapability<0x1::aptos_coin::AptosCoin>"]},{"name":"mint","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"destroy_mint_cap","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"claim_mint_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"configure_accounts_for_test","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer","0x1::coin::MintCapability<0x1::aptos_coin::AptosCoin>"],"return":[]},{"name":"delegate_mint_capability","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["signer","address"],"return":[]},{"name":"has_mint_capability","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["bool"]}],"structs":[{"name":"AptosCoin","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"DelegatedMintCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"to","type":"address"}],"variants":[]},{"name":"Delegations","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"inner","type":"vector<0x1::aptos_coin::DelegatedMintCapability>"}],"variants":[]},{"name":"MintCapStore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"mint_cap","type":"0x1::coin::MintCapability<0x1::aptos_coin::AptosCoin>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"aptos_hash","friends":[],"exposed_functions":[{"name":"blake2b_256","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"keccak256","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"ripemd160","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"sha2_512","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"sha2_512_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["vector<u8>"]},{"name":"sha3_512","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["vector<u8>"]},{"name":"sip_hash","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["u64"]},{"name":"sip_hash_from_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["u64"]}],"structs":[]}},{"abi":{"address":"0x1","name":"bcs_stream","friends":[],"exposed_functions":[{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::bcs_stream::BCSStream"]},{"name":"deserialize_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["address"]},{"name":"deserialize_bool","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["bool"]},{"name":"deserialize_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["0x1::string::String"]},{"name":"deserialize_u128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["u128"]},{"name":"deserialize_u16","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["u16"]},{"name":"deserialize_u256","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["u256"]},{"name":"deserialize_u256_entry","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["vector<u8>","u64"],"return":[]},{"name":"deserialize_u32","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["u32"]},{"name":"deserialize_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["u64"]},{"name":"deserialize_u8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["u8"]},{"name":"deserialize_uleb128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["u64"]},{"name":"has_remaining","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["bool"]}],"structs":[{"name":"BCSStream","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"data","type":"vector<u8>"},{"name":"cur","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"big_vector","friends":["0x1::smart_vector"],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::big_vector::BigVector<T0>","&T0"],"return":["bool"]},{"name":"index_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::big_vector::BigVector<T0>","&T0"],"return":["bool","u64"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::big_vector::BigVector<T0>","u64"],"return":["T0"]},{"name":"swap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::big_vector::BigVector<T0>","u64","u64"],"return":[]},{"name":"append","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::big_vector::BigVector<T0>","0x1::big_vector::BigVector<T0>"],"return":[]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::big_vector::BigVector<T0>","u64"],"return":["&T0"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::big_vector::BigVector<T0>","u64"],"return":["&mut T0"]},{"name":"destroy","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["0x1::big_vector::BigVector<T0>"],"return":[]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::big_vector::BigVector<T0>"],"return":[]},{"name":"empty","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["u64"],"return":["0x1::big_vector::BigVector<T0>"]},{"name":"is_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::big_vector::BigVector<T0>"],"return":["bool"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::big_vector::BigVector<T0>"],"return":["u64"]},{"name":"pop_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::big_vector::BigVector<T0>"],"return":["T0"]},{"name":"push_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::big_vector::BigVector<T0>","T0"],"return":[]},{"name":"reverse","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::big_vector::BigVector<T0>"],"return":[]},{"name":"singleton","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["T0","u64"],"return":["0x1::big_vector::BigVector<T0>"]},{"name":"swap_remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::big_vector::BigVector<T0>","u64"],"return":["T0"]},{"name":"to_vector","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy"]}],"params":["&0x1::big_vector::BigVector<T0>"],"return":["vector<T0>"]}],"structs":[{"name":"BigVector","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"buckets","type":"0x1::table_with_length::TableWithLength<u64, vector<T0>>"},{"name":"end_index","type":"u64"},{"name":"bucket_size","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"bit_vector","friends":[],"exposed_functions":[{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::bit_vector::BitVector"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bit_vector::BitVector"],"return":["u64"]},{"name":"is_index_set","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bit_vector::BitVector","u64"],"return":["bool"]},{"name":"longest_set_sequence_starting_at","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::bit_vector::BitVector","u64"],"return":["u64"]},{"name":"set","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bit_vector::BitVector","u64"],"return":[]},{"name":"shift_left","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bit_vector::BitVector","u64"],"return":[]},{"name":"unset","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bit_vector::BitVector","u64"],"return":[]}],"structs":[{"name":"BitVector","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"length","type":"u64"},{"name":"bit_field","type":"vector<bool>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"capability","friends":[],"exposed_functions":[{"name":"acquire","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","&T0"],"return":["0x1::capability::Cap<T0>"]},{"name":"acquire_linear","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","&T0"],"return":["0x1::capability::LinearCap<T0>"]},{"name":"create","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","&T0"],"return":[]},{"name":"delegate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::capability::Cap<T0>","&T0","&signer"],"return":[]},{"name":"linear_root_addr","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::capability::LinearCap<T0>","&T0"],"return":["address"]},{"name":"revoke","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::capability::Cap<T0>","&T0","address"],"return":[]},{"name":"root_addr","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::capability::Cap<T0>","&T0"],"return":["address"]}],"structs":[{"name":"Cap","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"root","type":"address"}],"variants":[]},{"name":"CapDelegateState","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"root","type":"address"}],"variants":[]},{"name":"CapState","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"delegates","type":"vector<address>"}],"variants":[]},{"name":"LinearCap","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"root","type":"address"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"chunky_dkg","friends":["0x1::reconfiguration_with_dkg","0x1::block"],"exposed_functions":[{"name":"start","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","0x1::chunky_dkg_config::ChunkyDKGConfig","vector<0x1::validator_consensus_info::ValidatorConsensusInfo>","vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"finish","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":[]},{"name":"incomplete_session","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<0x1::chunky_dkg::ChunkyDKGSessionState>"]},{"name":"is_session_started","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["bool"]},{"name":"last_completed_session","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<0x1::chunky_dkg::ChunkyDKGSessionState>"]},{"name":"session_dealer_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::chunky_dkg::ChunkyDKGSessionState"],"return":["u64"]},{"name":"try_clear_incomplete_session","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"session_start_time","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::chunky_dkg::ChunkyDKGSessionState"],"return":["u64"]}],"structs":[{"name":"ChunkyDKGSessionMetadata","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dealer_epoch","type":"u64"},{"name":"chunky_dkg_config","type":"0x1::chunky_dkg_config::ChunkyDKGConfig"},{"name":"dealer_validator_set","type":"vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"},{"name":"target_validator_set","type":"vector<0x1::validator_consensus_info::ValidatorConsensusInfo>"}],"variants":[]},{"name":"ChunkyDKGSessionState","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::chunky_dkg::ChunkyDKGSessionMetadata"},{"name":"start_time_us","type":"u64"},{"name":"aggregated_subtranscript","type":"vector<u8>"}],"variants":[]},{"name":"ChunkyDKGStartEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"session_metadata","type":"0x1::chunky_dkg::ChunkyDKGSessionMetadata"},{"name":"start_time_us","type":"u64"}],"variants":[]},{"name":"ChunkyDKGState","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"last_completed","type":"0x1::option::Option<0x1::chunky_dkg::ChunkyDKGSessionState>"},{"name":"in_progress","type":"0x1::option::Option<0x1::chunky_dkg::ChunkyDKGSessionState>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"comparator","friends":[],"exposed_functions":[{"name":"compare","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0","&T0"],"return":["0x1::comparator::Result"]},{"name":"compare_u8_vector","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","vector<u8>"],"return":["0x1::comparator::Result"]},{"name":"is_equal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::comparator::Result"],"return":["bool"]},{"name":"is_greater_than","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::comparator::Result"],"return":["bool"]},{"name":"is_smaller_than","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::comparator::Result"],"return":["bool"]}],"structs":[{"name":"Result","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"inner","type":"u8"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"decryption","friends":["0x1::reconfiguration_with_dkg","0x1::block"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"on_new_block","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64","u64","0x1::option::Option<vector<u8>>"],"return":[]},{"name":"set_for_next_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","vector<u8>"],"return":[]}],"structs":[{"name":"PerBlockDecryptionKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","key"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"},{"name":"round","type":"u64"},{"name":"decryption_key","type":"0x1::option::Option<vector<u8>>"}],"variants":[]},{"name":"PerEpochEncryptionKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"},{"name":"encryption_key","type":"0x1::option::Option<vector<u8>>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"math_fixed","friends":[],"exposed_functions":[{"name":"mul_div","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32","0x1::fixed_point32::FixedPoint32","0x1::fixed_point32::FixedPoint32"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"pow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32","u64"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"sqrt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"exp","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"ln_plus_32ln2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"log2_plus_32","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["0x1::fixed_point32::FixedPoint32"]}],"structs":[]}},{"abi":{"address":"0x1","name":"randomness","friends":["0x1::block"],"exposed_functions":[{"name":"bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["vector<u8>"]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"on_new_block","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64","u64","0x1::option::Option<vector<u8>>"],"return":[]},{"name":"permutation","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["vector<u64>"]},{"name":"u128_integer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u128"]},{"name":"u128_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","u128"],"return":["u128"]},{"name":"u16_integer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u16"]},{"name":"u16_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u16","u16"],"return":["u16"]},{"name":"u256_integer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u256"]},{"name":"u256_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u256","u256"],"return":["u256"]},{"name":"u32_integer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u32"]},{"name":"u32_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u32","u32"],"return":["u32"]},{"name":"u64_integer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"u64_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["u64"]},{"name":"u64_range_internal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["u64"]},{"name":"u8_integer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u8"]},{"name":"u8_range","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u8","u8"],"return":["u8"]}],"structs":[{"name":"PerBlockRandomness","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","key"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"},{"name":"round","type":"u64"},{"name":"seed","type":"0x1::option::Option<vector<u8>>"}],"variants":[]},{"name":"RandomnessGeneratedEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"simple_map","friends":[],"exposed_functions":[{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&mut 0x1::simple_map::SimpleMap<T0, T1>","&T0"],"return":["T0","T1"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":[],"return":["0x1::simple_map::SimpleMap<T0, T1>"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::simple_map::SimpleMap<T0, T1>","&T0"],"return":["&T1"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&mut 0x1::simple_map::SimpleMap<T0, T1>","&T0"],"return":["&mut T1"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["0x1::simple_map::SimpleMap<T0, T1>"],"return":[]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::simple_map::SimpleMap<T0, T1>"],"return":["u64"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&mut 0x1::simple_map::SimpleMap<T0, T1>","T0","T1"],"return":[]},{"name":"upsert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&mut 0x1::simple_map::SimpleMap<T0, T1>","T0","T1"],"return":["0x1::option::Option<T0>","0x1::option::Option<T1>"]},{"name":"create","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":[],"return":["0x1::simple_map::SimpleMap<T0, T1>"]},{"name":"add_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&mut 0x1::simple_map::SimpleMap<T0, T1>","vector<T0>","vector<T1>"],"return":[]},{"name":"keys","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy"]},{"constraints":[]}],"params":["&0x1::simple_map::SimpleMap<T0, T1>"],"return":["vector<T0>"]},{"name":"values","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":["copy"]}],"params":["&0x1::simple_map::SimpleMap<T0, T1>"],"return":["vector<T1>"]},{"name":"contains_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::simple_map::SimpleMap<T0, T1>","&T0"],"return":["bool"]},{"name":"new_from","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["vector<T0>","vector<T1>"],"return":["0x1::simple_map::SimpleMap<T0, T1>"]},{"name":"to_vec_pair","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["0x1::simple_map::SimpleMap<T0, T1>"],"return":["vector<T0>","vector<T1>"]}],"structs":[{"name":"Element","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[{"name":"key","type":"T0"},{"name":"value","type":"T1"}],"variants":[]},{"name":"SimpleMap","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[{"name":"data","type":"vector<0x1::simple_map::Element<T0, T1>>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"single_key","friends":[],"exposed_functions":[{"name":"new_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::single_key::AnyPublicKey"]},{"name":"deserialize_any_public_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["0x1::single_key::AnyPublicKey"]},{"name":"from_ed25519_public_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ed25519::ValidatedPublicKey"],"return":["0x1::single_key::AnyPublicKey"]},{"name":"from_ed25519_public_key_unvalidated","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ed25519::UnvalidatedPublicKey"],"return":["0x1::single_key::AnyPublicKey"]},{"name":"is_keyless_or_federated_keyless_public_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::single_key::AnyPublicKey"],"return":["bool"]},{"name":"to_authentication_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::single_key::AnyPublicKey"],"return":["vector<u8>"]}],"structs":[{"name":"AnyPublicKey","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"Ed25519","fields":[{"name":"pk","type":"0x1::ed25519::UnvalidatedPublicKey"}]},{"name":"Secp256k1Ecdsa","fields":[{"name":"pk","type":"0x1::secp256k1::ECDSARawPublicKey"}]},{"name":"Secp256r1Ecdsa","fields":[{"name":"pk","type":"0x1::secp256r1::ECDSARawPublicKey"}]},{"name":"Keyless","fields":[{"name":"pk","type":"0x1::keyless::PublicKey"}]},{"name":"FederatedKeyless","fields":[{"name":"pk","type":"0x1::federated_keyless::PublicKey"}]}]}]}},{"abi":{"address":"0x1","name":"ordered_map","friends":["0x1::big_ordered_map"],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["bool"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["T1"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":[],"return":["0x1::ordered_map::OrderedMap<T0, T1>"]},{"name":"append","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","0x1::ordered_map::OrderedMap<T0, T1>"],"return":[]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["&T1"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["&mut T1"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::ordered_map::OrderedMap<T0, T1>"],"return":[]},{"name":"is_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["bool"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["u64"]},{"name":"pop_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>"],"return":["T0","T1"]},{"name":"trim","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","u64"],"return":["0x1::ordered_map::OrderedMap<T0, T1>"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","T0","T1"],"return":[]},{"name":"upsert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","T0","T1"],"return":["0x1::option::Option<T1>"]},{"name":"add_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","vector<T0>","vector<T1>"],"return":[]},{"name":"keys","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy"]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["vector<T0>"]},{"name":"values","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":["copy"]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["vector<T1>"]},{"name":"append_disjoint","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","0x1::ordered_map::OrderedMap<T0, T1>"],"return":[]},{"name":"borrow_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["&T0","&T1"]},{"name":"borrow_front","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["&T0","&T1"]},{"name":"get","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["copy","store"]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T1>"]},{"name":"internal_find","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["0x1::ordered_map::IteratorPtr"]},{"name":"internal_lower_bound","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["0x1::ordered_map::IteratorPtr"]},{"name":"internal_new_begin_iter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["0x1::ordered_map::IteratorPtr"]},{"name":"internal_new_end_iter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["0x1::ordered_map::IteratorPtr"]},{"name":"iter_add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::ordered_map::IteratorPtr","&mut 0x1::ordered_map::OrderedMap<T0, T1>","T0","T1"],"return":[]},{"name":"iter_borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::ordered_map::IteratorPtr","&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["&T1"]},{"name":"iter_borrow_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::IteratorPtr","&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["&T0"]},{"name":"iter_borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::ordered_map::IteratorPtr","&mut 0x1::ordered_map::OrderedMap<T0, T1>"],"return":["&mut T1"]},{"name":"iter_is_begin","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::IteratorPtr","&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["bool"]},{"name":"iter_is_begin_from_non_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ordered_map::IteratorPtr"],"return":["bool"]},{"name":"iter_is_end","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::ordered_map::IteratorPtr","&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["bool"]},{"name":"iter_next","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::ordered_map::IteratorPtr","&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["0x1::ordered_map::IteratorPtr"]},{"name":"iter_prev","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::ordered_map::IteratorPtr","&0x1::ordered_map::OrderedMap<T0, T1>"],"return":["0x1::ordered_map::IteratorPtr"]},{"name":"iter_remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["0x1::ordered_map::IteratorPtr","&mut 0x1::ordered_map::OrderedMap<T0, T1>"],"return":["T1"]},{"name":"iter_replace","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["0x1::ordered_map::IteratorPtr","&mut 0x1::ordered_map::OrderedMap<T0, T1>","T1"],"return":["T1"]},{"name":"new_from","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["vector<T0>","vector<T1>"],"return":["0x1::ordered_map::OrderedMap<T0, T1>"]},{"name":"next_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy"]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T0>"]},{"name":"pop_front","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>"],"return":["T0","T1"]},{"name":"prev_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy"]},{"constraints":[]}],"params":["&0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T0>"]},{"name":"remove_or_none","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T1>"]},{"name":"replace_key_inplace","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","&T0","T0"],"return":[]},{"name":"to_vec_pair","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::ordered_map::OrderedMap<T0, T1>"],"return":["vector<T0>","vector<T1>"]},{"name":"upsert_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::ordered_map::OrderedMap<T0, T1>","vector<T0>","vector<T1>"],"return":[]}],"structs":[{"name":"Entry","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[{"name":"key","type":"T0"},{"name":"value","type":"T1"}],"variants":[]},{"name":"IteratorPtr","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"End","fields":[]},{"name":"Position","fields":[{"name":"index","type":"u64"}]}]},{"name":"OrderedMap","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[],"variants":[{"name":"SortedVectorMap","fields":[{"name":"entries","type":"vector<0x1::ordered_map::Entry<T0, T1>>"}]}]}]}},{"abi":{"address":"0x1","name":"smart_table","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["&0x1::smart_table::SmartTable<T0, T1>","T0"],"return":["bool"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","T0"],"return":["T1"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":[],"return":["0x1::smart_table::SmartTable<T0, T1>"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["&0x1::smart_table::SmartTable<T0, T1>","T0"],"return":["&T1"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":[]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","T0"],"return":["&mut T1"]},{"name":"destroy","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":["drop"]}],"params":["0x1::smart_table::SmartTable<T0, T1>"],"return":[]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["0x1::smart_table::SmartTable<T0, T1>"],"return":[]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::smart_table::SmartTable<T0, T1>"],"return":["u64"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","T0","T1"],"return":[]},{"name":"borrow_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::smart_table::SmartTable<T0, T1>","T0","&T1"],"return":["&T1"]},{"name":"borrow_mut_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","T0","T1"],"return":["&mut T1"]},{"name":"upsert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","T0","T1"],"return":[]},{"name":"num_buckets","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::smart_table::SmartTable<T0, T1>"],"return":["u64"]},{"name":"add_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","vector<T0>","vector<T1>"],"return":[]},{"name":"keys","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["copy","store"]}],"params":["&0x1::smart_table::SmartTable<T0, T1>"],"return":["vector<T0>"]},{"name":"borrow_buckets","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::smart_table::SmartTable<T0, T1>"],"return":["&0x1::table_with_length::TableWithLength<u64, vector<0x1::smart_table::Entry<T0, T1>>>"]},{"name":"borrow_buckets_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>"],"return":["&mut 0x1::table_with_length::TableWithLength<u64, vector<0x1::smart_table::Entry<T0, T1>>>"]},{"name":"borrow_kv","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::smart_table::Entry<T0, T1>"],"return":["&T0","&T1"]},{"name":"borrow_kv_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::smart_table::Entry<T0, T1>"],"return":["&mut T0","&mut T1"]},{"name":"clear","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>"],"return":[]},{"name":"keys_paginated","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["copy","store"]}],"params":["&0x1::smart_table::SmartTable<T0, T1>","u64","u64","u64"],"return":["vector<T0>","0x1::option::Option<u64>","0x1::option::Option<u64>"]},{"name":"load_factor","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::smart_table::SmartTable<T0, T1>"],"return":["u64"]},{"name":"new_with_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["u64","u8","u64"],"return":["0x1::smart_table::SmartTable<T0, T1>"]},{"name":"to_simple_map","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["copy","store"]}],"params":["&0x1::smart_table::SmartTable<T0, T1>"],"return":["0x1::simple_map::SimpleMap<T0, T1>"]},{"name":"update_split_load_threshold","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","u8"],"return":[]},{"name":"update_target_bucket_size","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&mut 0x1::smart_table::SmartTable<T0, T1>","u64"],"return":[]}],"structs":[{"name":"Entry","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[{"name":"hash","type":"u64"},{"name":"key","type":"T0"},{"name":"value","type":"T1"}],"variants":[]},{"name":"SmartTable","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[{"name":"buckets","type":"0x1::table_with_length::TableWithLength<u64, vector<0x1::smart_table::Entry<T0, T1>>>"},{"name":"num_buckets","type":"u64"},{"name":"level","type":"u8"},{"name":"size","type":"u64"},{"name":"split_load_threshold","type":"u8"},{"name":"target_bucket_size","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"storage_gas","friends":["0x1::reconfiguration","0x1::gas_schedule","0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"on_reconfig","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"base_8192_exponential_curve","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["0x1::storage_gas::GasCurve"]},{"name":"new_gas_curve","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64","vector<0x1::storage_gas::Point>"],"return":["0x1::storage_gas::GasCurve"]},{"name":"new_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["0x1::storage_gas::Point"]},{"name":"new_storage_gas_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::storage_gas::UsageGasConfig","0x1::storage_gas::UsageGasConfig"],"return":["0x1::storage_gas::StorageGasConfig"]},{"name":"new_usage_gas_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","0x1::storage_gas::GasCurve","0x1::storage_gas::GasCurve","0x1::storage_gas::GasCurve"],"return":["0x1::storage_gas::UsageGasConfig"]},{"name":"set_config","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::storage_gas::StorageGasConfig"],"return":[]}],"structs":[{"name":"GasCurve","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"min_gas","type":"u64"},{"name":"max_gas","type":"u64"},{"name":"points","type":"vector<0x1::storage_gas::Point>"}],"variants":[]},{"name":"Point","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"x","type":"u64"},{"name":"y","type":"u64"}],"variants":[]},{"name":"StorageGas","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"per_item_read","type":"u64"},{"name":"per_item_create","type":"u64"},{"name":"per_item_write","type":"u64"},{"name":"per_byte_read","type":"u64"},{"name":"per_byte_create","type":"u64"},{"name":"per_byte_write","type":"u64"}],"variants":[]},{"name":"StorageGasConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","key"],"generic_type_params":[],"fields":[{"name":"item_config","type":"0x1::storage_gas::UsageGasConfig"},{"name":"byte_config","type":"0x1::storage_gas::UsageGasConfig"}],"variants":[]},{"name":"UsageGasConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"target_usage","type":"u64"},{"name":"read_curve","type":"0x1::storage_gas::GasCurve"},{"name":"create_curve","type":"0x1::storage_gas::GasCurve"},{"name":"write_curve","type":"0x1::storage_gas::GasCurve"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"chain_status","friends":["0x1::genesis"],"exposed_functions":[{"name":"assert_genesis","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"assert_operating","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"is_genesis","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_operating","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"set_genesis_end","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]}],"structs":[{"name":"GenesisEndMarker","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"copyable_any","friends":[],"exposed_functions":[{"name":"type_name","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::copyable_any::Any"],"return":["&0x1::string::String"]},{"name":"pack","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["T0"],"return":["0x1::copyable_any::Any"]},{"name":"unpack","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::copyable_any::Any"],"return":["T0"]}],"structs":[{"name":"Any","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"type_name","type":"0x1::string::String"},{"name":"data","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"gas_schedule","friends":["0x1::reconfiguration_with_dkg","0x1::genesis"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"set_for_next_epoch_check_hash","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>"],"return":[]},{"name":"set_gas_schedule","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"set_storage_gas_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::storage_gas::StorageGasConfig"],"return":[]},{"name":"set_storage_gas_config_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::storage_gas::StorageGasConfig"],"return":[]}],"structs":[{"name":"GasEntry","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"key","type":"0x1::string::String"},{"name":"val","type":"u64"}],"variants":[]},{"name":"GasSchedule","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","key"],"generic_type_params":[],"fields":[{"name":"entries","type":"vector<0x1::gas_schedule::GasEntry>"}],"variants":[]},{"name":"GasScheduleV2","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"feature_version","type":"u64"},{"name":"entries","type":"vector<0x1::gas_schedule::GasEntry>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"managed_coin","friends":[],"exposed_functions":[{"name":"initialize","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","vector<u8>","vector<u8>","u8","bool"],"return":[]},{"name":"burn","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","u64"],"return":[]},{"name":"mint","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","address","u64"],"return":[]},{"name":"register","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer"],"return":[]},{"name":"destroy_caps","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer"],"return":[]},{"name":"remove_caps","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer"],"return":["0x1::coin::BurnCapability<T0>","0x1::coin::FreezeCapability<T0>","0x1::coin::MintCapability<T0>"]}],"structs":[{"name":"Capabilities","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"burn_cap","type":"0x1::coin::BurnCapability<T0>"},{"name":"freeze_cap","type":"0x1::coin::FreezeCapability<T0>"},{"name":"mint_cap","type":"0x1::coin::MintCapability<T0>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"math_fixed64","friends":[],"exposed_functions":[{"name":"mul_div","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"pow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","u64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"sqrt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"exp","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"ln_plus_32ln2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"log2_plus_64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]}],"structs":[]}},{"abi":{"address":"0x1","name":"rate_limiter","friends":[],"exposed_functions":[{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["0x1::rate_limiter::RateLimiter"]},{"name":"request","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::rate_limiter::RateLimiter","u64"],"return":["bool"]}],"structs":[{"name":"RateLimiter","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[],"variants":[{"name":"TokenBucket","fields":[{"name":"capacity","type":"u64"},{"name":"current_amount","type":"u64"},{"name":"refill_interval","type":"u64"},{"name":"last_refill_timestamp","type":"u64"},{"name":"fractional_accumulated","type":"u64"}]}]}]}},{"abi":{"address":"0x1","name":"ristretto255","friends":[],"exposed_functions":[{"name":"multi_scalar_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<0x1::ristretto255::RistrettoPoint>","&vector<0x1::ristretto255::Scalar>"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"scalar_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255::Scalar"]},{"name":"basepoint","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"basepoint_H","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"basepoint_H_compressed","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"basepoint_compressed","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"basepoint_double_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"basepoint_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"compressed_point_equals","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::CompressedRistretto","&0x1::ristretto255::CompressedRistretto"],"return":["bool"]},{"name":"compressed_point_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::CompressedRistretto"],"return":["vector<u8>"]},{"name":"double_scalar_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::Scalar","&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"hash_to_point_base","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"is_identity","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::CompressedRistretto"],"return":["bool"]},{"name":"new_compressed_point_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255::CompressedRistretto>"]},{"name":"new_point_and_compressed_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ristretto255::RistrettoPoint","0x1::ristretto255::CompressedRistretto"]},{"name":"new_point_from_64_uniform_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255::RistrettoPoint>"]},{"name":"new_point_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255::RistrettoPoint>"]},{"name":"new_point_from_sha2_512","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"new_point_from_sha512","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"new_scalar_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255::Scalar>"]},{"name":"new_scalar_from_sha2_512","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ristretto255::Scalar"]},{"name":"new_scalar_from_sha512","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ristretto255::Scalar"]},{"name":"new_scalar_from_u128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128"],"return":["0x1::ristretto255::Scalar"]},{"name":"new_scalar_from_u32","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u32"],"return":["0x1::ristretto255::Scalar"]},{"name":"new_scalar_from_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::ristretto255::Scalar"]},{"name":"new_scalar_from_u8","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u8"],"return":["0x1::ristretto255::Scalar"]},{"name":"new_scalar_reduced_from_32_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255::Scalar>"]},{"name":"new_scalar_uniform_from_64_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255::Scalar>"]},{"name":"point_add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"point_add_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint"],"return":["&mut 0x1::ristretto255::RistrettoPoint"]},{"name":"point_clone","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"point_compress","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"point_decompress","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::CompressedRistretto"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"point_equals","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint"],"return":["bool"]},{"name":"point_identity","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"point_identity_compressed","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"point_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"point_mul_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::Scalar"],"return":["&mut 0x1::ristretto255::RistrettoPoint"]},{"name":"point_neg","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"point_neg_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::RistrettoPoint"],"return":["&mut 0x1::ristretto255::RistrettoPoint"]},{"name":"point_sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"point_sub_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint"],"return":["&mut 0x1::ristretto255::RistrettoPoint"]},{"name":"point_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::CompressedRistretto"],"return":["vector<u8>"]},{"name":"points_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<0x1::ristretto255::RistrettoPoint>"],"return":["vector<vector<u8>>"]},{"name":"scalar_add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255::Scalar"]},{"name":"scalar_add_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["&mut 0x1::ristretto255::Scalar"]},{"name":"scalar_equals","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["bool"]},{"name":"scalar_invert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar"],"return":["0x1::option::Option<0x1::ristretto255::Scalar>"]},{"name":"scalar_is_one","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar"],"return":["bool"]},{"name":"scalar_is_zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar"],"return":["bool"]},{"name":"scalar_mul_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["&mut 0x1::ristretto255::Scalar"]},{"name":"scalar_neg","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255::Scalar"]},{"name":"scalar_neg_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::Scalar"],"return":["&mut 0x1::ristretto255::Scalar"]},{"name":"scalar_one","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::Scalar"]},{"name":"scalar_sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255::Scalar"]},{"name":"scalar_sub_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["&mut 0x1::ristretto255::Scalar"]},{"name":"scalar_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar"],"return":["vector<u8>"]},{"name":"scalar_zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::Scalar"]}],"structs":[{"name":"CompressedRistretto","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"data","type":"vector<u8>"}],"variants":[]},{"name":"RistrettoPoint","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"handle","type":"u64"}],"variants":[]},{"name":"Scalar","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"data","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"smart_vector","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::smart_vector::SmartVector<T0>","&T0"],"return":["bool"]},{"name":"index_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::smart_vector::SmartVector<T0>","&T0"],"return":["bool","u64"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>","u64"],"return":["T0"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":[],"return":["0x1::smart_vector::SmartVector<T0>"]},{"name":"swap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>","u64","u64"],"return":[]},{"name":"append","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>","0x1::smart_vector::SmartVector<T0>"],"return":[]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::smart_vector::SmartVector<T0>","u64"],"return":["&T0"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>","u64"],"return":["&mut T0"]},{"name":"destroy","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["0x1::smart_vector::SmartVector<T0>"],"return":[]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::smart_vector::SmartVector<T0>"],"return":[]},{"name":"empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":[],"return":["0x1::smart_vector::SmartVector<T0>"]},{"name":"is_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::smart_vector::SmartVector<T0>"],"return":["bool"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::smart_vector::SmartVector<T0>"],"return":["u64"]},{"name":"pop_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>"],"return":["T0"]},{"name":"push_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>","T0"],"return":[]},{"name":"reverse","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>"],"return":[]},{"name":"singleton","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["T0"],"return":["0x1::smart_vector::SmartVector<T0>"]},{"name":"swap_remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>","u64"],"return":["T0"]},{"name":"to_vector","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","store"]}],"params":["&0x1::smart_vector::SmartVector<T0>"],"return":["vector<T0>"]},{"name":"add_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>","vector<T0>"],"return":[]},{"name":"clear","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["&mut 0x1::smart_vector::SmartVector<T0>"],"return":[]},{"name":"empty_with_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["u64","u64"],"return":["0x1::smart_vector::SmartVector<T0>"]}],"structs":[{"name":"SmartVector","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"inline_vec","type":"vector<T0>"},{"name":"big_vec","type":"0x1::option::Option<0x1::big_vector::BigVector<T0>>"},{"name":"inline_capacity","type":"0x1::option::Option<u64>"},{"name":"bucket_size","type":"0x1::option::Option<u64>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"storage_slot","friends":[],"exposed_functions":[{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["T0"],"return":["0x1::storage_slot::StorageSlot<T0>"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&0x1::storage_slot::StorageSlot<T0>"],"return":["&T0"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slot::StorageSlot<T0>"],"return":["&mut T0"]},{"name":"destroy","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["0x1::storage_slot::StorageSlot<T0>"],"return":["T0"]},{"name":"copy_storage_slot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","store"]}],"params":["&0x1::storage_slot::StorageSlot<T0>"],"return":["0x1::storage_slot::StorageSlot<T0>"]}],"structs":[{"name":"StorageSlot","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"addr","type":"address"}],"variants":[]},{"name":"StorageSlotResource","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"val","type":"T0"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"string_utils","friends":[],"exposed_functions":[{"name":"to_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["0x1::string::String"]},{"name":"debug_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["0x1::string::String"]},{"name":"format1","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["&vector<u8>","T0"],"return":["0x1::string::String"]},{"name":"format2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":["drop"]}],"params":["&vector<u8>","T0","T1"],"return":["0x1::string::String"]},{"name":"format3","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":["drop"]},{"constraints":["drop"]}],"params":["&vector<u8>","T0","T1","T2"],"return":["0x1::string::String"]},{"name":"format4","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]},{"constraints":["drop"]},{"constraints":["drop"]},{"constraints":["drop"]}],"params":["&vector<u8>","T0","T1","T2","T3"],"return":["0x1::string::String"]},{"name":"to_string_with_canonical_addresses","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["0x1::string::String"]},{"name":"to_string_with_integer_types","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&T0"],"return":["0x1::string::String"]}],"structs":[{"name":"Cons","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[{"name":"car","type":"T0"},{"name":"cdr","type":"T1"}],"variants":[]},{"name":"FakeCons","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]},{"constraints":[]}],"fields":[{"name":"car","type":"T0"},{"name":"cdr","type":"T1"}],"variants":[]},{"name":"NIL","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"aggregator_v2","friends":[],"exposed_functions":[{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::aggregator_v2::Aggregator<T0>","T0"],"return":[]},{"name":"read","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::aggregator_v2::Aggregator<T0>"],"return":["T0"]},{"name":"sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::aggregator_v2::Aggregator<T0>","T0"],"return":[]},{"name":"create_aggregator","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":["T0"],"return":["0x1::aggregator_v2::Aggregator<T0>"]},{"name":"copy_snapshot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":["&0x1::aggregator_v2::AggregatorSnapshot<T0>"],"return":["0x1::aggregator_v2::AggregatorSnapshot<T0>"]},{"name":"snapshot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::aggregator_v2::Aggregator<T0>"],"return":["0x1::aggregator_v2::AggregatorSnapshot<T0>"]},{"name":"max_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":["&0x1::aggregator_v2::Aggregator<T0>"],"return":["T0"]},{"name":"create_aggregator_with_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":["T0","T0"],"return":["0x1::aggregator_v2::Aggregator<T0>"]},{"name":"create_derived_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::string::String"],"return":["0x1::aggregator_v2::DerivedStringSnapshot"]},{"name":"create_snapshot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":["T0"],"return":["0x1::aggregator_v2::AggregatorSnapshot<T0>"]},{"name":"create_unbounded_aggregator","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":[],"return":["0x1::aggregator_v2::Aggregator<T0>"]},{"name":"create_unbounded_aggregator_with_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]}],"params":["T0"],"return":["0x1::aggregator_v2::Aggregator<T0>"]},{"name":"derive_string_concat","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::string::String","&0x1::aggregator_v2::AggregatorSnapshot<T0>","0x1::string::String"],"return":["0x1::aggregator_v2::DerivedStringSnapshot"]},{"name":"is_at_least","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::aggregator_v2::Aggregator<T0>","T0"],"return":["bool"]},{"name":"read_derived_string","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::aggregator_v2::DerivedStringSnapshot"],"return":["0x1::string::String"]},{"name":"read_snapshot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::aggregator_v2::AggregatorSnapshot<T0>"],"return":["T0"]},{"name":"string_concat","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::string::String","&0x1::aggregator_v2::AggregatorSnapshot<T0>","0x1::string::String"],"return":["0x1::aggregator_v2::AggregatorSnapshot<0x1::string::String>"]},{"name":"try_add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::aggregator_v2::Aggregator<T0>","T0"],"return":["bool"]},{"name":"try_sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::aggregator_v2::Aggregator<T0>","T0"],"return":["bool"]}],"structs":[{"name":"Aggregator","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"value","type":"T0"},{"name":"max_value","type":"T0"}],"variants":[]},{"name":"AggregatorSnapshot","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"value","type":"T0"}],"variants":[]},{"name":"DerivedStringSnapshot","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"value","type":"0x1::string::String"},{"name":"padding","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"aptos_account","friends":["0x1::transaction_fee","0x1::transaction_validation","0x1::genesis","0x1::resource_account"],"exposed_functions":[{"name":"create_account","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"assert_account_exists","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"assert_account_is_registered_for_apt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"batch_transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","vector<u64>"],"return":[]},{"name":"batch_transfer_coins","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","vector<address>","vector<u64>"],"return":[]},{"name":"batch_transfer_fungible_assets","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","vector<address>","vector<u64>"],"return":[]},{"name":"burn_from_fungible_store_for_gas","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::BurnRef","address","u64"],"return":[]},{"name":"can_receive_direct_coin_transfers","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"deposit_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["address","0x1::coin::Coin<T0>"],"return":[]},{"name":"deposit_fungible_assets","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"fungible_transfer_only","visibility":"friend","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"is_fungible_balance_at_least","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":["bool"]},{"name":"register_apt","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set_allow_direct_coin_transfers","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]},{"name":"transfer_coins","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&signer","address","u64"],"return":[]},{"name":"transfer_fungible_assets","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","address","u64"],"return":[]}],"structs":[{"name":"DirectCoinTransferConfigUpdated","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"new_allow_direct_transfers","type":"bool"}],"variants":[]},{"name":"DirectCoinTransferConfigUpdatedEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"new_allow_direct_transfers","type":"bool"}],"variants":[]},{"name":"DirectTransferConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"allow_arbitrary_coin_transfers","type":"bool"},{"name":"update_coin_transfer_events","type":"0x1::event::EventHandle<0x1::aptos_account::DirectCoinTransferConfigUpdatedEvent>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"bn254_algebra","friends":[],"exposed_functions":[],"structs":[{"name":"FormatFq12LscLsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatFrLsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatFrMsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG1Compr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG1Uncompr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG2Compr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG2Uncompr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatGt","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Fq12","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Fr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"G1","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"G2","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Gt","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatFqLsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatFqMsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Fq","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"config_buffer","friends":["0x1::version","0x1::randomness_config_seqnum","0x1::randomness_config","0x1::randomness_api_v0_config","0x1::keyless_account","0x1::jwks","0x1::jwk_consensus_config","0x1::gas_schedule","0x1::execution_config","0x1::epoch_timeout_config","0x1::decryption","0x1::consensus_config","0x1::chunky_dkg_config_seqnum","0x1::chunky_dkg_config"],"exposed_functions":[{"name":"extract","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":[],"return":["T0"]},{"name":"upsert","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]}],"params":["T0"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"does_exist","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":[],"return":["bool"]},{"name":"extract_v2","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":[],"return":["T0"]}],"structs":[{"name":"PendingConfigs","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"configs","type":"0x1::simple_map::SimpleMap<0x1::string::String, 0x1::any::Any>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"create_signer","friends":["0x1::permissioned_signer","0x1::account","0x1::object","0x1::account_abstraction","0x1::fungible_asset","0x1::coin","0x1::aptos_account","0x1::stake","0x1::reconfiguration_with_dkg","0x1::transaction_validation","0x1::genesis","0x1::multisig_account"],"exposed_functions":[{"name":"create_signer","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["signer"]}],"structs":[]}},{"abi":{"address":"0x1","name":"fixed_point32","friends":[],"exposed_functions":[{"name":"ceil","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["u64"]},{"name":"create_from_rational","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"create_from_raw_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"create_from_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"divide_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","0x1::fixed_point32::FixedPoint32"],"return":["u64"]},{"name":"floor","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["u64"]},{"name":"get_raw_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["u64"]},{"name":"is_zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["bool"]},{"name":"max","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32","0x1::fixed_point32::FixedPoint32"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"min","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32","0x1::fixed_point32::FixedPoint32"],"return":["0x1::fixed_point32::FixedPoint32"]},{"name":"multiply_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","0x1::fixed_point32::FixedPoint32"],"return":["u64"]},{"name":"round","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point32::FixedPoint32"],"return":["u64"]}],"structs":[{"name":"FixedPoint32","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"value","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"fixed_point64","friends":[],"exposed_functions":[{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"ceil","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["u128"]},{"name":"create_from_rational","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","u128"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"create_from_raw_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"floor","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["u128"]},{"name":"get_raw_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["u128"]},{"name":"is_zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["bool"]},{"name":"max","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"min","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"round","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64"],"return":["u128"]},{"name":"almost_equal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["bool"]},{"name":"create_from_u128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128"],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"divide_u128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","0x1::fixed_point64::FixedPoint64"],"return":["u128"]},{"name":"equal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["bool"]},{"name":"greater","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["bool"]},{"name":"greater_or_equal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["bool"]},{"name":"less","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["bool"]},{"name":"less_or_equal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["bool"]},{"name":"multiply_u128","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u128","0x1::fixed_point64::FixedPoint64"],"return":["u128"]}],"structs":[{"name":"FixedPoint64","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"value","type":"u128"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"function_info","friends":["0x1::account_abstraction","0x1::fungible_asset","0x1::dispatchable_fungible_asset"],"exposed_functions":[{"name":"check_dispatch_type_compatibility","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::function_info::FunctionInfo","&0x1::function_info::FunctionInfo"],"return":["bool"]},{"name":"load_module_from_function","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::function_info::FunctionInfo"],"return":[]},{"name":"new_function_info","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String","0x1::string::String"],"return":["0x1::function_info::FunctionInfo"]},{"name":"new_function_info_from_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::string::String","0x1::string::String"],"return":["0x1::function_info::FunctionInfo"]}],"structs":[{"name":"FunctionInfo","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"module_address","type":"address"},{"name":"module_name","type":"0x1::string::String"},{"name":"function_name","type":"0x1::string::String"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"multi_ed25519","friends":[],"exposed_functions":[{"name":"signature_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::Signature"],"return":["vector<u8>"]},{"name":"new_signature_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::multi_ed25519::Signature"]},{"name":"new_unvalidated_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::multi_ed25519::UnvalidatedPublicKey"]},{"name":"new_validated_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::multi_ed25519::ValidatedPublicKey>"]},{"name":"public_key_into_unvalidated","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::multi_ed25519::ValidatedPublicKey"],"return":["0x1::multi_ed25519::UnvalidatedPublicKey"]},{"name":"public_key_to_unvalidated","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::ValidatedPublicKey"],"return":["0x1::multi_ed25519::UnvalidatedPublicKey"]},{"name":"public_key_validate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::UnvalidatedPublicKey"],"return":["0x1::option::Option<0x1::multi_ed25519::ValidatedPublicKey>"]},{"name":"signature_verify_strict","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::Signature","&0x1::multi_ed25519::UnvalidatedPublicKey","vector<u8>"],"return":["bool"]},{"name":"signature_verify_strict_t","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop"]}],"params":["&0x1::multi_ed25519::Signature","&0x1::multi_ed25519::UnvalidatedPublicKey","T0"],"return":["bool"]},{"name":"unvalidated_public_key_to_authentication_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::UnvalidatedPublicKey"],"return":["vector<u8>"]},{"name":"unvalidated_public_key_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::UnvalidatedPublicKey"],"return":["vector<u8>"]},{"name":"validated_public_key_to_authentication_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::ValidatedPublicKey"],"return":["vector<u8>"]},{"name":"validated_public_key_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::ValidatedPublicKey"],"return":["vector<u8>"]},{"name":"check_and_get_threshold","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<u8>"]},{"name":"new_validated_public_key_from_bytes_v2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::multi_ed25519::ValidatedPublicKey>"]},{"name":"public_key_validate_v2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::UnvalidatedPublicKey"],"return":["0x1::option::Option<0x1::multi_ed25519::ValidatedPublicKey>"]},{"name":"unvalidated_public_key_num_sub_pks","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::UnvalidatedPublicKey"],"return":["u8"]},{"name":"unvalidated_public_key_threshold","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::UnvalidatedPublicKey"],"return":["0x1::option::Option<u8>"]},{"name":"validated_public_key_num_sub_pks","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::ValidatedPublicKey"],"return":["u8"]},{"name":"validated_public_key_threshold","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::multi_ed25519::ValidatedPublicKey"],"return":["u8"]}],"structs":[{"name":"Signature","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"UnvalidatedPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]},{"name":"ValidatedPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"staking_proxy","friends":[],"exposed_functions":[{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"set_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"set_stake_pool_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"set_stake_pool_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"set_staking_contract_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"set_staking_contract_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"set_vesting_contract_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"set_vesting_contract_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"set_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]}],"structs":[{"name":"StakeProxyPermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"state_storage","friends":["0x1::storage_gas","0x1::reconfiguration","0x1::block","0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"current_items_and_bytes","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64","u64"]},{"name":"on_new_block","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":[]},{"name":"on_reconfig","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]}],"structs":[{"name":"GasParameter","is_native":false,"is_event":false,"is_enum":false,"abilities":["store","key"],"generic_type_params":[],"fields":[{"name":"usage","type":"0x1::state_storage::Usage"}],"variants":[]},{"name":"StateStorageUsage","is_native":false,"is_event":false,"is_enum":false,"abilities":["store","key"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"},{"name":"usage","type":"0x1::state_storage::Usage"}],"variants":[]},{"name":"Usage","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"items","type":"u64"},{"name":"bytes","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"crypto_algebra","friends":[],"exposed_functions":[{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>","&0x1::crypto_algebra::Element<T0>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"serialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>"],"return":["vector<u8>"]},{"name":"deserialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&vector<u8>"],"return":["0x1::option::Option<0x1::crypto_algebra::Element<T0>>"]},{"name":"div","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>","&0x1::crypto_algebra::Element<T0>"],"return":["0x1::option::Option<0x1::crypto_algebra::Element<T0>>"]},{"name":"double","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"downcast","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>"],"return":["0x1::option::Option<0x1::crypto_algebra::Element<T1>>"]},{"name":"eq","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>","&0x1::crypto_algebra::Element<T0>"],"return":["bool"]},{"name":"from_u64","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["u64"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"hash_to","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&vector<u8>","&vector<u8>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"inv","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>"],"return":["0x1::option::Option<0x1::crypto_algebra::Element<T0>>"]},{"name":"mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>","&0x1::crypto_algebra::Element<T0>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"multi_pairing","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]},{"constraints":[]}],"params":["&vector<0x1::crypto_algebra::Element<T0>>","&vector<0x1::crypto_algebra::Element<T1>>"],"return":["0x1::crypto_algebra::Element<T2>"]},{"name":"multi_scalar_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&vector<0x1::crypto_algebra::Element<T0>>","&vector<0x1::crypto_algebra::Element<T1>>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"neg","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"one","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"order","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["vector<u8>"]},{"name":"pairing","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]},{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>","&0x1::crypto_algebra::Element<T1>"],"return":["0x1::crypto_algebra::Element<T2>"]},{"name":"scalar_mul","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>","&0x1::crypto_algebra::Element<T1>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"sqr","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>","&0x1::crypto_algebra::Element<T0>"],"return":["0x1::crypto_algebra::Element<T0>"]},{"name":"upcast","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]},{"constraints":[]}],"params":["&0x1::crypto_algebra::Element<T0>"],"return":["0x1::crypto_algebra::Element<T1>"]},{"name":"zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::crypto_algebra::Element<T0>"]}],"structs":[{"name":"Element","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"handle","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"fungible_asset","friends":["0x1::dispatchable_fungible_asset","0x1::primary_fungible_store","0x1::coin","0x1::aptos_account"],"exposed_functions":[{"name":"extract","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::fungible_asset::FungibleAsset","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"merge","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::fungible_asset::FungibleAsset","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"revoke_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":[]},{"name":"burn","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::BurnRef","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"name","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::string::String"]},{"name":"generate_transfer_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::fungible_asset::TransferRef"]},{"name":"is_untransferable","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["bool"]},{"name":"set_untransferable","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":[]},{"name":"transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","0x1::object::Object<T0>","u64"],"return":[]},{"name":"transfer_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::TransferRef","0x1::object::Object<T0>","0x1::object::Object<T0>","u64"],"return":[]},{"name":"add_fungibility","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef","0x1::option::Option<u128>","0x1::string::String","0x1::string::String","u8","0x1::string::String","0x1::string::String"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"symbol","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::string::String"]},{"name":"decimals","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["u8"]},{"name":"icon_uri","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::string::String"]},{"name":"project_uri","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::string::String"]},{"name":"address_burn_from_for_gas","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::BurnRef","address","u64"],"return":[]},{"name":"amount","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::FungibleAsset"],"return":["u64"]},{"name":"asset_metadata","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::FungibleAsset"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"balance","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["u64"]},{"name":"balance_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::RawBalanceRef","0x1::object::Object<T0>"],"return":["u64"]},{"name":"metadata","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::fungible_asset::Metadata"]},{"name":"burn_from","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::BurnRef","0x1::object::Object<T0>","u64"],"return":[]},{"name":"burn_internal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fungible_asset::FungibleAsset"],"return":["u64"]},{"name":"burn_ref_metadata","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::BurnRef"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"create_store","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::object::ConstructorRef","0x1::object::Object<T0>"],"return":["0x1::object::Object<0x1::fungible_asset::FungibleStore>"]},{"name":"deposit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"deposit_dispatch_function","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::option::Option<0x1::function_info::FunctionInfo>"]},{"name":"deposit_sanity_check","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","bool"],"return":[]},{"name":"deposit_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::TransferRef","0x1::object::Object<T0>","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"derived_balance_dispatch_function","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::option::Option<0x1::function_info::FunctionInfo>"]},{"name":"derived_supply_dispatch_function","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::option::Option<0x1::function_info::FunctionInfo>"]},{"name":"destroy_zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"generate_burn_copy_ref","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::BurnRef"],"return":["0x1::fungible_asset::BurnRef"]},{"name":"generate_burn_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::fungible_asset::BurnRef"]},{"name":"generate_mint_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::fungible_asset::MintRef"]},{"name":"generate_mutate_metadata_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::fungible_asset::MutateMetadataRef"]},{"name":"generate_raw_balance_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::fungible_asset::RawBalanceRef"]},{"name":"generate_raw_supply_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef"],"return":["0x1::fungible_asset::RawSupplyRef"]},{"name":"grant_permission_by_address","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer","address","u64"],"return":[]},{"name":"grant_permission_by_store","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","&signer","0x1::object::Object<T0>","u64"],"return":[]},{"name":"is_address_balance_at_least","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":["bool"]},{"name":"is_asset_type_dispatchable","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["bool"]},{"name":"is_balance_at_least","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","u64"],"return":["bool"]},{"name":"is_frozen","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["bool"]},{"name":"is_store_dispatchable","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["bool"]},{"name":"maximum","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::option::Option<u128>"]},{"name":"metadata_from_asset","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::FungibleAsset"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"mint","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::MintRef","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"mint_internal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::object::Object<0x1::fungible_asset::Metadata>","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"mint_ref_metadata","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::MintRef"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"mint_to","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::MintRef","0x1::object::Object<T0>","u64"],"return":[]},{"name":"mutate_metadata","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::MutateMetadataRef","0x1::option::Option<0x1::string::String>","0x1::option::Option<0x1::string::String>","0x1::option::Option<u8>","0x1::option::Option<0x1::string::String>","0x1::option::Option<0x1::string::String>"],"return":[]},{"name":"object_from_metadata_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::MutateMetadataRef"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"refill_permission","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64","address"],"return":[]},{"name":"register_derive_supply_dispatch_function","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef","0x1::option::Option<0x1::function_info::FunctionInfo>"],"return":[]},{"name":"register_dispatch_functions","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef","0x1::option::Option<0x1::function_info::FunctionInfo>","0x1::option::Option<0x1::function_info::FunctionInfo>","0x1::option::Option<0x1::function_info::FunctionInfo>"],"return":[]},{"name":"remove_store","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::DeleteRef"],"return":[]},{"name":"set_frozen_flag","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::TransferRef","0x1::object::Object<T0>","bool"],"return":[]},{"name":"set_frozen_flag_internal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","bool"],"return":[]},{"name":"store_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"store_metadata","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"supply","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::option::Option<u128>"]},{"name":"supply_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::RawSupplyRef","0x1::object::Object<T0>"],"return":["0x1::option::Option<u128>"]},{"name":"transfer_ref_metadata","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::TransferRef"],"return":["0x1::object::Object<0x1::fungible_asset::Metadata>"]},{"name":"unchecked_deposit","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"unchecked_deposit_with_no_events","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"unchecked_withdraw","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"upgrade_store_to_concurrent","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>"],"return":[]},{"name":"upgrade_to_concurrent","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ExtendRef"],"return":[]},{"name":"withdraw","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"withdraw_dispatch_function","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::option::Option<0x1::function_info::FunctionInfo>"]},{"name":"withdraw_permission_check","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","u64"],"return":[]},{"name":"withdraw_permission_check_by_address","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"withdraw_sanity_check","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","bool"],"return":[]},{"name":"withdraw_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&0x1::fungible_asset::TransferRef","0x1::object::Object<T0>","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"zero","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::fungible_asset::FungibleAsset"]}],"structs":[{"name":"TransferRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"Untransferable","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"BurnRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"ConcurrentFungibleBalance","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"balance","type":"0x1::aggregator_v2::Aggregator<u64>"}],"variants":[]},{"name":"ConcurrentSupply","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"current","type":"0x1::aggregator_v2::Aggregator<u128>"}],"variants":[]},{"name":"Creation","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"address"},{"name":"name","type":"0x1::string::String"},{"name":"symbol","type":"0x1::string::String"},{"name":"decimals","type":"u8"},{"name":"icon_uri","type":"0x1::string::String"},{"name":"project_uri","type":"0x1::string::String"},{"name":"maximum_supply","type":"0x1::option::Option<u128>"}],"variants":[]},{"name":"Deposit","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"store","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"DepositEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"amount","type":"u64"}],"variants":[]},{"name":"DeriveSupply","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dispatch_function","type":"0x1::option::Option<0x1::function_info::FunctionInfo>"}],"variants":[]},{"name":"DispatchFunctionStore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"withdraw_function","type":"0x1::option::Option<0x1::function_info::FunctionInfo>"},{"name":"deposit_function","type":"0x1::option::Option<0x1::function_info::FunctionInfo>"},{"name":"derived_balance_function","type":"0x1::option::Option<0x1::function_info::FunctionInfo>"}],"variants":[]},{"name":"Frozen","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"store","type":"address"},{"name":"frozen","type":"bool"}],"variants":[]},{"name":"FrozenEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"frozen","type":"bool"}],"variants":[]},{"name":"FungibleAsset","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"FungibleAssetEvents","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"deposit_events","type":"0x1::event::EventHandle<0x1::fungible_asset::DepositEvent>"},{"name":"withdraw_events","type":"0x1::event::EventHandle<0x1::fungible_asset::WithdrawEvent>"},{"name":"frozen_events","type":"0x1::event::EventHandle<0x1::fungible_asset::FrozenEvent>"}],"variants":[]},{"name":"FungibleStore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"balance","type":"u64"},{"name":"frozen","type":"bool"}],"variants":[]},{"name":"FungibleStoreDeletion","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"store","type":"address"},{"name":"owner","type":"address"},{"name":"metadata","type":"address"}],"variants":[]},{"name":"Metadata","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","key"],"generic_type_params":[],"fields":[{"name":"name","type":"0x1::string::String"},{"name":"symbol","type":"0x1::string::String"},{"name":"decimals","type":"u8"},{"name":"icon_uri","type":"0x1::string::String"},{"name":"project_uri","type":"0x1::string::String"}],"variants":[]},{"name":"MintRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"MutateMetadataRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"RawBalanceRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"RawSupplyRef","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"metadata","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]},{"name":"Supply","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"current","type":"u128"},{"name":"maximum","type":"0x1::option::Option<u128>"}],"variants":[]},{"name":"Withdraw","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"store","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"WithdrawEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"amount","type":"u64"}],"variants":[]},{"name":"WithdrawPermission","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"ByStore","fields":[{"name":"store_address","type":"address"}]}]}]}},{"abi":{"address":"0x1","name":"sigma_protocol","friends":["0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[],"structs":[]}},{"abi":{"address":"0x1","name":"staking_config","friends":["0x1::stake","0x1::genesis"],"exposed_functions":[{"name":"get","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::staking_config::StakingConfig"]},{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64","u64","u64","bool","u64","u64","u64"],"return":[]},{"name":"calculate_and_save_latest_epoch_rewards_rate","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::fixed_point64::FixedPoint64"]},{"name":"get_allow_validator_set_change","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::staking_config::StakingConfig"],"return":["bool"]},{"name":"get_recurring_lockup_duration","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::staking_config::StakingConfig"],"return":["u64"]},{"name":"get_required_stake","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::staking_config::StakingConfig"],"return":["u64","u64"]},{"name":"get_reward_rate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::staking_config::StakingConfig"],"return":["u64","u64"]},{"name":"get_voting_power_increase_limit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::staking_config::StakingConfig"],"return":["u64"]},{"name":"initialize_rewards","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64","u64","u64","0x1::fixed_point64::FixedPoint64"],"return":[]},{"name":"reward_rate","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64","u64"]},{"name":"update_recurring_lockup_duration_secs","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"update_required_stake","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64","u64"],"return":[]},{"name":"update_rewards_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64","u64","0x1::fixed_point64::FixedPoint64"],"return":[]},{"name":"update_rewards_rate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64","u64"],"return":[]},{"name":"update_voting_power_increase_limit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]}],"structs":[{"name":"StakingConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","key"],"generic_type_params":[],"fields":[{"name":"minimum_stake","type":"u64"},{"name":"maximum_stake","type":"u64"},{"name":"recurring_lockup_duration_secs","type":"u64"},{"name":"allow_validator_set_change","type":"bool"},{"name":"rewards_rate","type":"u64"},{"name":"rewards_rate_denominator","type":"u64"},{"name":"voting_power_increase_limit","type":"u64"}],"variants":[]},{"name":"StakingRewardsConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","key"],"generic_type_params":[],"fields":[{"name":"rewards_rate","type":"0x1::fixed_point64::FixedPoint64"},{"name":"min_rewards_rate","type":"0x1::fixed_point64::FixedPoint64"},{"name":"rewards_rate_period_in_secs","type":"u64"},{"name":"last_rewards_rate_period_start_in_secs","type":"u64"},{"name":"rewards_rate_decrease_rate","type":"0x1::fixed_point64::FixedPoint64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"big_ordered_map","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["bool"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["T1"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":[],"return":["0x1::big_ordered_map::BigOrderedMap<T0, T1>"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["&T1"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["&mut T1"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":[]},{"name":"is_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["bool"]},{"name":"pop_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["T0","T1"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","T0","T1"],"return":[]},{"name":"upsert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","T0","T1"],"return":["0x1::option::Option<T1>"]},{"name":"allocate_spare_slots","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","u64"],"return":[]},{"name":"add_all","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","vector<T0>","vector<T1>"],"return":[]},{"name":"keys","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["vector<T0>"]},{"name":"borrow_back","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["T0","&T1"]},{"name":"borrow_front","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["T0","&T1"]},{"name":"get","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["copy","store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T1>"]},{"name":"internal_find","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["0x1::big_ordered_map::IteratorPtr<T0>"]},{"name":"internal_lower_bound","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["0x1::big_ordered_map::IteratorPtr<T0>"]},{"name":"internal_new_begin_iter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["0x1::big_ordered_map::IteratorPtr<T0>"]},{"name":"internal_new_end_iter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["0x1::big_ordered_map::IteratorPtr<T0>"]},{"name":"iter_borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]},{"constraints":["store"]}],"params":["0x1::big_ordered_map::IteratorPtr<T0>","&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["&T1"]},{"name":"iter_borrow_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::big_ordered_map::IteratorPtr<T0>"],"return":["&T0"]},{"name":"iter_borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]},{"constraints":["store"]}],"params":["0x1::big_ordered_map::IteratorPtr<T0>","&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["&mut T1"]},{"name":"iter_is_begin","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::IteratorPtr<T0>","&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["bool"]},{"name":"iter_is_end","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::IteratorPtr<T0>","&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["bool"]},{"name":"iter_next","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["0x1::big_ordered_map::IteratorPtr<T0>","&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["0x1::big_ordered_map::IteratorPtr<T0>"]},{"name":"iter_prev","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["0x1::big_ordered_map::IteratorPtr<T0>","&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["0x1::big_ordered_map::IteratorPtr<T0>"]},{"name":"iter_remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["0x1::big_ordered_map::IteratorPtrWithPath<T0>","&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["T1"]},{"name":"new_from","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["vector<T0>","vector<T1>"],"return":["0x1::big_ordered_map::BigOrderedMap<T0, T1>"]},{"name":"next_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T0>"]},{"name":"pop_front","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["T0","T1"]},{"name":"prev_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T0>"]},{"name":"remove_or_none","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["0x1::option::Option<T1>"]},{"name":"back_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["T0"]},{"name":"compute_length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["u64"]},{"name":"front_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["T0"]},{"name":"internal_find_with_path","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>","&T0"],"return":["0x1::big_ordered_map::IteratorPtrWithPath<T0>"]},{"name":"internal_leaf_borrow_value","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&0x1::big_ordered_map::Child<T0>"],"return":["&T0"]},{"name":"internal_leaf_iter_borrow_entries_and_next_leaf_index","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["0x1::big_ordered_map::LeafNodeIteratorPtr","&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["&0x1::ordered_map::OrderedMap<T0, 0x1::big_ordered_map::Child<T1>>","0x1::big_ordered_map::LeafNodeIteratorPtr"]},{"name":"internal_leaf_iter_is_end","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::big_ordered_map::LeafNodeIteratorPtr"],"return":["bool"]},{"name":"internal_leaf_new_begin_iter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["0x1::big_ordered_map::LeafNodeIteratorPtr"]},{"name":"iter_modify","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["drop","store"]},{"constraints":["store"]},{"constraints":[]}],"params":["0x1::big_ordered_map::IteratorPtr<T0>","&mut 0x1::big_ordered_map::BigOrderedMap<T0, T1>","|&mut T1|T2"],"return":["T2"]},{"name":"iter_with_path_get_iter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&0x1::big_ordered_map::IteratorPtrWithPath<T0>"],"return":["0x1::big_ordered_map::IteratorPtr<T0>"]},{"name":"new_with_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["u16","u16","bool"],"return":["0x1::big_ordered_map::BigOrderedMap<T0, T1>"]},{"name":"new_with_reusable","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":[],"return":["0x1::big_ordered_map::BigOrderedMap<T0, T1>"]},{"name":"new_with_type_size_hints","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"params":["u64","u64","u64","u64"],"return":["0x1::big_ordered_map::BigOrderedMap<T0, T1>"]},{"name":"to_ordered_map","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]},{"constraints":["copy","store"]}],"params":["&0x1::big_ordered_map::BigOrderedMap<T0, T1>"],"return":["0x1::ordered_map::OrderedMap<T0, T1>"]}],"structs":[{"name":"IteratorPtr","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop"],"generic_type_params":[{"constraints":[]}],"fields":[],"variants":[{"name":"End","fields":[]},{"name":"Some","fields":[{"name":"node_index","type":"u64"},{"name":"child_iter","type":"0x1::ordered_map::IteratorPtr"},{"name":"key","type":"T0"}]}]},{"name":"BigOrderedMap","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"fields":[],"variants":[{"name":"BPlusTreeMap","fields":[{"name":"root","type":"0x1::big_ordered_map::Node<T0, T1>"},{"name":"nodes","type":"0x1::storage_slots_allocator::StorageSlotsAllocator<0x1::big_ordered_map::Node<T0, T1>>"},{"name":"min_leaf_index","type":"u64"},{"name":"max_leaf_index","type":"u64"},{"name":"constant_kv_size","type":"bool"},{"name":"inner_max_degree","type":"u16"},{"name":"leaf_max_degree","type":"u16"}]}]},{"name":"Child","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[{"constraints":["store"]}],"fields":[],"variants":[{"name":"Inner","fields":[{"name":"node_index","type":"0x1::storage_slots_allocator::StoredSlot"}]},{"name":"Leaf","fields":[{"name":"value","type":"T0"}]}]},{"name":"IteratorPtrWithPath","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"iterator","type":"0x1::big_ordered_map::IteratorPtr<T0>"},{"name":"path","type":"vector<u64>"}],"variants":[]},{"name":"LeafNodeIteratorPtr","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"NodeIndex","fields":[{"name":"node_index","type":"u64"}]}]},{"name":"Node","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[{"constraints":["store"]},{"constraints":["store"]}],"fields":[],"variants":[{"name":"V1","fields":[{"name":"is_leaf","type":"bool"},{"name":"children","type":"0x1::ordered_map::OrderedMap<T0, 0x1::big_ordered_map::Child<T1>>"},{"name":"prev","type":"u64"},{"name":"next","type":"u64"}]}]}]}},{"abi":{"address":"0x1","name":"delegation_pool","friends":[],"exposed_functions":[{"name":"partial_governance_voting_enabled","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"withdraw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"create_proposal","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>","vector<u8>","vector<u8>","bool"],"return":[]},{"name":"vote","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64","u64","bool"],"return":[]},{"name":"add_stake","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"get_owned_pool_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"get_stake","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["u64","u64","u64"]},{"name":"owner_cap_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"reactivate_stake","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"set_delegated_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"set_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"unlock","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"multiply_then_divide","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64","u64"],"return":["u64"]},{"name":"allowlist_delegator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"allowlisting_enabled","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"beneficiary_for_operator","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"calculate_and_update_delegator_voter","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["address"]},{"name":"calculate_and_update_remaining_voting_power","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address","u64"],"return":["u64"]},{"name":"calculate_and_update_voter_total_voting_power","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["u64"]},{"name":"calculate_and_update_voting_delegation","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["address","address","u64"]},{"name":"can_withdraw_pending_inactive","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"delegate_voting_power","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"delegation_pool_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"delegator_allowlisted","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["bool"]},{"name":"disable_delegators_allowlisting","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"enable_delegators_allowlisting","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"enable_partial_governance_voting","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"evict_delegator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"get_add_stake_fee","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","u64"],"return":["u64"]},{"name":"get_delegation_pool_stake","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64","u64","u64","u64"]},{"name":"get_delegators_allowlist","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["vector<address>"]},{"name":"get_expected_stake_pool_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","vector<u8>"],"return":["address"]},{"name":"get_pending_withdrawal","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["bool","u64"]},{"name":"grant_delegation_pool_management_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"grant_stake_management_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"initialize_delegation_pool","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64","vector<u8>"],"return":[]},{"name":"operator_commission_percentage","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"is_next_commission_percentage_effective","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"min_remaining_secs_for_commission_change","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"observed_lockup_cycle","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"operator_commission_percentage_next_lockup_cycle","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"remove_delegator_from_allowlist","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"set_beneficiary_for_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"shareholders_count_active_pool","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"synchronize_delegation_pool","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"update_commission_percentage","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]}],"structs":[{"name":"CreateProposal","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"voter","type":"address"},{"name":"delegation_pool","type":"address"}],"variants":[]},{"name":"CreateProposalEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"voter","type":"address"},{"name":"delegation_pool","type":"address"}],"variants":[]},{"name":"Vote","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"voter","type":"address"},{"name":"proposal_id","type":"u64"},{"name":"delegation_pool","type":"address"},{"name":"num_votes","type":"u64"},{"name":"should_pass","type":"bool"}],"variants":[]},{"name":"VoteEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"voter","type":"address"},{"name":"proposal_id","type":"u64"},{"name":"delegation_pool","type":"address"},{"name":"num_votes","type":"u64"},{"name":"should_pass","type":"bool"}],"variants":[]},{"name":"AddStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_added","type":"u64"},{"name":"add_stake_fee","type":"u64"}],"variants":[]},{"name":"AddStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_added","type":"u64"},{"name":"add_stake_fee","type":"u64"}],"variants":[]},{"name":"ReactivateStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_reactivated","type":"u64"}],"variants":[]},{"name":"ReactivateStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_reactivated","type":"u64"}],"variants":[]},{"name":"UnlockStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_unlocked","type":"u64"}],"variants":[]},{"name":"UnlockStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_unlocked","type":"u64"}],"variants":[]},{"name":"WithdrawStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_withdrawn","type":"u64"}],"variants":[]},{"name":"WithdrawStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"},{"name":"amount_withdrawn","type":"u64"}],"variants":[]},{"name":"AllowlistDelegator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"}],"variants":[]},{"name":"BeneficiaryForOperator","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"beneficiary_for_operator","type":"address"}],"variants":[]},{"name":"CommissionPercentageChange","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"owner","type":"address"},{"name":"commission_percentage_next_lockup_cycle","type":"u64"}],"variants":[]},{"name":"DelegateVotingPower","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator","type":"address"},{"name":"voter","type":"address"}],"variants":[]},{"name":"DelegateVotingPowerEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator","type":"address"},{"name":"voter","type":"address"}],"variants":[]},{"name":"DelegatedVotes","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"active_shares","type":"u128"},{"name":"pending_inactive_shares","type":"u128"},{"name":"active_shares_next_lockup","type":"u128"},{"name":"last_locked_until_secs","type":"u64"}],"variants":[]},{"name":"DelegationPermission","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"DelegationPoolManagementPermission","fields":[]},{"name":"StakeManagementPermission","fields":[]}]},{"name":"DelegationPool","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"active_shares","type":"0x1::pool_u64_unbound::Pool"},{"name":"observed_lockup_cycle","type":"0x1::delegation_pool::ObservedLockupCycle"},{"name":"inactive_shares","type":"0x1::table::Table<0x1::delegation_pool::ObservedLockupCycle, 0x1::pool_u64_unbound::Pool>"},{"name":"pending_withdrawals","type":"0x1::table::Table<address, 0x1::delegation_pool::ObservedLockupCycle>"},{"name":"stake_pool_signer_cap","type":"0x1::account::SignerCapability"},{"name":"total_coins_inactive","type":"u64"},{"name":"operator_commission_percentage","type":"u64"},{"name":"add_stake_events","type":"0x1::event::EventHandle<0x1::delegation_pool::AddStakeEvent>"},{"name":"reactivate_stake_events","type":"0x1::event::EventHandle<0x1::delegation_pool::ReactivateStakeEvent>"},{"name":"unlock_stake_events","type":"0x1::event::EventHandle<0x1::delegation_pool::UnlockStakeEvent>"},{"name":"withdraw_stake_events","type":"0x1::event::EventHandle<0x1::delegation_pool::WithdrawStakeEvent>"},{"name":"distribute_commission_events","type":"0x1::event::EventHandle<0x1::delegation_pool::DistributeCommissionEvent>"}],"variants":[]},{"name":"DelegationPoolAllowlisting","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"allowlist","type":"0x1::smart_table::SmartTable<address, bool>"}],"variants":[]},{"name":"DelegationPoolOwnership","is_native":false,"is_event":false,"is_enum":false,"abilities":["store","key"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"DisableDelegatorsAllowlisting","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"DistributeCommission","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"operator","type":"address"},{"name":"beneficiary","type":"address"},{"name":"commission_active","type":"u64"},{"name":"commission_pending_inactive","type":"u64"}],"variants":[]},{"name":"DistributeCommissionEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"operator","type":"address"},{"name":"commission_active","type":"u64"},{"name":"commission_pending_inactive","type":"u64"}],"variants":[]},{"name":"EnableDelegatorsAllowlisting","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"}],"variants":[]},{"name":"EvictDelegator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"}],"variants":[]},{"name":"GovernanceRecords","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"votes","type":"0x1::smart_table::SmartTable<0x1::delegation_pool::VotingRecordKey, u64>"},{"name":"votes_per_proposal","type":"0x1::smart_table::SmartTable<u64, u64>"},{"name":"vote_delegation","type":"0x1::smart_table::SmartTable<address, 0x1::delegation_pool::VoteDelegation>"},{"name":"delegated_votes","type":"0x1::smart_table::SmartTable<address, 0x1::delegation_pool::DelegatedVotes>"},{"name":"vote_events","type":"0x1::event::EventHandle<0x1::delegation_pool::VoteEvent>"},{"name":"create_proposal_events","type":"0x1::event::EventHandle<0x1::delegation_pool::CreateProposalEvent>"},{"name":"delegate_voting_power_events","type":"0x1::event::EventHandle<0x1::delegation_pool::DelegateVotingPowerEvent>"}],"variants":[]},{"name":"NextCommissionPercentage","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"commission_percentage_next_lockup_cycle","type":"u64"},{"name":"effective_after_secs","type":"u64"}],"variants":[]},{"name":"ObservedLockupCycle","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"index","type":"u64"}],"variants":[]},{"name":"RemoveDelegatorFromAllowlist","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"pool_address","type":"address"},{"name":"delegator_address","type":"address"}],"variants":[]},{"name":"SetBeneficiaryForOperator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"old_beneficiary","type":"address"},{"name":"new_beneficiary","type":"address"}],"variants":[]},{"name":"VoteDelegation","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"voter","type":"address"},{"name":"pending_voter","type":"address"},{"name":"last_locked_until_secs","type":"u64"}],"variants":[]},{"name":"VotingRecordKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"voter","type":"address"},{"name":"proposal_id","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"keyless_account","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"add_override_aud","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String"],"return":[]},{"name":"add_override_aud_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::string::String"],"return":[]},{"name":"new_configuration","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::string::String>","u16","u64","0x1::option::Option<vector<u8>>","u16","u16","u16","u32"],"return":["0x1::keyless_account::Configuration"]},{"name":"new_groth16_verification_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>","vector<u8>","vector<u8>","vector<u8>","vector<vector<u8>>"],"return":["0x1::keyless_account::Groth16VerificationKey"]},{"name":"register_ek_and_encrypt_dk","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>","0x1::object::Object<0x1::fungible_asset::Metadata>","vector<u8>","vector<vector<u8>>","vector<vector<u8>>","vector<u8>"],"return":[]},{"name":"remove_all_override_auds","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"remove_all_override_auds_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set_configuration_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::keyless_account::Configuration"],"return":[]},{"name":"set_groth16_verification_key_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::keyless_account::Groth16VerificationKey"],"return":[]},{"name":"update_configuration","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::keyless_account::Configuration"],"return":[]},{"name":"update_groth16_verification_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::keyless_account::Groth16VerificationKey"],"return":[]},{"name":"update_max_exp_horizon","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"update_max_exp_horizon_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"update_training_wheels","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::option::Option<vector<u8>>"],"return":[]},{"name":"update_training_wheels_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::option::Option<vector<u8>>"],"return":[]}],"structs":[{"name":"Configuration","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"override_aud_vals","type":"vector<0x1::string::String>"},{"name":"max_signatures_per_txn","type":"u16"},{"name":"max_exp_horizon_secs","type":"u64"},{"name":"training_wheels_pubkey","type":"0x1::option::Option<vector<u8>>"},{"name":"max_commited_epk_bytes","type":"u16"},{"name":"max_iss_val_bytes","type":"u16"},{"name":"max_extra_field_bytes","type":"u16"},{"name":"max_jwt_header_b64_bytes","type":"u32"}],"variants":[]},{"name":"Group","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Groth16VerificationKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"alpha_g1","type":"vector<u8>"},{"name":"beta_g2","type":"vector<u8>"},{"name":"gamma_g2","type":"vector<u8>"},{"name":"delta_g2","type":"vector<u8>"},{"name":"gamma_abc_g1","type":"vector<vector<u8>>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"reconfiguration","friends":["0x1::version","0x1::gas_schedule","0x1::execution_config","0x1::consensus_config","0x1::reconfiguration_with_dkg","0x1::aptos_governance","0x1::block","0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"current_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"last_reconfiguration_time","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"reconfigure","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]}],"structs":[{"name":"Configuration","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"},{"name":"last_reconfiguration_time","type":"u64"},{"name":"events","type":"0x1::event::EventHandle<0x1::reconfiguration::NewEpochEvent>"}],"variants":[]},{"name":"DisableReconfiguration","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"NewEpoch","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"}],"variants":[]},{"name":"NewEpochEvent","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"epoch","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"transaction_fee","friends":["0x1::reconfiguration","0x1::block","0x1::transaction_validation","0x1::genesis"],"exposed_functions":[{"name":"store_aptos_coin_mint_cap","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::coin::MintCapability<0x1::aptos_coin::AptosCoin>"],"return":[]},{"name":"burn_fee","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":[]},{"name":"convert_to_aptos_fa_burn_ref","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"emit_fee_statement","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::transaction_fee::FeeStatement"],"return":[]},{"name":"initialize_fee_collection_and_distribution","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u8"],"return":[]},{"name":"initialize_storage_refund","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"mint_and_refund","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":[]},{"name":"storage_fee_refund_octas","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_fee::FeeStatement"],"return":["u64"]},{"name":"store_aptos_coin_burn_cap","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::coin::BurnCapability<0x1::aptos_coin::AptosCoin>"],"return":[]},{"name":"upgrade_burn_percentage","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u8"],"return":[]}],"structs":[{"name":"AptosCoinCapabilities","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"burn_cap","type":"0x1::coin::BurnCapability<0x1::aptos_coin::AptosCoin>"}],"variants":[]},{"name":"AptosCoinMintCapability","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"mint_cap","type":"0x1::coin::MintCapability<0x1::aptos_coin::AptosCoin>"}],"variants":[]},{"name":"AptosFABurnCapabilities","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"burn_ref","type":"0x1::fungible_asset::BurnRef"}],"variants":[]},{"name":"CollectedFeesPerBlock","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"amount","type":"0x1::coin::AggregatableCoin<0x1::aptos_coin::AptosCoin>"},{"name":"proposer","type":"0x1::option::Option<address>"},{"name":"burn_percentage","type":"u8"}],"variants":[]},{"name":"FeeStatement","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"total_charge_gas_units","type":"u64"},{"name":"execution_gas_units","type":"u64"},{"name":"io_gas_units","type":"u64"},{"name":"storage_fee_octas","type":"u64"},{"name":"storage_fee_refund_octas","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"aptos_governance","friends":[],"exposed_functions":[{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"create_proposal","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>","vector<u8>","vector<u8>"],"return":[]},{"name":"create_proposal_v2","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>","vector<u8>","vector<u8>","bool"],"return":[]},{"name":"resolve","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","address"],"return":["signer"]},{"name":"vote","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64","bool"],"return":[]},{"name":"get_voting_power","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"reconfigure","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"add_approved_script_hash","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":[]},{"name":"add_approved_script_hash_script","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["u64"],"return":[]},{"name":"assert_proposal_expiration","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64"],"return":[]},{"name":"batch_partial_vote","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64","u64","bool"],"return":[]},{"name":"batch_vote","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64","bool"],"return":[]},{"name":"create_proposal_v2_impl","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>","vector<u8>","vector<u8>","bool"],"return":["u64"]},{"name":"force_end_epoch","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"force_end_epoch_test_only","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"get_min_voting_threshold","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u128"]},{"name":"get_remaining_voting_power","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","u64"],"return":["u64"]},{"name":"get_required_proposer_stake","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_signer_testnet_only","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":["signer"]},{"name":"get_voting_duration_secs","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"has_entirely_voted","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","u64"],"return":["bool"]},{"name":"initialize_partial_voting","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"partial_vote","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64","u64","bool"],"return":[]},{"name":"remove_approved_hash","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":[]},{"name":"resolve_multi_step_proposal","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","address","vector<u8>"],"return":["signer"]},{"name":"store_signer_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::account::SignerCapability"],"return":[]},{"name":"toggle_features","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u64>","vector<u64>"],"return":[]},{"name":"update_governance_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u128","u64","u64"],"return":[]}],"structs":[{"name":"CreateProposal","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposer","type":"address"},{"name":"stake_pool","type":"address"},{"name":"proposal_id","type":"u64"},{"name":"execution_hash","type":"vector<u8>"},{"name":"proposal_metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"}],"variants":[]},{"name":"CreateProposalEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposer","type":"address"},{"name":"stake_pool","type":"address"},{"name":"proposal_id","type":"u64"},{"name":"execution_hash","type":"vector<u8>"},{"name":"proposal_metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"}],"variants":[]},{"name":"Vote","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"voter","type":"address"},{"name":"stake_pool","type":"address"},{"name":"num_votes","type":"u64"},{"name":"should_pass","type":"bool"}],"variants":[]},{"name":"VoteEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"proposal_id","type":"u64"},{"name":"voter","type":"address"},{"name":"stake_pool","type":"address"},{"name":"num_votes","type":"u64"},{"name":"should_pass","type":"bool"}],"variants":[]},{"name":"ApprovedExecutionHashes","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"hashes","type":"0x1::simple_map::SimpleMap<u64, vector<u8>>"}],"variants":[]},{"name":"GovernanceConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"min_voting_threshold","type":"u128"},{"name":"required_proposer_stake","type":"u64"},{"name":"voting_duration_secs","type":"u64"}],"variants":[]},{"name":"GovernanceEvents","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"create_proposal_events","type":"0x1::event::EventHandle<0x1::aptos_governance::CreateProposalEvent>"},{"name":"update_config_events","type":"0x1::event::EventHandle<0x1::aptos_governance::UpdateConfigEvent>"},{"name":"vote_events","type":"0x1::event::EventHandle<0x1::aptos_governance::VoteEvent>"}],"variants":[]},{"name":"GovernancePermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"GovernanceResponsbility","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"signer_caps","type":"0x1::simple_map::SimpleMap<address, 0x1::account::SignerCapability>"}],"variants":[]},{"name":"RecordKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"stake_pool","type":"address"},{"name":"proposal_id","type":"u64"}],"variants":[]},{"name":"UpdateConfig","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"min_voting_threshold","type":"u128"},{"name":"required_proposer_stake","type":"u64"},{"name":"voting_duration_secs","type":"u64"}],"variants":[]},{"name":"UpdateConfigEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"min_voting_threshold","type":"u128"},{"name":"required_proposer_stake","type":"u64"},{"name":"voting_duration_secs","type":"u64"}],"variants":[]},{"name":"VotingRecords","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"votes","type":"0x1::table::Table<0x1::aptos_governance::RecordKey, bool>"}],"variants":[]},{"name":"VotingRecordsV2","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"votes","type":"0x1::smart_table::SmartTable<0x1::aptos_governance::RecordKey, u64>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"bls12381_algebra","friends":[],"exposed_functions":[],"structs":[{"name":"FormatFq12LscLsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatFrLsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatFrMsb","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG1Compr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG1Uncompr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG2Compr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatG2Uncompr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"FormatGt","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Fq12","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Fr","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"G1","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"G2","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Gt","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"HashG1XmdSha256SswuRo","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"HashG2XmdSha256SswuRo","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"consensus_config","friends":["0x1::reconfiguration_with_dkg","0x1::genesis"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"validator_txn_enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]}],"structs":[{"name":"ConsensusConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"config","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"execution_config","friends":["0x1::reconfiguration_with_dkg","0x1::genesis"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>"],"return":[]}],"structs":[{"name":"ExecutionConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"config","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"multisig_account","friends":[],"exposed_functions":[{"name":"create","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"is_owner","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["bool"]},{"name":"metadata","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"]},{"name":"vote","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","u64","address"],"return":["bool","bool"]},{"name":"add_owner","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"add_owners","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>"],"return":[]},{"name":"add_owners_and_update_signatures_required","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64"],"return":[]},{"name":"approve_transaction","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"available_transaction_queue_capacity","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"can_be_executed","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","u64"],"return":["bool"]},{"name":"can_be_rejected","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","u64"],"return":["bool"]},{"name":"can_execute","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address","u64"],"return":["bool"]},{"name":"can_reject","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address","u64"],"return":["bool"]},{"name":"num_signatures_required","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"create_transaction","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>"],"return":[]},{"name":"create_transaction_with_hash","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","vector<u8>"],"return":[]},{"name":"create_with_existing_account","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address","vector<address>","u64","u8","vector<u8>","vector<u8>","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"owners","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["vector<address>"]},{"name":"create_with_existing_account_and_revoke_auth_key","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address","vector<address>","u64","u8","vector<u8>","vector<u8>","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"create_with_existing_account_and_revoke_auth_key_call","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"create_with_existing_account_call","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"create_with_owners","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"create_with_owners_and_timelock","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64","vector<0x1::string::String>","vector<vector<u8>>","0x1::option::Option<u64>","0x1::option::Option<u64>"],"return":[]},{"name":"timelock_period","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"create_with_owners_then_remove_bootstrapper","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","u64","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"execute_rejected_transaction","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"execute_rejected_transactions","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"get_next_multisig_account_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"get_next_transaction_payload","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","vector<u8>"],"return":["vector<u8>"]},{"name":"get_pending_transactions","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["vector<0x1::multisig_account::MultisigTransaction>"]},{"name":"get_transaction","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","u64"],"return":["0x1::multisig_account::MultisigTransaction"]},{"name":"last_resolved_sequence_number","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"next_sequence_number","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["u64"]},{"name":"reject_transaction","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"remove_owner","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"remove_owners","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>"],"return":[]},{"name":"remove_timelock","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"swap_owner","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"swap_owners","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","vector<address>"],"return":[]},{"name":"swap_owners_and_update_signatures_required","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<address>","vector<address>","u64"],"return":[]},{"name":"timelock_override_threshold","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["0x1::option::Option<u64>"]},{"name":"update_metadata","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<0x1::string::String>","vector<vector<u8>>"],"return":[]},{"name":"update_signatures_required","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]},{"name":"upsert_timelock","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","u64","0x1::option::Option<u64>"],"return":[]},{"name":"vote_transaction","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64","bool"],"return":[]},{"name":"vote_transactions","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64","u64","bool"],"return":[]},{"name":"vote_transanction","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64","bool"],"return":[]}],"structs":[{"name":"Vote","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"owner","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"approved","type":"bool"}],"variants":[]},{"name":"VoteEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"owner","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"approved","type":"bool"}],"variants":[]},{"name":"AddOwners","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"owners_added","type":"vector<address>"}],"variants":[]},{"name":"AddOwnersEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"owners_added","type":"vector<address>"}],"variants":[]},{"name":"CreateTransaction","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"creator","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"transaction","type":"0x1::multisig_account::MultisigTransaction"}],"variants":[]},{"name":"CreateTransactionEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"creator","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"transaction","type":"0x1::multisig_account::MultisigTransaction"}],"variants":[]},{"name":"ExecuteRejectedTransaction","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"num_rejections","type":"u64"},{"name":"executor","type":"address"}],"variants":[]},{"name":"ExecuteRejectedTransactionEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"sequence_number","type":"u64"},{"name":"num_rejections","type":"u64"},{"name":"executor","type":"address"}],"variants":[]},{"name":"ExecutionError","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"abort_location","type":"0x1::string::String"},{"name":"error_type","type":"0x1::string::String"},{"name":"error_code","type":"u64"}],"variants":[]},{"name":"MetadataUpdated","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"old_metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"},{"name":"new_metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"}],"variants":[]},{"name":"MetadataUpdatedEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"},{"name":"new_metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"}],"variants":[]},{"name":"MultisigAccount","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"owners","type":"vector<address>"},{"name":"num_signatures_required","type":"u64"},{"name":"transactions","type":"0x1::table::Table<u64, 0x1::multisig_account::MultisigTransaction>"},{"name":"last_executed_sequence_number","type":"u64"},{"name":"next_sequence_number","type":"u64"},{"name":"signer_cap","type":"0x1::option::Option<0x1::account::SignerCapability>"},{"name":"metadata","type":"0x1::simple_map::SimpleMap<0x1::string::String, vector<u8>>"},{"name":"add_owners_events","type":"0x1::event::EventHandle<0x1::multisig_account::AddOwnersEvent>"},{"name":"remove_owners_events","type":"0x1::event::EventHandle<0x1::multisig_account::RemoveOwnersEvent>"},{"name":"update_signature_required_events","type":"0x1::event::EventHandle<0x1::multisig_account::UpdateSignaturesRequiredEvent>"},{"name":"create_transaction_events","type":"0x1::event::EventHandle<0x1::multisig_account::CreateTransactionEvent>"},{"name":"vote_events","type":"0x1::event::EventHandle<0x1::multisig_account::VoteEvent>"},{"name":"execute_rejected_transaction_events","type":"0x1::event::EventHandle<0x1::multisig_account::ExecuteRejectedTransactionEvent>"},{"name":"execute_transaction_events","type":"0x1::event::EventHandle<0x1::multisig_account::TransactionExecutionSucceededEvent>"},{"name":"transaction_execution_failed_events","type":"0x1::event::EventHandle<0x1::multisig_account::TransactionExecutionFailedEvent>"},{"name":"metadata_updated_events","type":"0x1::event::EventHandle<0x1::multisig_account::MetadataUpdatedEvent>"}],"variants":[]},{"name":"MultisigAccountCreationMessage","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"chain_id","type":"u8"},{"name":"account_address","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"owners","type":"vector<address>"},{"name":"num_signatures_required","type":"u64"}],"variants":[]},{"name":"MultisigAccountCreationWithAuthKeyRevocationMessage","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"chain_id","type":"u8"},{"name":"account_address","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"owners","type":"vector<address>"},{"name":"num_signatures_required","type":"u64"}],"variants":[]},{"name":"MultisigAccountTimeLock","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop","key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"timelock_period","type":"u64"},{"name":"override_threshold","type":"0x1::option::Option<u64>"}]}]},{"name":"MultisigTransaction","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"payload","type":"0x1::option::Option<vector<u8>>"},{"name":"payload_hash","type":"0x1::option::Option<vector<u8>>"},{"name":"votes","type":"0x1::simple_map::SimpleMap<address, bool>"},{"name":"creator","type":"address"},{"name":"creation_time_secs","type":"u64"}],"variants":[]},{"name":"RemoveOwners","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"owners_removed","type":"vector<address>"}],"variants":[]},{"name":"RemoveOwnersEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"owners_removed","type":"vector<address>"}],"variants":[]},{"name":"TimelockRemoved","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"}],"variants":[]},{"name":"TimelockUpdated","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"timelock_period","type":"u64"},{"name":"override_threshold","type":"0x1::option::Option<u64>"}],"variants":[]},{"name":"TransactionExecutionFailed","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"executor","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"transaction_payload","type":"vector<u8>"},{"name":"num_approvals","type":"u64"},{"name":"execution_error","type":"0x1::multisig_account::ExecutionError"}],"variants":[]},{"name":"TransactionExecutionFailedEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"executor","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"transaction_payload","type":"vector<u8>"},{"name":"num_approvals","type":"u64"},{"name":"execution_error","type":"0x1::multisig_account::ExecutionError"}],"variants":[]},{"name":"TransactionExecutionSucceeded","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"executor","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"transaction_payload","type":"vector<u8>"},{"name":"num_approvals","type":"u64"}],"variants":[]},{"name":"TransactionExecutionSucceededEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"executor","type":"address"},{"name":"sequence_number","type":"u64"},{"name":"transaction_payload","type":"vector<u8>"},{"name":"num_approvals","type":"u64"}],"variants":[]},{"name":"UpdateSignaturesRequired","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"multisig_account","type":"address"},{"name":"old_num_signatures_required","type":"u64"},{"name":"new_num_signatures_required","type":"u64"}],"variants":[]},{"name":"UpdateSignaturesRequiredEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_num_signatures_required","type":"u64"},{"name":"new_num_signatures_required","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"nonce_validation","friends":["0x1::transaction_validation","0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"add_nonce_buckets","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["u64"],"return":[]},{"name":"check_and_insert_nonce","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u64","u64"],"return":["bool"]},{"name":"initialize_nonce_table","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]}],"structs":[{"name":"Bucket","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"nonces_ordered_by_exp_time","type":"0x1::big_ordered_map::BigOrderedMap<0x1::nonce_validation::NonceKeyWithExpTime, bool>"},{"name":"nonce_to_exp_time_map","type":"0x1::big_ordered_map::BigOrderedMap<0x1::nonce_validation::NonceKey, u64>"}],"variants":[]},{"name":"NonceHistory","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"nonce_table","type":"0x1::table::Table<u64, 0x1::nonce_validation::Bucket>"},{"name":"next_key","type":"u64"}],"variants":[]},{"name":"NonceKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"sender_address","type":"address"},{"name":"nonce","type":"u64"}],"variants":[]},{"name":"NonceKeyWithExpTime","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"txn_expiration_time","type":"u64"},{"name":"sender_address","type":"address"},{"name":"nonce","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"pool_u64_unbound","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","address"],"return":["bool"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::pool_u64_unbound::Pool"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::pool_u64_unbound::Pool"],"return":[]},{"name":"create","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::pool_u64_unbound::Pool"]},{"name":"amount_to_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","u64"],"return":["u128"]},{"name":"amount_to_shares_with_total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","u64","u64"],"return":["u128"]},{"name":"total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool"],"return":["u64"]},{"name":"balance","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","address"],"return":["u64"]},{"name":"buy_in","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64_unbound::Pool","address","u64"],"return":["u128"]},{"name":"create_with_scaling_factor","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::pool_u64_unbound::Pool"]},{"name":"multiply_then_divide","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","u128","u128","u128"],"return":["u128"]},{"name":"redeem_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64_unbound::Pool","address","u128"],"return":["u64"]},{"name":"shareholders_count","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool"],"return":["u64"]},{"name":"shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","address"],"return":["u128"]},{"name":"shares_to_amount","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","u128"],"return":["u64"]},{"name":"shares_to_amount_with_total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","u128","u64"],"return":["u64"]},{"name":"total_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool"],"return":["u128"]},{"name":"transfer_shares","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64_unbound::Pool","address","address","u128"],"return":[]},{"name":"update_total_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::pool_u64_unbound::Pool","u64"],"return":[]},{"name":"shares_to_amount_with_total_stats","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::pool_u64_unbound::Pool","u128","u64","u128"],"return":["u64"]}],"structs":[{"name":"Pool","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"total_coins","type":"u64"},{"name":"total_shares","type":"u128"},{"name":"shares","type":"0x1::table_with_length::TableWithLength<address, u128>"},{"name":"scaling_factor","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"resource_account","friends":[],"exposed_functions":[{"name":"create_resource_account","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>"],"return":[]},{"name":"create_resource_account_and_fund","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>","u64"],"return":[]},{"name":"create_resource_account_and_publish_package","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>","vector<vector<u8>>"],"return":[]},{"name":"retrieve_resource_account_cap","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":["0x1::account::SignerCapability"]}],"structs":[{"name":"Container","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"store","type":"0x1::simple_map::SimpleMap<address, 0x1::account::SignerCapability>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"staking_contract","friends":[],"exposed_functions":[{"name":"add_stake","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"beneficiary_for_operator","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["address"]},{"name":"get_expected_stake_pool_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address","vector<u8>"],"return":["address"]},{"name":"set_beneficiary_for_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"commission_percentage","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["u64"]},{"name":"create_staking_contract","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address","u64","u64","vector<u8>"],"return":[]},{"name":"create_staking_contract_with_coins","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","address","0x1::coin::Coin<0x1::aptos_coin::AptosCoin>","u64","vector<u8>"],"return":["address"]},{"name":"distribute","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["address","address"],"return":[]},{"name":"last_recorded_principal","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["u64"]},{"name":"pending_attribution_snapshot","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address","address"],"return":["u64"]},{"name":"pending_distribution_counts","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["u64"]},{"name":"request_commission","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"reset_lockup","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"stake_pool_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["address"]},{"name":"staker_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["0x1::option::Option<address>"]},{"name":"staking_contract_amounts","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["u64","u64","u64"]},{"name":"staking_contract_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","address"],"return":["bool"]},{"name":"switch_operator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address","u64"],"return":[]},{"name":"switch_operator_with_same_commission","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]},{"name":"unlock_rewards","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"unlock_stake","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"update_commision","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","u64"],"return":[]},{"name":"update_voter","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","address"],"return":[]}],"structs":[{"name":"AddStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"AddStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"UnlockStake","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"},{"name":"commission_paid","type":"u64"}],"variants":[]},{"name":"UnlockStakeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"},{"name":"commission_paid","type":"u64"}],"variants":[]},{"name":"BeneficiaryForOperator","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"beneficiary_for_operator","type":"address"}],"variants":[]},{"name":"SetBeneficiaryForOperator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"old_beneficiary","type":"address"},{"name":"new_beneficiary","type":"address"}],"variants":[]},{"name":"AddDistribution","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"AddDistributionEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"CreateStakingContract","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"voter","type":"address"},{"name":"pool_address","type":"address"},{"name":"principal","type":"u64"},{"name":"commission_percentage","type":"u64"}],"variants":[]},{"name":"CreateStakingContractEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"voter","type":"address"},{"name":"pool_address","type":"address"},{"name":"principal","type":"u64"},{"name":"commission_percentage","type":"u64"}],"variants":[]},{"name":"Distribute","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"recipient","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"DistributeEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"recipient","type":"address"},{"name":"amount","type":"u64"}],"variants":[]},{"name":"RequestCommission","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"accumulated_rewards","type":"u64"},{"name":"commission_amount","type":"u64"}],"variants":[]},{"name":"RequestCommissionEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"accumulated_rewards","type":"u64"},{"name":"commission_amount","type":"u64"}],"variants":[]},{"name":"ResetLockup","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"}],"variants":[]},{"name":"ResetLockupEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"}],"variants":[]},{"name":"Staker","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"staker","type":"address"}],"variants":[]},{"name":"StakingContract","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"principal","type":"u64"},{"name":"pool_address","type":"address"},{"name":"owner_cap","type":"0x1::stake::OwnerCapability"},{"name":"commission_percentage","type":"u64"},{"name":"distribution_pool","type":"0x1::pool_u64::Pool"},{"name":"signer_cap","type":"0x1::account::SignerCapability"}],"variants":[]},{"name":"StakingGroupContainer","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"StakingGroupUpdateCommissionEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"update_commission_events","type":"0x1::event::EventHandle<0x1::staking_contract::UpdateCommissionEvent>"}],"variants":[]},{"name":"Store","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"staking_contracts","type":"0x1::simple_map::SimpleMap<address, 0x1::staking_contract::StakingContract>"},{"name":"create_staking_contract_events","type":"0x1::event::EventHandle<0x1::staking_contract::CreateStakingContractEvent>"},{"name":"update_voter_events","type":"0x1::event::EventHandle<0x1::staking_contract::UpdateVoterEvent>"},{"name":"reset_lockup_events","type":"0x1::event::EventHandle<0x1::staking_contract::ResetLockupEvent>"},{"name":"add_stake_events","type":"0x1::event::EventHandle<0x1::staking_contract::AddStakeEvent>"},{"name":"request_commission_events","type":"0x1::event::EventHandle<0x1::staking_contract::RequestCommissionEvent>"},{"name":"unlock_stake_events","type":"0x1::event::EventHandle<0x1::staking_contract::UnlockStakeEvent>"},{"name":"switch_operator_events","type":"0x1::event::EventHandle<0x1::staking_contract::SwitchOperatorEvent>"},{"name":"add_distribution_events","type":"0x1::event::EventHandle<0x1::staking_contract::AddDistributionEvent>"},{"name":"distribute_events","type":"0x1::event::EventHandle<0x1::staking_contract::DistributeEvent>"}],"variants":[]},{"name":"SwitchOperator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_operator","type":"address"},{"name":"new_operator","type":"address"},{"name":"pool_address","type":"address"}],"variants":[]},{"name":"SwitchOperatorEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"old_operator","type":"address"},{"name":"new_operator","type":"address"},{"name":"pool_address","type":"address"}],"variants":[]},{"name":"UpdateCommission","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"staker","type":"address"},{"name":"operator","type":"address"},{"name":"old_commission_percentage","type":"u64"},{"name":"new_commission_percentage","type":"u64"}],"variants":[]},{"name":"UpdateCommissionEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"staker","type":"address"},{"name":"operator","type":"address"},{"name":"old_commission_percentage","type":"u64"},{"name":"new_commission_percentage","type":"u64"}],"variants":[]},{"name":"UpdateVoter","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"old_voter","type":"address"},{"name":"new_voter","type":"address"}],"variants":[]},{"name":"UpdateVoterEvent","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"operator","type":"address"},{"name":"pool_address","type":"address"},{"name":"old_voter","type":"address"},{"name":"new_voter","type":"address"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"system_addresses","friends":[],"exposed_functions":[{"name":"assert_aptos_framework","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"assert_core_resource","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"assert_core_resource_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"assert_framework_reserved","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":[]},{"name":"assert_framework_reserved_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"assert_vm","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"is_aptos_framework_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"is_core_resource_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"is_framework_reserved_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"is_reserved_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]},{"name":"is_vm","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["bool"]},{"name":"is_vm_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address"],"return":["bool"]}],"structs":[]}},{"abi":{"address":"0x1","name":"chunky_dkg_config","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"current","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::chunky_dkg_config::ChunkyDKGConfig"]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::chunky_dkg_config::ChunkyDKGConfig"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::chunky_dkg_config::ChunkyDKGConfig"],"return":[]},{"name":"enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"new_off","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::chunky_dkg_config::ChunkyDKGConfig"]},{"name":"new_v1","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::chunky_dkg_config::ChunkyDKGConfig"]},{"name":"grace_period_secs","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<u64>"]},{"name":"new_shadow_v1","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64","u64"],"return":["0x1::chunky_dkg_config::ChunkyDKGConfig"]}],"structs":[{"name":"ConfigOff","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"ConfigV1","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"secrecy_threshold","type":"0x1::fixed_point64::FixedPoint64"},{"name":"reconstruction_threshold","type":"0x1::fixed_point64::FixedPoint64"}],"variants":[]},{"name":"ChunkyDKGConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"variant","type":"0x1::copyable_any::Any"}],"variants":[]},{"name":"ConfigShadowV1","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"secrecy_threshold","type":"0x1::fixed_point64::FixedPoint64"},{"name":"reconstruction_threshold","type":"0x1::fixed_point64::FixedPoint64"},{"name":"grace_period_secs","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"federated_keyless","friends":[],"exposed_functions":[{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::keyless::PublicKey","address"],"return":["0x1::federated_keyless::PublicKey"]},{"name":"deserialize_public_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::bcs_stream::BCSStream"],"return":["0x1::federated_keyless::PublicKey"]},{"name":"new_public_key_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::federated_keyless::PublicKey"]},{"name":"get_jwk_address","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::federated_keyless::PublicKey"],"return":["address"]},{"name":"get_keyless_public_key","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::federated_keyless::PublicKey"],"return":["0x1::keyless::PublicKey"]}],"structs":[{"name":"PublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"jwk_address","type":"address"},{"name":"keyless_public_key","type":"0x1::keyless::PublicKey"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"randomness_config","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"current","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::randomness_config::RandomnessConfig"]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::randomness_config::RandomnessConfig"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::randomness_config::RandomnessConfig"],"return":[]},{"name":"enabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"new_off","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::randomness_config::RandomnessConfig"]},{"name":"new_v1","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::randomness_config::RandomnessConfig"]},{"name":"new_v2","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64","0x1::fixed_point64::FixedPoint64"],"return":["0x1::randomness_config::RandomnessConfig"]}],"structs":[{"name":"ConfigOff","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"ConfigV1","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"secrecy_threshold","type":"0x1::fixed_point64::FixedPoint64"},{"name":"reconstruction_threshold","type":"0x1::fixed_point64::FixedPoint64"}],"variants":[]},{"name":"ConfigV2","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"secrecy_threshold","type":"0x1::fixed_point64::FixedPoint64"},{"name":"reconstruction_threshold","type":"0x1::fixed_point64::FixedPoint64"},{"name":"fast_path_secrecy_threshold","type":"0x1::fixed_point64::FixedPoint64"}],"variants":[]},{"name":"RandomnessConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"variant","type":"0x1::copyable_any::Any"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"table_with_length","friends":[],"exposed_functions":[{"name":"contains","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::table_with_length::TableWithLength<T0, T1>","T0"],"return":["bool"]},{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&mut 0x1::table_with_length::TableWithLength<T0, T1>","T0"],"return":["T1"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["store"]}],"params":[],"return":["0x1::table_with_length::TableWithLength<T0, T1>"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::table_with_length::TableWithLength<T0, T1>","T0"],"return":["&T1"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&mut 0x1::table_with_length::TableWithLength<T0, T1>","T0"],"return":["&mut T1"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["0x1::table_with_length::TableWithLength<T0, T1>"],"return":[]},{"name":"empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::table_with_length::TableWithLength<T0, T1>"],"return":["bool"]},{"name":"length","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&0x1::table_with_length::TableWithLength<T0, T1>"],"return":["u64"]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"params":["&mut 0x1::table_with_length::TableWithLength<T0, T1>","T0","T1"],"return":[]},{"name":"borrow_mut_with_default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::table_with_length::TableWithLength<T0, T1>","T0","T1"],"return":["&mut T1"]},{"name":"upsert","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":["drop"]}],"params":["&mut 0x1::table_with_length::TableWithLength<T0, T1>","T0","T1"],"return":[]}],"structs":[{"name":"TableWithLength","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[{"constraints":["copy","drop"]},{"constraints":[]}],"fields":[{"name":"inner","type":"0x1::table::Table<T0, T1>"},{"name":"length","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"aggregator_factory","friends":["0x1::optional_aggregator","0x1::genesis"],"exposed_functions":[{"name":"create_aggregator","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u128"],"return":["0x1::aggregator::Aggregator"]},{"name":"create_aggregator_internal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::aggregator::Aggregator"]},{"name":"initialize_aggregator_factory","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]}],"structs":[{"name":"AggregatorFactory","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"phantom_table","type":"0x1::table::Table<address, u128>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"confidential_asset","friends":[],"exposed_functions":[{"name":"deposit","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","u64"],"return":[]},{"name":"register","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","0x1::ristretto255::CompressedRistretto","0x1::confidential_asset::RegistrationProof"],"return":[]},{"name":"confidential_transfer","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","address","0x1::confidential_asset::TransferProof","vector<u8>"],"return":[]},{"name":"confidential_transfer_raw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","address","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<vector<u8>>>","vector<u8>","vector<u8>","vector<vector<u8>>","vector<vector<u8>>","vector<u8>"],"return":[]},{"name":"get_asset_specific_auditor_config","visibility":"private","is_entry":false,"is_view":true,"generic_type_params":[],"params":["0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::confidential_asset::AuditorConfig"]},{"name":"get_available_balance","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"]},{"name":"get_effective_auditor_config","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::confidential_asset::EffectiveAuditorConfig"]},{"name":"get_effective_auditor_hint","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::option::Option<0x1::confidential_asset::EffectiveAuditorHint>"]},{"name":"get_encryption_key","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"get_global_auditor_config","visibility":"private","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["0x1::confidential_asset::AuditorConfig"]},{"name":"get_max_memo_bytes","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_max_transfers_before_rollover","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_num_transfers_received","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["u64"]},{"name":"get_pending_balance","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>"]},{"name":"get_total_confidential_supply","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["u64"]},{"name":"has_confidential_store","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["bool"]},{"name":"incoming_transfers_paused","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["bool"]},{"name":"is_allow_listing_required","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_confidentiality_enabled_for_asset_type","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["bool"]},{"name":"is_emergency_paused","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_normalized","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["bool"]},{"name":"normalize_raw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<u8>","vector<vector<u8>>","vector<vector<u8>>"],"return":[]},{"name":"register_raw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","vector<u8>","vector<vector<u8>>","vector<vector<u8>>"],"return":[]},{"name":"rollover_pending_balance","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":[]},{"name":"rollover_pending_balance_and_pause","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":[]},{"name":"rotate_encryption_key","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","0x1::confidential_asset::KeyRotationProof","bool"],"return":[]},{"name":"rotate_encryption_key_raw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","vector<u8>","bool","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>"],"return":[]},{"name":"set_allow_listing","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]},{"name":"set_asset_specific_auditor","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","0x1::option::Option<vector<u8>>"],"return":[]},{"name":"set_confidentiality_for_apt","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]},{"name":"set_confidentiality_for_asset_type","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","bool"],"return":[]},{"name":"set_emergency_paused","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]},{"name":"set_global_auditor","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::option::Option<vector<u8>>"],"return":[]},{"name":"set_incoming_transfers_paused","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","bool"],"return":[]},{"name":"withdraw_to","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","address","u64","0x1::confidential_asset::WithdrawalProof"],"return":[]},{"name":"withdraw_to_raw","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","address","u64","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<u8>","vector<vector<u8>>","vector<vector<u8>>"],"return":[]}],"structs":[{"name":"AllowListingChanged","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"enabled","type":"bool"}]}]},{"name":"AssetConfig","is_native":false,"is_event":false,"is_enum":true,"abilities":["key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"allowed","type":"bool"},{"name":"auditor","type":"0x1::confidential_asset::AuditorConfig"}]}]},{"name":"AssetSpecificAuditorChanged","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"new","type":"0x1::confidential_asset::AuditorConfig"}]}]},{"name":"AuditorConfig","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"ek","type":"0x1::option::Option<0x1::ristretto255::CompressedRistretto>"},{"name":"epoch","type":"u64"}]}]},{"name":"ConfidentialStore","is_native":false,"is_event":false,"is_enum":true,"abilities":["key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"pause_incoming","type":"bool"},{"name":"normalized","type":"bool"},{"name":"transfers_received","type":"u64"},{"name":"pending_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>"},{"name":"available_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"},{"name":"ek","type":"0x1::ristretto255::CompressedRistretto"},{"name":"auditor_hint","type":"0x1::option::Option<0x1::confidential_asset::EffectiveAuditorHint>"}]}]},{"name":"ConfidentialityForAssetTypeChanged","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"allowed","type":"bool"}]}]},{"name":"Deposited","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"addr","type":"address"},{"name":"amount","type":"u64"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"new_pending_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>"}]}]},{"name":"EffectiveAuditorConfig","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"is_global","type":"bool"},{"name":"config","type":"0x1::confidential_asset::AuditorConfig"}]}]},{"name":"EffectiveAuditorHint","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"is_global","type":"bool"},{"name":"epoch","type":"u64"}]}]},{"name":"EmergencyPauseChanged","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"paused","type":"bool"}]}]},{"name":"GlobalAuditorChanged","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"new","type":"0x1::confidential_asset::AuditorConfig"}]}]},{"name":"GlobalConfig","is_native":false,"is_event":false,"is_enum":true,"abilities":["key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"allow_list_enabled","type":"bool"},{"name":"global_auditor","type":"0x1::confidential_asset::AuditorConfig"},{"name":"extend_ref","type":"0x1::object::ExtendRef"}]},{"name":"V2","fields":[{"name":"allow_list_enabled","type":"bool"},{"name":"global_auditor","type":"0x1::confidential_asset::AuditorConfig"},{"name":"extend_ref","type":"0x1::object::ExtendRef"},{"name":"emergency_paused","type":"bool"}]}]},{"name":"IncomingTransfersPauseChanged","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"addr","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"paused","type":"bool"}]}]},{"name":"KeyRotated","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"addr","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"new_ek","type":"0x1::ristretto255::CompressedRistretto"},{"name":"new_available_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"}]}]},{"name":"KeyRotationProof","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"compressed_new_ek","type":"0x1::ristretto255::CompressedRistretto"},{"name":"compressed_new_R","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"sigma","type":"0x1::sigma_protocol_proof::Proof"}]}]},{"name":"Normalized","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"addr","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"new_available_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"},{"name":"auditor_hint","type":"0x1::option::Option<0x1::confidential_asset::EffectiveAuditorHint>"}]}]},{"name":"Registered","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"addr","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"ek","type":"0x1::ristretto255::CompressedRistretto"}]}]},{"name":"RegistrationProof","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"sigma","type":"0x1::sigma_protocol_proof::Proof"}]}]},{"name":"RolledOver","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"addr","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"new_available_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"}]}]},{"name":"TransferProof","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"compressed_new_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"},{"name":"compressed_amount","type":"0x1::confidential_amount::CompressedAmount"},{"name":"compressed_ek_volun_auds","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"zkrp_new_balance","type":"0x1::ristretto255_bulletproofs::RangeProof"},{"name":"zkrp_amount","type":"0x1::ristretto255_bulletproofs::RangeProof"},{"name":"sigma","type":"0x1::sigma_protocol_proof::Proof"}]}]},{"name":"Transferred","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"amount","type":"0x1::confidential_amount::CompressedAmount"},{"name":"ek_volun_auds","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"sender_auditor_hint","type":"0x1::option::Option<0x1::confidential_asset::EffectiveAuditorHint>"},{"name":"new_sender_available_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"},{"name":"new_recip_pending_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>"},{"name":"memo","type":"vector<u8>"}]}]},{"name":"WithdrawalProof","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"compressed_new_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"},{"name":"zkrp_new_balance","type":"0x1::ristretto255_bulletproofs::RangeProof"},{"name":"sigma","type":"0x1::sigma_protocol_proof::Proof"}]}]},{"name":"Withdrawn","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"from","type":"address"},{"name":"to","type":"address"},{"name":"amount","type":"u64"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"new_available_balance","type":"0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"},{"name":"auditor_hint","type":"0x1::option::Option<0x1::confidential_asset::EffectiveAuditorHint>"}]}]}]}},{"abi":{"address":"0x1","name":"transaction_limits","friends":["0x1::transaction_validation","0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<0x1::transaction_limits::TxnLimitTier>","vector<0x1::transaction_limits::TxnLimitTier>"],"return":[]},{"name":"new_tier","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","u64"],"return":["0x1::transaction_limits::TxnLimitTier"]},{"name":"update_config","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u64>","vector<u64>","vector<u64>","vector<u64>"],"return":[]},{"name":"validate_high_txn_limits","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::transaction_limits::UserTxnLimitsRequest"],"return":[]}],"structs":[{"name":"RequestedMultipliers","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"execution_multiplier_percent","type":"u64"},{"name":"io_multiplier_percent","type":"u64"}]}]},{"name":"TxnLimitTier","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"min_stake","type":"u64"},{"name":"multiplier_percent","type":"u64"}],"variants":[]},{"name":"TxnLimitsConfig","is_native":false,"is_event":false,"is_enum":true,"abilities":["key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"execution_tiers","type":"vector<0x1::transaction_limits::TxnLimitTier>"},{"name":"io_tiers","type":"vector<0x1::transaction_limits::TxnLimitTier>"}]}]},{"name":"UserTxnLimitsRequest","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"StakePoolOwner","fields":[{"name":"multipliers","type":"0x1::transaction_limits::RequestedMultipliers"}]},{"name":"DelegatedVoter","fields":[{"name":"pool_address","type":"address"},{"name":"multipliers","type":"0x1::transaction_limits::RequestedMultipliers"}]},{"name":"DelegationPoolDelegator","fields":[{"name":"pool_address","type":"address"},{"name":"multipliers","type":"0x1::transaction_limits::RequestedMultipliers"}]}]}]}},{"abi":{"address":"0x1","name":"account_abstraction","friends":["0x1::transaction_validation"],"exposed_functions":[{"name":"initialize","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"add_authentication_function","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String"],"return":[]},{"name":"add_dispatchable_authentication_function","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String"],"return":[]},{"name":"derive_account_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::function_info::FunctionInfo","&vector<u8>"],"return":["address"]},{"name":"derive_account_address_view","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address","0x1::string::String","0x1::string::String","vector<u8>"],"return":["address"]},{"name":"dispatchable_authenticator","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["0x1::option::Option<vector<0x1::function_info::FunctionInfo>>"]},{"name":"register_derivable_authentication_function","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String"],"return":[]},{"name":"remove_authentication_function","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String"],"return":[]},{"name":"remove_authenticator","visibility":"private","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"remove_dispatchable_authentication_function","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::string::String","0x1::string::String"],"return":[]},{"name":"remove_dispatchable_authenticator","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"using_dispatchable_authenticator","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":["address"],"return":["bool"]}],"structs":[{"name":"DerivableDispatchableAuthenticator","is_native":false,"is_event":false,"is_enum":true,"abilities":["key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"auth_functions","type":"0x1::big_ordered_map::BigOrderedMap<0x1::function_info::FunctionInfo, 0x1::account_abstraction::DerivableRegisterValue>"}]}]},{"name":"DerivableRegisterValue","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[],"fields":[],"variants":[{"name":"Empty","fields":[]}]},{"name":"DispatchableAuthenticator","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"auth_functions","type":"0x1::ordered_map::OrderedMap<0x1::function_info::FunctionInfo, bool>"}]}]},{"name":"RemoveDispatchableAuthenticator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"}],"variants":[]},{"name":"UpdateDispatchableAuthenticator","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"account","type":"address"},{"name":"update","type":"vector<u8>"},{"name":"auth_function","type":"0x1::function_info::FunctionInfo"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"confidential_amount","friends":["0x1::sigma_protocol_transfer","0x1::confidential_asset"],"exposed_functions":[{"name":"new","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::RistrettoPoint>","vector<vector<0x1::ristretto255::RistrettoPoint>>"],"return":["0x1::confidential_amount::Amount"]},{"name":"compress","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::Amount"],"return":["0x1::confidential_amount::CompressedAmount"]},{"name":"get_compressed_P","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::CompressedAmount"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_compressed_R_eff_aud","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::CompressedAmount"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_compressed_R_recip","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::CompressedAmount"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_compressed_R_sender","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::CompressedAmount"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_compressed_R_volun_auds","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::CompressedAmount"],"return":["&vector<vector<0x1::ristretto255::CompressedRistretto>>"]},{"name":"has_effective_auditor_compressed","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::CompressedAmount"],"return":["bool"]},{"name":"new_compressed","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::ristretto255::CompressedRistretto>","vector<0x1::ristretto255::CompressedRistretto>","vector<0x1::ristretto255::CompressedRistretto>","vector<0x1::ristretto255::CompressedRistretto>","vector<vector<0x1::ristretto255::CompressedRistretto>>"],"return":["0x1::confidential_amount::CompressedAmount"]},{"name":"new_compressed_from_bytes","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>","vector<vector<vector<u8>>>"],"return":["0x1::confidential_amount::CompressedAmount"]},{"name":"num_volun_auditors_compressed","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::confidential_amount::CompressedAmount"],"return":["u64"]}],"structs":[{"name":"Amount","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"P","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"R_sender","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"R_recip","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"R_eff_aud","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"R_volun_auds","type":"vector<vector<0x1::ristretto255::RistrettoPoint>>"}],"variants":[]},{"name":"CompressedAmount","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"compressed_P","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"compressed_R_sender","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"compressed_R_recip","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"compressed_R_eff_aud","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"compressed_R_volun_auds","type":"vector<vector<0x1::ristretto255::CompressedRistretto>>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"governance_proposal","friends":["0x1::aptos_governance"],"exposed_functions":[{"name":"create_proposal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::governance_proposal::GovernanceProposal"]},{"name":"create_empty_proposal","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::governance_proposal::GovernanceProposal"]}],"structs":[{"name":"GovernanceProposal","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"optional_aggregator","friends":["0x1::fungible_asset","0x1::coin"],"exposed_functions":[{"name":"new","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["bool"],"return":["0x1::optional_aggregator::OptionalAggregator"]},{"name":"destroy","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::optional_aggregator::OptionalAggregator"],"return":[]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::optional_aggregator::OptionalAggregator","u128"],"return":[]},{"name":"read","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::optional_aggregator::OptionalAggregator"],"return":["u128"]},{"name":"sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::optional_aggregator::OptionalAggregator","u128"],"return":[]},{"name":"is_parallelizable","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::optional_aggregator::OptionalAggregator"],"return":["bool"]},{"name":"switch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::optional_aggregator::OptionalAggregator"],"return":[]}],"structs":[{"name":"Integer","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"value","type":"u128"},{"name":"limit","type":"u128"}],"variants":[]},{"name":"OptionalAggregator","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"aggregator","type":"0x1::option::Option<0x1::aggregator::Aggregator>"},{"name":"integer","type":"0x1::option::Option<0x1::optional_aggregator::Integer>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"permissioned_signer","friends":["0x1::account","0x1::object","0x1::fungible_asset","0x1::voting","0x1::stake","0x1::aptos_governance","0x1::code","0x1::delegation_pool","0x1::vesting","0x1::transaction_validation","0x1::permissioned_delegation","0x1::staking_proxy"],"exposed_functions":[{"name":"address_of","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["address"]},{"name":"borrow_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["&address"]},{"name":"assert_master_signer","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"authorize_increase","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","&signer","u256","T0"],"return":[]},{"name":"capacity","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","T0"],"return":["0x1::option::Option<u256>"]},{"name":"authorize_unlimited","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","&signer","T0"],"return":[]},{"name":"check_permission_capacity_above","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","u256","T0"],"return":["bool"]},{"name":"check_permission_consume","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","u256","T0"],"return":["bool"]},{"name":"check_permission_exists","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","T0"],"return":["bool"]},{"name":"create_permissioned_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["0x1::permissioned_signer::PermissionedHandle"]},{"name":"create_storable_permissioned_handle","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":["0x1::permissioned_signer::StorablePermissionedHandle"]},{"name":"destroy_permissioned_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::permissioned_signer::PermissionedHandle"],"return":[]},{"name":"destroy_storable_permissioned_handle","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::permissioned_signer::StorablePermissionedHandle"],"return":[]},{"name":"grant_revoke_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer"],"return":[]},{"name":"grant_unlimited_with_permissioned_signer","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","T0"],"return":[]},{"name":"increase_limit","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","u256","T0"],"return":[]},{"name":"is_permissioned_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":["bool"]},{"name":"permissions_storage_address","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::permissioned_signer::StorablePermissionedHandle"],"return":["address"]},{"name":"revoke_all_handles","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"revoke_permission","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["copy","drop","store"]}],"params":["&signer","T0"],"return":[]},{"name":"revoke_permission_storage_address","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","address"],"return":[]},{"name":"signer_from_permissioned_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::permissioned_signer::PermissionedHandle"],"return":["signer"]},{"name":"signer_from_storable_permissioned_handle","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::permissioned_signer::StorablePermissionedHandle"],"return":["signer"]}],"structs":[{"name":"GrantedPermissionHandles","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"active_handles","type":"vector<address>"}],"variants":[]},{"name":"PermissionStorage","is_native":false,"is_event":false,"is_enum":true,"abilities":["key"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"perms","type":"0x1::big_ordered_map::BigOrderedMap<0x1::copyable_any::Any, 0x1::permissioned_signer::StoredPermission>"}]}]},{"name":"PermissionedHandle","is_native":false,"is_event":false,"is_enum":true,"abilities":[],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"master_account_addr","type":"address"},{"name":"permissions_storage_addr","type":"address"}]}]},{"name":"RevokePermissionHandlePermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"StorablePermissionedHandle","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"master_account_addr","type":"address"},{"name":"permissions_storage_addr","type":"address"},{"name":"expiration_time","type":"u64"}]}]},{"name":"StoredPermission","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"Unlimited","fields":[]},{"name":"Capacity","fields":[{"name":"_0","type":"u256"}]}]}]}},{"abi":{"address":"0x1","name":"transaction_context","friends":[],"exposed_functions":[{"name":"chain_id","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u8"]},{"name":"account_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::EntryFunctionPayload"],"return":["address"]},{"name":"module_name","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::EntryFunctionPayload"],"return":["0x1::string::String"]},{"name":"args","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::EntryFunctionPayload"],"return":["vector<vector<u8>>"]},{"name":"auid_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::AUID"],"return":["address"]},{"name":"entry_function_payload","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<0x1::transaction_context::EntryFunctionPayload>"]},{"name":"function_name","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::EntryFunctionPayload"],"return":["0x1::string::String"]},{"name":"gas_payer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["address"]},{"name":"gas_unit_price","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"generate_auid","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::transaction_context::AUID"]},{"name":"generate_auid_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["address"]},{"name":"get_script_hash","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["vector<u8>"]},{"name":"get_transaction_hash","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["vector<u8>"]},{"name":"inner_entry_function_payload","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::MultisigPayload"],"return":["0x1::option::Option<0x1::transaction_context::EntryFunctionPayload>"]},{"name":"is_encrypted_txn","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"max_gas_amount","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"monotonically_increasing_counter","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u128"]},{"name":"multisig_address","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::MultisigPayload"],"return":["address"]},{"name":"multisig_payload","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<0x1::transaction_context::MultisigPayload>"]},{"name":"secondary_signers","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["vector<address>"]},{"name":"sender","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["address"]},{"name":"type_arg_names","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::EntryFunctionPayload"],"return":["vector<0x1::string::String>"]}],"structs":[{"name":"AUID","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"unique_address","type":"address"}],"variants":[]},{"name":"EntryFunctionPayload","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"account_address","type":"address"},{"name":"module_name","type":"0x1::string::String"},{"name":"function_name","type":"0x1::string::String"},{"name":"ty_args_names","type":"vector<0x1::string::String>"},{"name":"args","type":"vector<vector<u8>>"}],"variants":[]},{"name":"MultisigPayload","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"multisig_address","type":"address"},{"name":"entry_function_payload","type":"0x1::option::Option<0x1::transaction_context::EntryFunctionPayload>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"confidential_balance","friends":["0x1::sigma_protocol_withdraw","0x1::confidential_amount","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation","0x1::confidential_range_proofs","0x1::confidential_asset"],"exposed_functions":[{"name":"is_zero","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::CompressedBalance<T0>"],"return":["bool"]},{"name":"add_assign_available_excluding_auditor","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>","&0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>"],"return":[]},{"name":"add_assign_pending","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>","&0x1::confidential_balance::Balance<0x1::confidential_balance::Pending>"],"return":["0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>"]},{"name":"add_mut_base","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::confidential_balance::Balance<T0>","&vector<0x1::ristretto255::RistrettoPoint>","&vector<0x1::ristretto255::RistrettoPoint>"],"return":[]},{"name":"compress","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::Balance<T0>"],"return":["0x1::confidential_balance::CompressedBalance<T0>"]},{"name":"decompress","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::CompressedBalance<T0>"],"return":["0x1::confidential_balance::Balance<T0>"]},{"name":"get_P","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::Balance<T0>"],"return":["&vector<0x1::ristretto255::RistrettoPoint>"]},{"name":"get_R","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::Balance<T0>"],"return":["&vector<0x1::ristretto255::RistrettoPoint>"]},{"name":"get_R_aud","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::Balance<T0>"],"return":["&vector<0x1::ristretto255::RistrettoPoint>"]},{"name":"get_b_powers","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["vector<0x1::ristretto255::Scalar>"]},{"name":"get_chunk_size_bits","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_chunk_upper_bound","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_compressed_P","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::CompressedBalance<T0>"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_compressed_R","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::CompressedBalance<T0>"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_compressed_R_aud","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::confidential_balance::CompressedBalance<T0>"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_encryption_key_basepoint_compressed","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"get_num_available_chunks","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"get_num_pending_chunks","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"new_available_from_p_r_r_aud","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::RistrettoPoint>"],"return":["0x1::confidential_balance::Balance<0x1::confidential_balance::Available>"]},{"name":"new_compressed_available_from_bytes","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<vector<u8>>","vector<vector<u8>>","vector<vector<u8>>"],"return":["0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"]},{"name":"new_compressed_available_from_p_r_r_aud","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::ristretto255::CompressedRistretto>","vector<0x1::ristretto255::CompressedRistretto>","vector<0x1::ristretto255::CompressedRistretto>"],"return":["0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"]},{"name":"new_pending_from_p_and_r","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::RistrettoPoint>"],"return":["0x1::confidential_balance::Balance<0x1::confidential_balance::Pending>"]},{"name":"new_pending_u64_no_randomness","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::confidential_balance::Balance<0x1::confidential_balance::Pending>"]},{"name":"new_zero_available_compressed","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>"]},{"name":"new_zero_pending_compressed","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Pending>"]},{"name":"set_available_R","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>","vector<0x1::ristretto255::CompressedRistretto>"],"return":[]}],"structs":[{"name":"Available","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"Balance","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[{"constraints":[]}],"fields":[],"variants":[{"name":"V1","fields":[{"name":"P","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"R","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"R_aud","type":"vector<0x1::ristretto255::RistrettoPoint>"}]}]},{"name":"CompressedBalance","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[{"constraints":[]}],"fields":[],"variants":[{"name":"V1","fields":[{"name":"P","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"R","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"R_aud","type":"vector<0x1::ristretto255::CompressedRistretto>"}]}]},{"name":"Pending","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"epoch_timeout_config","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::epoch_timeout_config::EpochTimeoutConfig"],"return":[]},{"name":"force_end_grace_period_secs","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::option::Option<u64>"]},{"name":"new_disabled","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::epoch_timeout_config::EpochTimeoutConfig"]},{"name":"new_with_grace_period","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::epoch_timeout_config::EpochTimeoutConfig"]}],"structs":[{"name":"EpochTimeoutConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store","key"],"generic_type_params":[],"fields":[{"name":"force_end_grace_period_secs","type":"0x1::option::Option<u64>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"jwk_consensus_config","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::jwk_consensus_config::JWKConsensusConfig"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::jwk_consensus_config::JWKConsensusConfig"],"return":[]},{"name":"new_off","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::jwk_consensus_config::JWKConsensusConfig"]},{"name":"new_v1","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::jwk_consensus_config::OIDCProvider>"],"return":["0x1::jwk_consensus_config::JWKConsensusConfig"]},{"name":"new_oidc_provider","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::string::String","0x1::string::String"],"return":["0x1::jwk_consensus_config::OIDCProvider"]}],"structs":[{"name":"ConfigOff","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"ConfigV1","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"oidc_providers","type":"vector<0x1::jwk_consensus_config::OIDCProvider>"}],"variants":[]},{"name":"OIDCProvider","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"name","type":"0x1::string::String"},{"name":"config_url","type":"0x1::string::String"}],"variants":[]},{"name":"JWKConsensusConfig","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"variant","type":"0x1::copyable_any::Any"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"ristretto255_elgamal","friends":[],"exposed_functions":[{"name":"ciphertext_add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext","&0x1::ristretto255_elgamal::Ciphertext"],"return":["0x1::ristretto255_elgamal::Ciphertext"]},{"name":"ciphertext_add_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255_elgamal::Ciphertext","&0x1::ristretto255_elgamal::Ciphertext"],"return":[]},{"name":"ciphertext_as_points","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext"],"return":["&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint"]},{"name":"ciphertext_clone","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext"],"return":["0x1::ristretto255_elgamal::Ciphertext"]},{"name":"ciphertext_equals","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext","&0x1::ristretto255_elgamal::Ciphertext"],"return":["bool"]},{"name":"ciphertext_from_compressed_points","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::CompressedRistretto","0x1::ristretto255::CompressedRistretto"],"return":["0x1::ristretto255_elgamal::CompressedCiphertext"]},{"name":"ciphertext_from_points","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::RistrettoPoint","0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255_elgamal::Ciphertext"]},{"name":"ciphertext_into_points","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255_elgamal::Ciphertext"],"return":["0x1::ristretto255::RistrettoPoint","0x1::ristretto255::RistrettoPoint"]},{"name":"ciphertext_sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext","&0x1::ristretto255_elgamal::Ciphertext"],"return":["0x1::ristretto255_elgamal::Ciphertext"]},{"name":"ciphertext_sub_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255_elgamal::Ciphertext","&0x1::ristretto255_elgamal::Ciphertext"],"return":[]},{"name":"ciphertext_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext"],"return":["vector<u8>"]},{"name":"compress_ciphertext","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext"],"return":["0x1::ristretto255_elgamal::CompressedCiphertext"]},{"name":"decompress_ciphertext","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::CompressedCiphertext"],"return":["0x1::ristretto255_elgamal::Ciphertext"]},{"name":"get_value_component","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::Ciphertext"],"return":["&0x1::ristretto255::RistrettoPoint"]},{"name":"new_ciphertext_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255_elgamal::Ciphertext>"]},{"name":"new_ciphertext_no_randomness","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255_elgamal::Ciphertext"]},{"name":"new_pubkey_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255_elgamal::CompressedPubkey>"]},{"name":"pubkey_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::CompressedPubkey"],"return":["vector<u8>"]},{"name":"pubkey_to_compressed_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::CompressedPubkey"],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"pubkey_to_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_elgamal::CompressedPubkey"],"return":["0x1::ristretto255::RistrettoPoint"]}],"structs":[{"name":"Ciphertext","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"left","type":"0x1::ristretto255::RistrettoPoint"},{"name":"right","type":"0x1::ristretto255::RistrettoPoint"}],"variants":[]},{"name":"CompressedCiphertext","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"left","type":"0x1::ristretto255::CompressedRistretto"},{"name":"right","type":"0x1::ristretto255::CompressedRistretto"}],"variants":[]},{"name":"CompressedPubkey","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"point","type":"0x1::ristretto255::CompressedRistretto"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_proof","friends":["0x1::sigma_protocol","0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation","0x1::confidential_asset"],"exposed_functions":[{"name":"get_commitment","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_proof::Proof"],"return":["&vector<0x1::ristretto255::RistrettoPoint>"]},{"name":"get_compressed_commitment","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_proof::Proof"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_response","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_proof::Proof"],"return":["&vector<0x1::ristretto255::Scalar>"]},{"name":"get_response_length","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_proof::Proof"],"return":["u64"]},{"name":"new_proof","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::CompressedRistretto>","vector<0x1::ristretto255::Scalar>"],"return":["0x1::sigma_protocol_proof::Proof"]},{"name":"new_proof_from_bytes","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<vector<u8>>","vector<vector<u8>>"],"return":["0x1::sigma_protocol_proof::Proof"]},{"name":"response_to_witness","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_proof::Proof"],"return":["0x1::sigma_protocol_witness::Witness"]}],"structs":[{"name":"Proof","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"comm_A","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"compressed_comm_A","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"resp_sigma","type":"vector<0x1::ristretto255::Scalar>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_utils","friends":["0x1::sigma_protocol_proof","0x1::sigma_protocol","0x1::confidential_balance","0x1::sigma_protocol_withdraw","0x1::confidential_amount","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation","0x1::confidential_asset"],"exposed_functions":[{"name":"deserialize_compressed_points","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<vector<u8>>"],"return":["vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"deserialize_points","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<vector<u8>>"],"return":["vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"deserialize_scalars","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<vector<u8>>"],"return":["vector<0x1::ristretto255::Scalar>"]},{"name":"e_wrong_num_points","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"e_wrong_num_scalars","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"e_wrong_output_len","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"e_wrong_witness_len","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"neg_scalars","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<0x1::ristretto255::Scalar>"],"return":["vector<0x1::ristretto255::Scalar>"]},{"name":"points_clone","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<0x1::ristretto255::RistrettoPoint>"],"return":["vector<0x1::ristretto255::RistrettoPoint>"]}],"structs":[]}},{"abi":{"address":"0x1","name":"reconfiguration_state","friends":["0x1::stake","0x1::reconfiguration","0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize_for_testing","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"is_in_progress","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"is_initialized","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["bool"]},{"name":"on_reconfig_finish","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"on_reconfig_start","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"start_time_secs","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]}],"structs":[{"name":"State","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"variant","type":"0x1::copyable_any::Any"}],"variants":[]},{"name":"StateActive","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"start_time_secs","type":"u64"}],"variants":[]},{"name":"StateInactive","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"ristretto255_pedersen","friends":[],"exposed_functions":[{"name":"commitment_add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment","&0x1::ristretto255_pedersen::Commitment"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"commitment_add_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255_pedersen::Commitment","&0x1::ristretto255_pedersen::Commitment"],"return":[]},{"name":"commitment_as_compressed_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment"],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"commitment_as_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment"],"return":["&0x1::ristretto255::RistrettoPoint"]},{"name":"commitment_clone","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"commitment_equals","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment","&0x1::ristretto255_pedersen::Commitment"],"return":["bool"]},{"name":"commitment_from_compressed","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::CompressedRistretto"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"commitment_from_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"commitment_into_compressed_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255_pedersen::Commitment"],"return":["0x1::ristretto255::CompressedRistretto"]},{"name":"commitment_into_point","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255_pedersen::Commitment"],"return":["0x1::ristretto255::RistrettoPoint"]},{"name":"commitment_sub","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment","&0x1::ristretto255_pedersen::Commitment"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"commitment_sub_assign","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::ristretto255_pedersen::Commitment","&0x1::ristretto255_pedersen::Commitment"],"return":[]},{"name":"commitment_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment"],"return":["vector<u8>"]},{"name":"new_commitment","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::Scalar","&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"new_commitment_for_bulletproof","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"new_commitment_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::option::Option<0x1::ristretto255_pedersen::Commitment>"]},{"name":"new_commitment_with_basepoint","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::Scalar","&0x1::ristretto255::Scalar","&0x1::ristretto255::RistrettoPoint"],"return":["0x1::ristretto255_pedersen::Commitment"]},{"name":"randomness_base_for_bulletproof","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::ristretto255::RistrettoPoint"]}],"structs":[{"name":"Commitment","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"point","type":"0x1::ristretto255::RistrettoPoint"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sui_derivable_account","friends":[],"exposed_functions":[{"name":"authenticate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["signer","0x1::auth_data::AbstractionAuthData"],"return":["signer"]},{"name":"authenticate_auth_data","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::auth_data::AbstractionAuthData","&vector<u8>"],"return":[]},{"name":"split_signature_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<u8>"],"return":["u8","vector<u8>","vector<u8>"]}],"structs":[{"name":"AppId","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"Sui","fields":[]}]},{"name":"Intent","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"scope","type":"0x1::sui_derivable_account::IntentScope"},{"name":"version","type":"0x1::sui_derivable_account::IntentVersion"},{"name":"app_id","type":"0x1::sui_derivable_account::AppId"}],"variants":[]},{"name":"IntentMessage","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"intent","type":"0x1::sui_derivable_account::Intent"},{"name":"value","type":"vector<u8>"}],"variants":[]},{"name":"IntentScope","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"TransactionData","fields":[]},{"name":"TransactionEffects","fields":[]},{"name":"CheckpointSummary","fields":[]},{"name":"PersonalMessage","fields":[]}]},{"name":"IntentVersion","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V0","fields":[]}]},{"name":"SuiAbstractPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"sui_account_address","type":"vector<u8>"},{"name":"domain","type":"vector<u8>"}],"variants":[]},{"name":"SuiAbstractSignature","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"MessageV1","fields":[{"name":"signature","type":"vector<u8>"}]}]},{"name":"SuiSigningScheme","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"ED25519","fields":[]}]}]}},{"abi":{"address":"0x1","name":"object_code_deployment","friends":[],"exposed_functions":[{"name":"publish","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<vector<u8>>"],"return":[]},{"name":"freeze_code_object","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::code::PackageRegistry>"],"return":[]},{"name":"get_code_object_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::code::PackageRegistry>"],"return":["signer"]},{"name":"upgrade","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<vector<u8>>","0x1::object::Object<0x1::code::PackageRegistry>"],"return":[]}],"structs":[{"name":"Freeze","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"object_address","type":"address"}],"variants":[]},{"name":"ManagingRefs","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"extend_ref","type":"0x1::object::ExtendRef"}],"variants":[]},{"name":"Publish","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"object_address","type":"address"}],"variants":[]},{"name":"Upgrade","is_native":false,"is_event":true,"is_enum":false,"abilities":["drop","store"],"generic_type_params":[],"fields":[{"name":"object_address","type":"address"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"primary_fungible_store","friends":[],"exposed_functions":[{"name":"burn","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::BurnRef","address","u64"],"return":[]},{"name":"grant_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","&signer","0x1::object::Object<T0>","u64"],"return":[]},{"name":"transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","address","u64"],"return":[]},{"name":"transfer_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::TransferRef","address","address","u64"],"return":[]},{"name":"balance","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>"],"return":["u64"]},{"name":"deposit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"deposit_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::TransferRef","address","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"is_balance_at_least","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>","u64"],"return":["bool"]},{"name":"is_frozen","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>"],"return":["bool"]},{"name":"mint","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::MintRef","address","u64"],"return":[]},{"name":"set_frozen_flag","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::TransferRef","address","bool"],"return":[]},{"name":"withdraw","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"withdraw_with_ref","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::fungible_asset::TransferRef","address","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"transfer_assert_minimum_deposit","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","address","u64","u64"],"return":[]},{"name":"create_primary_store","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>"],"return":["0x1::object::Object<0x1::fungible_asset::FungibleStore>"]},{"name":"create_primary_store_enabled_fungible_asset","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef","0x1::option::Option<u128>","0x1::string::String","0x1::string::String","u8","0x1::string::String","0x1::string::String"],"return":[]},{"name":"deposit_with_signer","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"ensure_primary_store_exists","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>"],"return":["0x1::object::Object<0x1::fungible_asset::FungibleStore>"]},{"name":"grant_apt_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer","u64"],"return":[]},{"name":"primary_store","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>"],"return":["0x1::object::Object<0x1::fungible_asset::FungibleStore>"]},{"name":"primary_store_address","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>"],"return":["address"]},{"name":"primary_store_exists","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["address","0x1::object::Object<T0>"],"return":["bool"]}],"structs":[{"name":"DeriveRefPod","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"metadata_derive_ref","type":"0x1::object::DeriveRef"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_witness","friends":["0x1::sigma_protocol_proof","0x1::sigma_protocol_homomorphism","0x1::sigma_protocol","0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[{"name":"length","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_witness::Witness"],"return":["u64"]},{"name":"get","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_witness::Witness","u64"],"return":["&0x1::ristretto255::Scalar"]},{"name":"get_scalars","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_witness::Witness"],"return":["&vector<0x1::ristretto255::Scalar>"]},{"name":"new_secret_witness","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::ristretto255::Scalar>"],"return":["0x1::sigma_protocol_witness::Witness"]}],"structs":[{"name":"Witness","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"w","type":"vector<0x1::ristretto255::Scalar>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"storage_slot_or_inline","friends":[],"exposed_functions":[{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&0x1::storage_slot_or_inline::StorageSlotOrInline<T0>"],"return":["&T0"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slot_or_inline::StorageSlotOrInline<T0>"],"return":["&mut T0"]},{"name":"destroy","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["0x1::storage_slot_or_inline::StorageSlotOrInline<T0>"],"return":["T0"]},{"name":"move_to_inline","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slot_or_inline::StorageSlotOrInline<T0>"],"return":[]},{"name":"move_to_storage_slot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slot_or_inline::StorageSlotOrInline<T0>"],"return":[]},{"name":"new_inline","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["T0"],"return":["0x1::storage_slot_or_inline::StorageSlotOrInline<T0>"]},{"name":"new_storage_slot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["T0"],"return":["0x1::storage_slot_or_inline::StorageSlotOrInline<T0>"]}],"structs":[{"name":"Dummy","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"StorageSlotOrInline","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[{"constraints":[]}],"fields":[],"variants":[{"name":"Inline","fields":[{"name":"value","type":"T0"}]},{"name":"StorageSlot","fields":[{"name":"slot","type":"0x1::storage_slot::StorageSlot<T0>"}]},{"name":"Transient","fields":[]}]}]}},{"abi":{"address":"0x1","name":"transaction_validation","friends":["0x1::genesis"],"exposed_functions":[{"name":"initialize","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","vector<u8>","vector<u8>","vector<u8>","vector<u8>"],"return":[]},{"name":"grant_gas_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","&signer","u64"],"return":[]},{"name":"revoke_gas_permission","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]}],"structs":[{"name":"EpilogueArgs","is_native":false,"is_event":false,"is_enum":true,"abilities":[],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"fee_statement","type":"0x1::transaction_fee::FeeStatement"},{"name":"txn_gas_price","type":"u64"},{"name":"txn_max_gas_units","type":"u64"},{"name":"gas_units_remaining","type":"u64"},{"name":"is_simulation","type":"bool"},{"name":"is_orderless_txn","type":"bool"}]}]},{"name":"GasPermission","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"PrologueArgs","is_native":false,"is_event":false,"is_enum":true,"abilities":[],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"needs_fee_payer_auth_check","type":"bool"},{"name":"txn_sender_public_key","type":"0x1::option::Option<vector<u8>>"},{"name":"fee_payer_public_key_hash","type":"0x1::option::Option<vector<u8>>"},{"name":"replay_protector","type":"0x1::transaction_validation::ReplayProtector"},{"name":"secondary_signer_addresses","type":"vector<address>"},{"name":"secondary_signer_public_key_hashes","type":"vector<0x1::option::Option<vector<u8>>>"},{"name":"txn_gas_price","type":"u64"},{"name":"txn_max_gas_units","type":"u64"},{"name":"txn_expiration_time","type":"u64"},{"name":"chain_id","type":"u8"},{"name":"is_simulation","type":"bool"},{"name":"txn_limits_request","type":"0x1::option::Option<0x1::transaction_limits::UserTxnLimitsRequest>"}]}]},{"name":"ReplayProtector","is_native":false,"is_event":false,"is_enum":true,"abilities":[],"generic_type_params":[],"fields":[],"variants":[{"name":"Nonce","fields":[{"name":"_0","type":"u64"}]},{"name":"SequenceNumber","fields":[{"name":"_0","type":"u64"}]}]},{"name":"TransactionValidation","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"module_addr","type":"address"},{"name":"module_name","type":"vector<u8>"},{"name":"script_prologue_name","type":"vector<u8>"},{"name":"module_prologue_name","type":"vector<u8>"},{"name":"multi_agent_prologue_name","type":"vector<u8>"},{"name":"user_epilogue_name","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"permissioned_delegation","friends":[],"exposed_functions":[{"name":"authenticate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["signer","0x1::auth_data::AbstractionAuthData"],"return":["signer"]},{"name":"add_permissioned_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::permissioned_delegation::DelegationKey","0x1::option::Option<0x1::rate_limiter::RateLimiter>","u64"],"return":["signer"]},{"name":"gen_ed25519_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ed25519::UnvalidatedPublicKey"],"return":["0x1::permissioned_delegation::DelegationKey"]},{"name":"handle_address_by_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","0x1::permissioned_delegation::DelegationKey"],"return":["address"]},{"name":"permissioned_signer_by_key","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::permissioned_delegation::DelegationKey"],"return":["signer"]},{"name":"remove_permissioned_handle","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::permissioned_delegation::DelegationKey"],"return":[]}],"structs":[{"name":"AccountDelegation","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"handle","type":"0x1::permissioned_signer::StorablePermissionedHandle"},{"name":"rate_limiter","type":"0x1::option::Option<0x1::rate_limiter::RateLimiter>"}]}]},{"name":"DelegationKey","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"Ed25519PublicKey","fields":[{"name":"_0","type":"0x1::ed25519::UnvalidatedPublicKey"}]}]},{"name":"RegisteredDelegations","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"delegations","type":"0x1::big_ordered_map::BigOrderedMap<0x1::permissioned_delegation::DelegationKey, 0x1::permissioned_delegation::AccountDelegation>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_transfer","friends":["0x1::confidential_asset"],"exposed_functions":[{"name":"assert_verifies","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_transfer::TransferSession","&0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_transfer::Transfer>","&0x1::sigma_protocol_proof::Proof"],"return":[]},{"name":"new_session","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","address","0x1::object::Object<0x1::fungible_asset::Metadata>","bool","u64"],"return":["0x1::sigma_protocol_transfer::TransferSession"]},{"name":"new_transfer_statement","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::CompressedRistretto","0x1::ristretto255::CompressedRistretto","&0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>","&0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>","&0x1::confidential_amount::CompressedAmount","&0x1::option::Option<0x1::ristretto255::CompressedRistretto>","&vector<0x1::ristretto255::CompressedRistretto>"],"return":["0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_transfer::Transfer>","0x1::confidential_balance::Balance<0x1::confidential_balance::Pending>"]}],"structs":[{"name":"Transfer","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"TransferSession","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"sender","type":"address"},{"name":"recipient","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"num_avail_chunks","type":"u64"},{"name":"num_transfer_chunks","type":"u64"},{"name":"has_effective_auditor","type":"bool"},{"name":"num_volun_auditors","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_withdraw","friends":["0x1::confidential_asset"],"exposed_functions":[{"name":"assert_verifies","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_withdraw::WithdrawSession","&0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_withdraw::Withdrawal>","&0x1::sigma_protocol_proof::Proof"],"return":[]},{"name":"new_session","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>","bool"],"return":["0x1::sigma_protocol_withdraw::WithdrawSession"]},{"name":"new_withdrawal_statement","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::CompressedRistretto","&0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>","&0x1::confidential_balance::CompressedBalance<0x1::confidential_balance::Available>","&0x1::option::Option<0x1::ristretto255::CompressedRistretto>","0x1::ristretto255::Scalar"],"return":["0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_withdraw::Withdrawal>"]}],"structs":[{"name":"WithdrawSession","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"sender","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"num_chunks","type":"u64"},{"name":"has_auditor","type":"bool"}],"variants":[]},{"name":"Withdrawal","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"storage_slots_allocator","friends":[],"exposed_functions":[{"name":"remove","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","0x1::storage_slots_allocator::StoredSlot"],"return":["T0"]},{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["bool"],"return":["0x1::storage_slots_allocator::StorageSlotsAllocator<T0>"]},{"name":"borrow","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","u64"],"return":["&T0"]},{"name":"borrow_mut","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","u64"],"return":["&mut T0"]},{"name":"destroy_empty","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["0x1::storage_slots_allocator::StorageSlotsAllocator<T0>"],"return":[]},{"name":"add","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","T0"],"return":["0x1::storage_slots_allocator::StoredSlot"]},{"name":"allocate_spare_slots","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","u64"],"return":[]},{"name":"fill_reserved_slot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","0x1::storage_slots_allocator::ReservedSlot","T0"],"return":[]},{"name":"free_reserved_slot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","0x1::storage_slots_allocator::ReservedSlot","0x1::storage_slots_allocator::StoredSlot"],"return":[]},{"name":"get_num_spare_slot_count","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&0x1::storage_slots_allocator::StorageSlotsAllocator<T0>"],"return":["u32"]},{"name":"is_null_index","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["bool"]},{"name":"is_special_unused_index","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["bool"]},{"name":"remove_and_reserve","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>","u64"],"return":["0x1::storage_slots_allocator::ReservedSlot","T0"]},{"name":"reserve_slot","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["store"]}],"params":["&mut 0x1::storage_slots_allocator::StorageSlotsAllocator<T0>"],"return":["0x1::storage_slots_allocator::StoredSlot","0x1::storage_slots_allocator::ReservedSlot"]},{"name":"reserved_to_index","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::storage_slots_allocator::ReservedSlot"],"return":["u64"]},{"name":"stored_to_index","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::storage_slots_allocator::StoredSlot"],"return":["u64"]}],"structs":[{"name":"Link","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[{"constraints":["store"]}],"fields":[],"variants":[{"name":"Occupied","fields":[{"name":"value","type":"T0"}]},{"name":"Vacant","fields":[{"name":"next","type":"u64"}]}]},{"name":"ReservedSlot","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[],"fields":[{"name":"slot_index","type":"u64"}],"variants":[]},{"name":"StorageSlotsAllocator","is_native":false,"is_event":false,"is_enum":true,"abilities":["store"],"generic_type_params":[{"constraints":["store"]}],"fields":[],"variants":[{"name":"V1","fields":[{"name":"slots","type":"0x1::option::Option<0x1::table_with_length::TableWithLength<u64, 0x1::storage_slots_allocator::Link<T0>>>"},{"name":"new_slot_index","type":"u64"},{"name":"should_reuse","type":"bool"},{"name":"reuse_head_index","type":"u64"},{"name":"reuse_spare_count","type":"u32"}]}]},{"name":"StoredSlot","is_native":false,"is_event":false,"is_enum":false,"abilities":["store"],"generic_type_params":[],"fields":[{"name":"slot_index","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"chunky_dkg_config_seqnum","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]}],"structs":[{"name":"ChunkyDKGConfigSeqNum","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"seq_num","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"randomness_api_v0_config","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::option::Option<u64>"],"return":[]},{"name":"set_allow_max_gas_flag_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","bool"],"return":[]}],"structs":[{"name":"AllowCustomMaxGasFlag","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"value","type":"bool"}],"variants":[]},{"name":"RequiredGasDeposit","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"gas_amount","type":"0x1::option::Option<u64>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"randomness_config_seqnum","friends":["0x1::reconfiguration_with_dkg"],"exposed_functions":[{"name":"on_new_epoch","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"initialize","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"set_for_next_epoch","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","u64"],"return":[]}],"structs":[{"name":"RandomnessConfigSeqNum","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop","store","key"],"generic_type_params":[],"fields":[{"name":"seq_num","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"reconfiguration_with_dkg","friends":["0x1::aptos_governance","0x1::block"],"exposed_functions":[{"name":"finish","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer"],"return":[]},{"name":"try_advance_reconfig","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"try_start","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]},{"name":"try_start_with_chunky_dkg","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":[]}],"structs":[{"name":"ForceEndEpochEvent","is_native":false,"is_event":true,"is_enum":true,"abilities":["drop","store"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"epoch","type":"u64"},{"name":"dkg_incomplete","type":"bool"},{"name":"chunky_incomplete","type":"bool"},{"name":"deadline_us","type":"u64"},{"name":"now_us","type":"u64"}]}]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_statement","friends":["0x1::sigma_protocol_statement_builder","0x1::sigma_protocol_representation","0x1::sigma_protocol_homomorphism","0x1::sigma_protocol_fiat_shamir","0x1::sigma_protocol","0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[{"name":"get_scalars","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::sigma_protocol_statement::Statement<T0>"],"return":["&vector<0x1::ristretto255::Scalar>"]},{"name":"get_compressed_points","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::sigma_protocol_statement::Statement<T0>"],"return":["&vector<0x1::ristretto255::CompressedRistretto>"]},{"name":"get_point","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::sigma_protocol_statement::Statement<T0>","u64"],"return":["&0x1::ristretto255::RistrettoPoint"]},{"name":"get_points","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::sigma_protocol_statement::Statement<T0>"],"return":["&vector<0x1::ristretto255::RistrettoPoint>"]},{"name":"new_statement","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["vector<0x1::ristretto255::RistrettoPoint>","vector<0x1::ristretto255::CompressedRistretto>","vector<0x1::ristretto255::Scalar>"],"return":["0x1::sigma_protocol_statement::Statement<T0>"]}],"structs":[{"name":"Statement","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"points","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"compressed_points","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"scalars","type":"vector<0x1::ristretto255::Scalar>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"solana_derivable_account","friends":[],"exposed_functions":[{"name":"authenticate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["signer","0x1::auth_data::AbstractionAuthData"],"return":["signer"]}],"structs":[{"name":"SIWSAbstractSignature","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"MessageV1","fields":[{"name":"signature","type":"vector<u8>"}]}]}]}},{"abi":{"address":"0x1","name":"validator_consensus_info","friends":[],"exposed_functions":[{"name":"new","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","vector<u8>","u64"],"return":["0x1::validator_consensus_info::ValidatorConsensusInfo"]},{"name":"default","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["0x1::validator_consensus_info::ValidatorConsensusInfo"]},{"name":"get_addr","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::validator_consensus_info::ValidatorConsensusInfo"],"return":["address"]},{"name":"get_pk_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::validator_consensus_info::ValidatorConsensusInfo"],"return":["vector<u8>"]},{"name":"get_voting_power","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::validator_consensus_info::ValidatorConsensusInfo"],"return":["u64"]}],"structs":[{"name":"ValidatorConsensusInfo","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"addr","type":"address"},{"name":"pk_bytes","type":"vector<u8>"},{"name":"voting_power","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"confidential_range_proofs","friends":["0x1::confidential_asset"],"exposed_functions":[{"name":"assert_valid_range_proof","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<0x1::ristretto255::CompressedRistretto>","&0x1::ristretto255_bulletproofs::RangeProof"],"return":[]},{"name":"get_bulletproofs_dst","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[],"params":[],"return":["vector<u8>"]}],"structs":[]}},{"abi":{"address":"0x1","name":"ristretto255_bulletproofs","friends":[],"exposed_functions":[{"name":"get_max_range_bits","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["u64"]},{"name":"range_proof_from_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u8>"],"return":["0x1::ristretto255_bulletproofs::RangeProof"]},{"name":"range_proof_to_bytes","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_bulletproofs::RangeProof"],"return":["vector<u8>"]},{"name":"verify_batch_range_proof","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<0x1::ristretto255::RistrettoPoint>","&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255_bulletproofs::RangeProof","u64","vector<u8>"],"return":["bool"]},{"name":"verify_batch_range_proof_pedersen","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<0x1::ristretto255_pedersen::Commitment>","&0x1::ristretto255_bulletproofs::RangeProof","u64","vector<u8>"],"return":["bool"]},{"name":"verify_range_proof","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255::RistrettoPoint","&0x1::ristretto255_bulletproofs::RangeProof","u64","vector<u8>"],"return":["bool"]},{"name":"verify_range_proof_pedersen","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::ristretto255_pedersen::Commitment","&0x1::ristretto255_bulletproofs::RangeProof","u64","vector<u8>"],"return":["bool"]}],"structs":[{"name":"RangeProof","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop","store"],"generic_type_params":[],"fields":[{"name":"bytes","type":"vector<u8>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"ethereum_derivable_account","friends":[],"exposed_functions":[{"name":"authenticate","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["signer","0x1::auth_data::AbstractionAuthData"],"return":["signer"]}],"structs":[{"name":"SIWEAbstractPublicKey","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"ethereum_address","type":"vector<u8>"},{"name":"domain","type":"vector<u8>"}],"variants":[]},{"name":"SIWEAbstractSignature","is_native":false,"is_event":false,"is_enum":true,"abilities":["drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"MessageV1","fields":[{"name":"issued_at","type":"0x1::string::String"},{"name":"signature","type":"vector<u8>"}]},{"name":"MessageV2","fields":[{"name":"scheme","type":"0x1::string::String"},{"name":"issued_at","type":"0x1::string::String"},{"name":"signature","type":"vector<u8>"}]}]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_fiat_shamir","friends":["0x1::sigma_protocol","0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[{"name":"fiat_shamir","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::sigma_protocol_fiat_shamir::DomainSeparator","&0x1::sigma_protocol_statement::Statement<T0>","&vector<0x1::ristretto255::CompressedRistretto>","&vector<0x1::ristretto255::Scalar>","u64"],"return":["0x1::ristretto255::Scalar","vector<0x1::ristretto255::Scalar>"]},{"name":"new_domain_separator","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["address","u8","vector<u8>","vector<u8>"],"return":["0x1::sigma_protocol_fiat_shamir::DomainSeparator"]}],"structs":[{"name":"DomainSeparator","is_native":false,"is_event":false,"is_enum":true,"abilities":["copy","drop"],"generic_type_params":[],"fields":[],"variants":[{"name":"V1","fields":[{"name":"contract_address","type":"address"},{"name":"chain_id","type":"u8"},{"name":"protocol_id","type":"vector<u8>"},{"name":"session_id","type":"vector<u8>"}]}]},{"name":"FiatShamirInputs","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"dst","type":"0x1::sigma_protocol_fiat_shamir::DomainSeparator"},{"name":"type_name","type":"0x1::string::String"},{"name":"k","type":"u64"},{"name":"stmt_X","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"stmt_x","type":"vector<0x1::ristretto255::Scalar>"},{"name":"proof_A","type":"vector<0x1::ristretto255::CompressedRistretto>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"dispatchable_fungible_asset","friends":[],"exposed_functions":[{"name":"transfer","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","0x1::object::Object<T0>","u64"],"return":[]},{"name":"deposit","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","0x1::fungible_asset::FungibleAsset"],"return":[]},{"name":"register_derive_supply_dispatch_function","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef","0x1::option::Option<0x1::function_info::FunctionInfo>"],"return":[]},{"name":"register_dispatch_functions","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::object::ConstructorRef","0x1::option::Option<0x1::function_info::FunctionInfo>","0x1::option::Option<0x1::function_info::FunctionInfo>","0x1::option::Option<0x1::function_info::FunctionInfo>"],"return":[]},{"name":"withdraw","visibility":"public","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","u64"],"return":["0x1::fungible_asset::FungibleAsset"]},{"name":"derived_balance","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["u64"]},{"name":"derived_supply","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>"],"return":["0x1::option::Option<u128>"]},{"name":"is_derived_balance_at_least","visibility":"public","is_entry":false,"is_view":true,"generic_type_params":[{"constraints":["key"]}],"params":["0x1::object::Object<T0>","u64"],"return":["bool"]},{"name":"transfer_assert_minimum_deposit","visibility":"public","is_entry":true,"is_view":false,"generic_type_params":[{"constraints":["key"]}],"params":["&signer","0x1::object::Object<T0>","0x1::object::Object<T0>","u64","u64"],"return":[]}],"structs":[{"name":"TransferRefStore","is_native":false,"is_event":false,"is_enum":false,"abilities":["key"],"generic_type_params":[],"fields":[{"name":"transfer_ref","type":"0x1::fungible_asset::TransferRef"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_homomorphism","friends":["0x1::sigma_protocol","0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[],"structs":[{"name":"Homomorphism","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"_0","type":"|&0x1::sigma_protocol_statement::Statement<T0>,&0x1::sigma_protocol_witness::Witness|0x1::sigma_protocol_representation_vec::RepresentationVec"}],"variants":[]},{"name":"TransformationFunction","is_native":false,"is_event":false,"is_enum":false,"abilities":[],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"_0","type":"|&0x1::sigma_protocol_statement::Statement<T0>|0x1::sigma_protocol_representation_vec::RepresentationVec"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_key_rotation","friends":["0x1::confidential_asset"],"exposed_functions":[{"name":"assert_verifies","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_key_rotation::KeyRotationSession","&0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_key_rotation::KeyRotation>","&0x1::sigma_protocol_proof::Proof"],"return":[]},{"name":"new_session","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::sigma_protocol_key_rotation::KeyRotationSession"]},{"name":"new_key_rotation_statement","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::CompressedRistretto","0x1::ristretto255::CompressedRistretto","&vector<0x1::ristretto255::CompressedRistretto>","&vector<0x1::ristretto255::CompressedRistretto>"],"return":["0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_key_rotation::KeyRotation>"]}],"structs":[{"name":"KeyRotation","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"KeyRotationSession","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"sender","type":"address"},{"name":"token_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"},{"name":"num_chunks","type":"u64"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_registration","friends":["0x1::confidential_asset"],"exposed_functions":[{"name":"assert_verifies","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_registration::RegistrationSession","&0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_registration::Registration>","&0x1::sigma_protocol_proof::Proof"],"return":[]},{"name":"new_session","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&signer","0x1::object::Object<0x1::fungible_asset::Metadata>"],"return":["0x1::sigma_protocol_registration::RegistrationSession"]},{"name":"new_registration_statement","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["0x1::ristretto255::CompressedRistretto"],"return":["0x1::sigma_protocol_statement::Statement<0x1::sigma_protocol_registration::Registration>"]}],"structs":[{"name":"Registration","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"dummy_field","type":"bool"}],"variants":[]},{"name":"RegistrationSession","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"sender","type":"address"},{"name":"asset_type","type":"0x1::object::Object<0x1::fungible_asset::Metadata>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_representation","friends":["0x1::sigma_protocol_representation_vec","0x1::sigma_protocol_homomorphism","0x1::sigma_protocol","0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[{"name":"get_scalars","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_representation::Representation"],"return":["&vector<0x1::ristretto255::Scalar>"]},{"name":"new_representation","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<u64>","vector<0x1::ristretto255::Scalar>"],"return":["0x1::sigma_protocol_representation::Representation"]},{"name":"repr_point","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64"],"return":["0x1::sigma_protocol_representation::Representation"]},{"name":"repr_scaled","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["u64","0x1::ristretto255::Scalar"],"return":["0x1::sigma_protocol_representation::Representation"]},{"name":"scale","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::sigma_protocol_representation::Representation","&0x1::ristretto255::Scalar"],"return":[]},{"name":"to_points","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&0x1::sigma_protocol_representation::Representation","&0x1::sigma_protocol_statement::Statement<T0>"],"return":["vector<0x1::ristretto255::RistrettoPoint>"]}],"structs":[{"name":"Representation","is_native":false,"is_event":false,"is_enum":false,"abilities":["copy","drop"],"generic_type_params":[],"fields":[{"name":"point_idxs","type":"vector<u64>"},{"name":"scalars","type":"vector<0x1::ristretto255::Scalar>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"sigma_protocol_statement_builder","friends":["0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[{"name":"add_point","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::sigma_protocol_statement_builder::StatementBuilder<T0>","0x1::ristretto255::CompressedRistretto"],"return":["u64"]},{"name":"add_points","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::sigma_protocol_statement_builder::StatementBuilder<T0>","&vector<0x1::ristretto255::CompressedRistretto>"],"return":["u64"]},{"name":"add_points_cloned","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::sigma_protocol_statement_builder::StatementBuilder<T0>","&vector<0x1::ristretto255::CompressedRistretto>"],"return":["u64","vector<0x1::ristretto255::RistrettoPoint>"]},{"name":"add_scalar","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["&mut 0x1::sigma_protocol_statement_builder::StatementBuilder<T0>","0x1::ristretto255::Scalar"],"return":["u64"]},{"name":"build","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":["0x1::sigma_protocol_statement_builder::StatementBuilder<T0>"],"return":["0x1::sigma_protocol_statement::Statement<T0>"]},{"name":"new_builder","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[{"constraints":[]}],"params":[],"return":["0x1::sigma_protocol_statement_builder::StatementBuilder<T0>"]}],"structs":[{"name":"StatementBuilder","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[{"constraints":[]}],"fields":[{"name":"points","type":"vector<0x1::ristretto255::RistrettoPoint>"},{"name":"compressed_points","type":"vector<0x1::ristretto255::CompressedRistretto>"},{"name":"scalars","type":"vector<0x1::ristretto255::Scalar>"}],"variants":[]}]}},{"abi":{"address":"0x1","name":"common_account_abstractions_utils","friends":["0x1::ethereum_derivable_account","0x1::solana_derivable_account","0x1::sui_derivable_account"],"exposed_functions":[{"name":"construct_message","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&vector<u8>","&vector<u8>","&vector<u8>","&vector<u8>","&vector<u8>"],"return":["vector<u8>"]},{"name":"entry_function_name","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::transaction_context::EntryFunctionPayload"],"return":["vector<u8>"]},{"name":"network_name","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":[],"return":["vector<u8>"]}],"structs":[]}},{"abi":{"address":"0x1","name":"sigma_protocol_representation_vec","friends":["0x1::sigma_protocol_homomorphism","0x1::sigma_protocol","0x1::sigma_protocol_withdraw","0x1::sigma_protocol_transfer","0x1::sigma_protocol_registration","0x1::sigma_protocol_key_rotation"],"exposed_functions":[{"name":"length","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_representation_vec::RepresentationVec"],"return":["u64"]},{"name":"get_representations","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&0x1::sigma_protocol_representation_vec::RepresentationVec"],"return":["&vector<0x1::sigma_protocol_representation::Representation>"]},{"name":"new_representation_vec","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["vector<0x1::sigma_protocol_representation::Representation>"],"return":["0x1::sigma_protocol_representation_vec::RepresentationVec"]},{"name":"scale_all","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::sigma_protocol_representation_vec::RepresentationVec","&0x1::ristretto255::Scalar"],"return":[]},{"name":"scale_each","visibility":"friend","is_entry":false,"is_view":false,"generic_type_params":[],"params":["&mut 0x1::sigma_protocol_representation_vec::RepresentationVec","&vector<0x1::ristretto255::Scalar>"],"return":[]}],"structs":[{"name":"RepresentationVec","is_native":false,"is_event":false,"is_enum":false,"abilities":["drop"],"generic_type_params":[],"fields":[{"name":"v","type":"vector<0x1::sigma_protocol_representation::Representation>"}],"variants":[]}]}}]',
);

export function loadAllTypes(coder: MoveCoder) {
  for (const m of Object.values(MODULES)) {
    coder.load(m as any, "0x1");
  }
}

loadAllTypes(defaultMoveCoder(AptosNetwork.MAIN_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.TEST_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.MOVEMENT_MAIN_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.MOVEMENT_TEST_NET));
loadAllTypes(defaultMoveCoder(AptosNetwork.INITIA_ECHELON));