import * as $ from '@manahippo/move-to-ts';
import { AptosDataCache, AptosParserRepo, DummyCache, AptosLocalCache } from '@manahippo/move-to-ts';
import { U8, U64, U128 } from '@manahippo/move-to-ts';
import { u8, u64, u128 } from '@manahippo/move-to-ts';
import { TypeParamDeclType, FieldDeclType } from '@manahippo/move-to-ts';
import { AtomicTypeTag, StructTag, TypeTag, VectorTag, SimpleStructTag } from '@manahippo/move-to-ts';
import { OptionTransaction } from '@manahippo/move-to-ts';
import { HexString, AptosClient, AptosAccount, TxnBuilderTypes, Types } from 'aptos';
import * as Account from './account';
import * as Bcs from './bcs';
import * as Coin from './coin';
import * as Error from './error';
import * as Event from './event';
import * as Pool_u64 from './pool_u64';
import * as Signer from './signer';
import * as Simple_map from './simple_map';
import * as Stake from './stake';
import * as Staking_config from './staking_config';
import * as Vector from './vector';
export const packageName = 'AptosFramework';
export const moduleAddress = new HexString('0x1');
export const moduleName = 'staking_contract';

export const ECANT_MERGE_STAKING_CONTRACTS: U64 = u64('5');
export const EINSUFFICIENT_ACTIVE_STAKE_TO_WITHDRAW: U64 = u64('7');
export const EINSUFFICIENT_STAKE_AMOUNT: U64 = u64('1');
export const EINVALID_COMMISSION_PERCENTAGE: U64 = u64('2');
export const ENOT_STAKER_OR_OPERATOR: U64 = u64('8');
export const ENO_STAKING_CONTRACT_FOUND_FOR_OPERATOR: U64 = u64('4');
export const ENO_STAKING_CONTRACT_FOUND_FOR_STAKER: U64 = u64('3');
export const ESTAKING_CONTRACT_ALREADY_EXISTS: U64 = u64('6');
export const MAXIMUM_PENDING_DISTRIBUTIONS: U64 = u64('20');
export const SALT: U8[] = [
  u8('97'),
  u8('112'),
  u8('116'),
  u8('111'),
  u8('115'),
  u8('95'),
  u8('102'),
  u8('114'),
  u8('97'),
  u8('109'),
  u8('101'),
  u8('119'),
  u8('111'),
  u8('114'),
  u8('107'),
  u8('58'),
  u8('58'),
  u8('115'),
  u8('116'),
  u8('97'),
  u8('107'),
  u8('105'),
  u8('110'),
  u8('103'),
  u8('95'),
  u8('99'),
  u8('111'),
  u8('110'),
  u8('116'),
  u8('114'),
  u8('97'),
  u8('99'),
  u8('116')
];

export class AddDistributionEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'AddDistributionEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'amount', typeTag: AtomicTypeTag.U64 }
  ];

  operator: HexString;
  pool_address: HexString;
  amount: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
    this.amount = proto['amount'] as U64;
  }

  static AddDistributionEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): AddDistributionEvent {
    const proto = $.parseStructProto(data, typeTag, repo, AddDistributionEvent);
    return new AddDistributionEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'AddDistributionEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class AddStakeEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'AddStakeEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'amount', typeTag: AtomicTypeTag.U64 }
  ];

  operator: HexString;
  pool_address: HexString;
  amount: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
    this.amount = proto['amount'] as U64;
  }

  static AddStakeEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): AddStakeEvent {
    const proto = $.parseStructProto(data, typeTag, repo, AddStakeEvent);
    return new AddStakeEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'AddStakeEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class CreateStakingContractEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'CreateStakingContractEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'voter', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'principal', typeTag: AtomicTypeTag.U64 },
    { name: 'commission_percentage', typeTag: AtomicTypeTag.U64 }
  ];

  operator: HexString;
  voter: HexString;
  pool_address: HexString;
  principal: U64;
  commission_percentage: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.voter = proto['voter'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
    this.principal = proto['principal'] as U64;
    this.commission_percentage = proto['commission_percentage'] as U64;
  }

  static CreateStakingContractEventParser(
    data: any,
    typeTag: TypeTag,
    repo: AptosParserRepo
  ): CreateStakingContractEvent {
    const proto = $.parseStructProto(data, typeTag, repo, CreateStakingContractEvent);
    return new CreateStakingContractEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'CreateStakingContractEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class DistributeEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'DistributeEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'recipient', typeTag: AtomicTypeTag.Address },
    { name: 'amount', typeTag: AtomicTypeTag.U64 }
  ];

  operator: HexString;
  pool_address: HexString;
  recipient: HexString;
  amount: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
    this.recipient = proto['recipient'] as HexString;
    this.amount = proto['amount'] as U64;
  }

  static DistributeEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): DistributeEvent {
    const proto = $.parseStructProto(data, typeTag, repo, DistributeEvent);
    return new DistributeEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'DistributeEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class RequestCommissionEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'RequestCommissionEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'accumulated_rewards', typeTag: AtomicTypeTag.U64 },
    { name: 'commission_amount', typeTag: AtomicTypeTag.U64 }
  ];

  operator: HexString;
  pool_address: HexString;
  accumulated_rewards: U64;
  commission_amount: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
    this.accumulated_rewards = proto['accumulated_rewards'] as U64;
    this.commission_amount = proto['commission_amount'] as U64;
  }

  static RequestCommissionEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): RequestCommissionEvent {
    const proto = $.parseStructProto(data, typeTag, repo, RequestCommissionEvent);
    return new RequestCommissionEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'RequestCommissionEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class ResetLockupEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'ResetLockupEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address }
  ];

  operator: HexString;
  pool_address: HexString;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
  }

  static ResetLockupEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): ResetLockupEvent {
    const proto = $.parseStructProto(data, typeTag, repo, ResetLockupEvent);
    return new ResetLockupEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'ResetLockupEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class StakingContract {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'StakingContract';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'principal', typeTag: AtomicTypeTag.U64 },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'owner_cap', typeTag: new StructTag(new HexString('0x1'), 'stake', 'OwnerCapability', []) },
    { name: 'commission_percentage', typeTag: AtomicTypeTag.U64 },
    { name: 'distribution_pool', typeTag: new StructTag(new HexString('0x1'), 'pool_u64', 'Pool', []) },
    { name: 'signer_cap', typeTag: new StructTag(new HexString('0x1'), 'account', 'SignerCapability', []) }
  ];

  principal: U64;
  pool_address: HexString;
  owner_cap: Stake.OwnerCapability;
  commission_percentage: U64;
  distribution_pool: Pool_u64.Pool;
  signer_cap: Account.SignerCapability;

  constructor(proto: any, public typeTag: TypeTag) {
    this.principal = proto['principal'] as U64;
    this.pool_address = proto['pool_address'] as HexString;
    this.owner_cap = proto['owner_cap'] as Stake.OwnerCapability;
    this.commission_percentage = proto['commission_percentage'] as U64;
    this.distribution_pool = proto['distribution_pool'] as Pool_u64.Pool;
    this.signer_cap = proto['signer_cap'] as Account.SignerCapability;
  }

  static StakingContractParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): StakingContract {
    const proto = $.parseStructProto(data, typeTag, repo, StakingContract);
    return new StakingContract(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'StakingContract', []);
  }
  async loadFullState(app: $.AppType) {
    await this.owner_cap.loadFullState(app);
    await this.distribution_pool.loadFullState(app);
    await this.signer_cap.loadFullState(app);
    this.__app = app;
  }
}

export class Store {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'Store';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    {
      name: 'staking_contracts',
      typeTag: new StructTag(new HexString('0x1'), 'simple_map', 'SimpleMap', [
        AtomicTypeTag.Address,
        new StructTag(new HexString('0x1'), 'staking_contract', 'StakingContract', [])
      ])
    },
    {
      name: 'create_staking_contract_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'CreateStakingContractEvent', [])
      ])
    },
    {
      name: 'update_voter_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'UpdateVoterEvent', [])
      ])
    },
    {
      name: 'reset_lockup_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'ResetLockupEvent', [])
      ])
    },
    {
      name: 'add_stake_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'AddStakeEvent', [])
      ])
    },
    {
      name: 'request_commission_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'RequestCommissionEvent', [])
      ])
    },
    {
      name: 'unlock_stake_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'UnlockStakeEvent', [])
      ])
    },
    {
      name: 'switch_operator_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'SwitchOperatorEvent', [])
      ])
    },
    {
      name: 'add_distribution_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'AddDistributionEvent', [])
      ])
    },
    {
      name: 'distribute_events',
      typeTag: new StructTag(new HexString('0x1'), 'event', 'EventHandle', [
        new StructTag(new HexString('0x1'), 'staking_contract', 'DistributeEvent', [])
      ])
    }
  ];

  staking_contracts: Simple_map.SimpleMap;
  create_staking_contract_events: Event.EventHandle;
  update_voter_events: Event.EventHandle;
  reset_lockup_events: Event.EventHandle;
  add_stake_events: Event.EventHandle;
  request_commission_events: Event.EventHandle;
  unlock_stake_events: Event.EventHandle;
  switch_operator_events: Event.EventHandle;
  add_distribution_events: Event.EventHandle;
  distribute_events: Event.EventHandle;

  constructor(proto: any, public typeTag: TypeTag) {
    this.staking_contracts = proto['staking_contracts'] as Simple_map.SimpleMap;
    this.create_staking_contract_events = proto['create_staking_contract_events'] as Event.EventHandle;
    this.update_voter_events = proto['update_voter_events'] as Event.EventHandle;
    this.reset_lockup_events = proto['reset_lockup_events'] as Event.EventHandle;
    this.add_stake_events = proto['add_stake_events'] as Event.EventHandle;
    this.request_commission_events = proto['request_commission_events'] as Event.EventHandle;
    this.unlock_stake_events = proto['unlock_stake_events'] as Event.EventHandle;
    this.switch_operator_events = proto['switch_operator_events'] as Event.EventHandle;
    this.add_distribution_events = proto['add_distribution_events'] as Event.EventHandle;
    this.distribute_events = proto['distribute_events'] as Event.EventHandle;
  }

  static StoreParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): Store {
    const proto = $.parseStructProto(data, typeTag, repo, Store);
    return new Store(proto, typeTag);
  }

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, Store, typeParams);
    return result as unknown as Store;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, Store, typeParams);
    await result.loadFullState(app);
    return result as unknown as Store;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'Store', []);
  }
  async loadFullState(app: $.AppType) {
    await this.staking_contracts.loadFullState(app);
    await this.create_staking_contract_events.loadFullState(app);
    await this.update_voter_events.loadFullState(app);
    await this.reset_lockup_events.loadFullState(app);
    await this.add_stake_events.loadFullState(app);
    await this.request_commission_events.loadFullState(app);
    await this.unlock_stake_events.loadFullState(app);
    await this.switch_operator_events.loadFullState(app);
    await this.add_distribution_events.loadFullState(app);
    await this.distribute_events.loadFullState(app);
    this.__app = app;
  }
}

export class SwitchOperatorEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'SwitchOperatorEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'old_operator', typeTag: AtomicTypeTag.Address },
    { name: 'new_operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address }
  ];

  old_operator: HexString;
  new_operator: HexString;
  pool_address: HexString;

  constructor(proto: any, public typeTag: TypeTag) {
    this.old_operator = proto['old_operator'] as HexString;
    this.new_operator = proto['new_operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
  }

  static SwitchOperatorEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): SwitchOperatorEvent {
    const proto = $.parseStructProto(data, typeTag, repo, SwitchOperatorEvent);
    return new SwitchOperatorEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'SwitchOperatorEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class UnlockStakeEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'UnlockStakeEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'amount', typeTag: AtomicTypeTag.U64 },
    { name: 'commission_paid', typeTag: AtomicTypeTag.U64 }
  ];

  operator: HexString;
  pool_address: HexString;
  amount: U64;
  commission_paid: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
    this.amount = proto['amount'] as U64;
    this.commission_paid = proto['commission_paid'] as U64;
  }

  static UnlockStakeEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): UnlockStakeEvent {
    const proto = $.parseStructProto(data, typeTag, repo, UnlockStakeEvent);
    return new UnlockStakeEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'UnlockStakeEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}

export class UpdateVoterEvent {
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = 'UpdateVoterEvent';
  static typeParameters: TypeParamDeclType[] = [];
  static fields: FieldDeclType[] = [
    { name: 'operator', typeTag: AtomicTypeTag.Address },
    { name: 'pool_address', typeTag: AtomicTypeTag.Address },
    { name: 'old_voter', typeTag: AtomicTypeTag.Address },
    { name: 'new_voter', typeTag: AtomicTypeTag.Address }
  ];

  operator: HexString;
  pool_address: HexString;
  old_voter: HexString;
  new_voter: HexString;

  constructor(proto: any, public typeTag: TypeTag) {
    this.operator = proto['operator'] as HexString;
    this.pool_address = proto['pool_address'] as HexString;
    this.old_voter = proto['old_voter'] as HexString;
    this.new_voter = proto['new_voter'] as HexString;
  }

  static UpdateVoterEventParser(data: any, typeTag: TypeTag, repo: AptosParserRepo): UpdateVoterEvent {
    const proto = $.parseStructProto(data, typeTag, repo, UpdateVoterEvent);
    return new UpdateVoterEvent(proto, typeTag);
  }

  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, 'UpdateVoterEvent', []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }
}
export function add_distribution_(
  operator: HexString,
  staking_contract: StakingContract,
  recipient: HexString,
  coins_amount: U64,
  add_distribution_events: Event.EventHandle,
  $c: AptosDataCache
): void {
  let distribution_pool, pool_address, total_distribution_amount;
  distribution_pool = staking_contract.distribution_pool;
  [, , , total_distribution_amount] = Stake.get_stake_($.copy(staking_contract.pool_address), $c);
  update_distribution_pool_(
    distribution_pool,
    $.copy(total_distribution_amount),
    $.copy(operator),
    $.copy(staking_contract.commission_percentage),
    $c
  );
  Pool_u64.buy_in_(distribution_pool, $.copy(recipient), $.copy(coins_amount), $c);
  pool_address = $.copy(staking_contract.pool_address);
  Event.emit_event_(
    add_distribution_events,
    new AddDistributionEvent(
      { operator: $.copy(operator), pool_address: $.copy(pool_address), amount: $.copy(coins_amount) },
      new SimpleStructTag(AddDistributionEvent)
    ),
    $c,
    [new SimpleStructTag(AddDistributionEvent)]
  );
  return;
}

export function add_stake_(staker: HexString, operator: HexString, amount: U64, $c: AptosDataCache): void {
  let pool_address, staked_coins, staker_address, staking_contract, store;
  staker_address = Signer.address_of_(staker, $c);
  assert_staking_contract_exists_($.copy(staker_address), $.copy(operator), $c);
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker_address));
  staking_contract = Simple_map.borrow_mut_(store.staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  staked_coins = Coin.withdraw_(staker, $.copy(amount), $c, [
    new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
  ]);
  Stake.add_stake_with_cap_(staking_contract.owner_cap, staked_coins, $c);
  staking_contract.principal = $.copy(staking_contract.principal).add($.copy(amount));
  pool_address = $.copy(staking_contract.pool_address);
  Event.emit_event_(
    store.add_stake_events,
    new AddStakeEvent(
      { operator: $.copy(operator), pool_address: $.copy(pool_address), amount: $.copy(amount) },
      new SimpleStructTag(AddStakeEvent)
    ),
    $c,
    [new SimpleStructTag(AddStakeEvent)]
  );
  return;
}

export function buildPayload_add_stake(
  operator: HexString,
  amount: U64,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'add_stake',
    typeParamStrings,
    [operator, amount],
    isJSON
  );
}
export function assert_staking_contract_exists_(staker: HexString, operator: HexString, $c: AptosDataCache): void {
  let temp$1, temp$2, staking_contracts;
  if (!$c.exists(new SimpleStructTag(Store), $.copy(staker))) {
    throw $.abortCode(Error.not_found_($.copy(ENO_STAKING_CONTRACT_FOUND_FOR_STAKER), $c));
  }
  staking_contracts = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker)).staking_contracts;
  [temp$1, temp$2] = [staking_contracts, operator];
  if (!Simple_map.contains_key_(temp$1, temp$2, $c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)])) {
    throw $.abortCode(Error.not_found_($.copy(ENO_STAKING_CONTRACT_FOUND_FOR_OPERATOR), $c));
  }
  return;
}

export function commission_percentage_(staker: HexString, operator: HexString, $c: AptosDataCache): U64 {
  let staking_contracts;
  assert_staking_contract_exists_($.copy(staker), $.copy(operator), $c);
  staking_contracts = $c.borrow_global<Store>(new SimpleStructTag(Store), $.copy(staker)).staking_contracts;
  return $.copy(
    Simple_map.borrow_(staking_contracts, operator, $c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)])
      .commission_percentage
  );
}

export function create_stake_pool_(
  staker: HexString,
  operator: HexString,
  voter: HexString,
  contract_creation_seed: U8[],
  $c: AptosDataCache
): [HexString, Account.SignerCapability, Stake.OwnerCapability] {
  let temp$1, owner_cap, seed, stake_pool_signer, stake_pool_signer_cap;
  temp$1 = Signer.address_of_(staker, $c);
  seed = Bcs.to_bytes_(temp$1, $c, [AtomicTypeTag.Address]);
  Vector.append_(seed, Bcs.to_bytes_(operator, $c, [AtomicTypeTag.Address]), $c, [AtomicTypeTag.U8]);
  Vector.append_(seed, $.copy(SALT), $c, [AtomicTypeTag.U8]);
  Vector.append_(seed, $.copy(contract_creation_seed), $c, [AtomicTypeTag.U8]);
  [stake_pool_signer, stake_pool_signer_cap] = Account.create_resource_account_(staker, $.copy(seed), $c);
  Stake.initialize_stake_owner_(stake_pool_signer, u64('0'), $.copy(operator), $.copy(voter), $c);
  owner_cap = Stake.extract_owner_cap_(stake_pool_signer, $c);
  return [stake_pool_signer, stake_pool_signer_cap, owner_cap];
}

export function create_staking_contract_(
  staker: HexString,
  operator: HexString,
  voter: HexString,
  amount: U64,
  commission_percentage: U64,
  contract_creation_seed: U8[],
  $c: AptosDataCache
): void {
  let staked_coins;
  staked_coins = Coin.withdraw_(staker, $.copy(amount), $c, [
    new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
  ]);
  create_staking_contract_with_coins_(
    staker,
    $.copy(operator),
    $.copy(voter),
    staked_coins,
    $.copy(commission_percentage),
    $.copy(contract_creation_seed),
    $c
  );
  return;
}

export function buildPayload_create_staking_contract(
  operator: HexString,
  voter: HexString,
  amount: U64,
  commission_percentage: U64,
  contract_creation_seed: U8[],
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'create_staking_contract',
    typeParamStrings,
    [operator, voter, amount, commission_percentage, contract_creation_seed],
    isJSON
  );
}
export function create_staking_contract_with_coins_(
  staker: HexString,
  operator: HexString,
  voter: HexString,
  coins: Coin.Coin,
  commission_percentage: U64,
  contract_creation_seed: U8[],
  $c: AptosDataCache
): HexString {
  let temp$1,
    temp$2,
    temp$3,
    temp$4,
    min_stake_required,
    owner_cap,
    pool_address,
    principal,
    stake_pool_signer,
    stake_pool_signer_cap,
    staker_address,
    staking_contracts,
    store;
  if ($.copy(commission_percentage).ge(u64('0'))) {
    temp$1 = $.copy(commission_percentage).le(u64('100'));
  } else {
    temp$1 = false;
  }
  if (!temp$1) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINVALID_COMMISSION_PERCENTAGE), $c));
  }
  temp$2 = Staking_config.get_($c);
  [min_stake_required] = Staking_config.get_required_stake_(temp$2, $c);
  principal = Coin.value_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  if (!$.copy(principal).ge($.copy(min_stake_required))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_STAKE_AMOUNT), $c));
  }
  staker_address = Signer.address_of_(staker, $c);
  if (!$c.exists(new SimpleStructTag(Store), $.copy(staker_address))) {
    $c.move_to(new SimpleStructTag(Store), staker, new_staking_contracts_holder_(staker, $c));
  } else {
  }
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker_address));
  staking_contracts = store.staking_contracts;
  [temp$3, temp$4] = [staking_contracts, operator];
  if (!!Simple_map.contains_key_(temp$3, temp$4, $c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)])) {
    throw $.abortCode(Error.already_exists_($.copy(ESTAKING_CONTRACT_ALREADY_EXISTS), $c));
  }
  [stake_pool_signer, stake_pool_signer_cap, owner_cap] = create_stake_pool_(
    staker,
    $.copy(operator),
    $.copy(voter),
    $.copy(contract_creation_seed),
    $c
  );
  Stake.add_stake_with_cap_(owner_cap, coins, $c);
  pool_address = Signer.address_of_(stake_pool_signer, $c);
  Simple_map.add_(
    staking_contracts,
    $.copy(operator),
    new StakingContract(
      {
        principal: $.copy(principal),
        pool_address: $.copy(pool_address),
        owner_cap: owner_cap,
        commission_percentage: $.copy(commission_percentage),
        distribution_pool: Pool_u64.create_($.copy(MAXIMUM_PENDING_DISTRIBUTIONS), $c),
        signer_cap: stake_pool_signer_cap
      },
      new SimpleStructTag(StakingContract)
    ),
    $c,
    [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)]
  );
  Event.emit_event_(
    store.create_staking_contract_events,
    new CreateStakingContractEvent(
      {
        operator: $.copy(operator),
        voter: $.copy(voter),
        pool_address: $.copy(pool_address),
        principal: $.copy(principal),
        commission_percentage: $.copy(commission_percentage)
      },
      new SimpleStructTag(CreateStakingContractEvent)
    ),
    $c,
    [new SimpleStructTag(CreateStakingContractEvent)]
  );
  return $.copy(pool_address);
}

export function distribute_(staker: HexString, operator: HexString, $c: AptosDataCache): void {
  let staking_contract, store;
  assert_staking_contract_exists_($.copy(staker), $.copy(operator), $c);
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker));
  staking_contract = Simple_map.borrow_mut_(store.staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  distribute_internal_($.copy(staker), $.copy(operator), staking_contract, store.distribute_events, $c);
  return;
}

export function buildPayload_distribute(
  staker: HexString,
  operator: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'distribute',
    typeParamStrings,
    [staker, operator],
    isJSON
  );
}
export function distribute_internal_(
  staker: HexString,
  operator: HexString,
  staking_contract: StakingContract,
  distribute_events: Event.EventHandle,
  $c: AptosDataCache
): void {
  let temp$1,
    temp$2,
    temp$3,
    temp$4,
    amount_to_distribute,
    coins,
    current_shares,
    distribution_amount,
    distribution_pool,
    inactive,
    pending_inactive,
    pool_address,
    recipient,
    recipients,
    total_potential_withdrawable;
  pool_address = $.copy(staking_contract.pool_address);
  [, inactive, , pending_inactive] = Stake.get_stake_($.copy(pool_address), $c);
  total_potential_withdrawable = $.copy(inactive).add($.copy(pending_inactive));
  coins = Stake.withdraw_with_cap_(staking_contract.owner_cap, $.copy(total_potential_withdrawable), $c);
  distribution_amount = Coin.value_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  if ($.copy(distribution_amount).eq(u64('0'))) {
    Coin.destroy_zero_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
    return;
  } else {
  }
  distribution_pool = staking_contract.distribution_pool;
  update_distribution_pool_(
    distribution_pool,
    $.copy(distribution_amount),
    $.copy(operator),
    $.copy(staking_contract.commission_percentage),
    $c
  );
  while (Pool_u64.shareholders_count_(distribution_pool, $c).gt(u64('0'))) {
    {
      recipients = Pool_u64.shareholders_(distribution_pool, $c);
      [temp$1, temp$2] = [recipients, u64('0')];
      recipient = $.copy(Vector.borrow_(temp$1, temp$2, $c, [AtomicTypeTag.Address]));
      [temp$3, temp$4] = [distribution_pool, $.copy(recipient)];
      current_shares = Pool_u64.shares_(temp$3, temp$4, $c);
      amount_to_distribute = Pool_u64.redeem_shares_(distribution_pool, $.copy(recipient), $.copy(current_shares), $c);
      Coin.deposit_(
        $.copy(recipient),
        Coin.extract_(coins, $.copy(amount_to_distribute), $c, [
          new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])
        ]),
        $c,
        [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]
      );
      Event.emit_event_(
        distribute_events,
        new DistributeEvent(
          {
            operator: $.copy(operator),
            pool_address: $.copy(pool_address),
            recipient: $.copy(recipient),
            amount: $.copy(amount_to_distribute)
          },
          new SimpleStructTag(DistributeEvent)
        ),
        $c,
        [new SimpleStructTag(DistributeEvent)]
      );
    }
  }
  if (Coin.value_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]).gt(u64('0'))) {
    Coin.deposit_($.copy(staker), coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
    Pool_u64.update_total_coins_(distribution_pool, u64('0'), $c);
  } else {
    Coin.destroy_zero_(coins, $c, [new StructTag(new HexString('0x1'), 'aptos_coin', 'AptosCoin', [])]);
  }
  return;
}

export function get_staking_contract_amounts_internal_(
  staking_contract: StakingContract,
  $c: AptosDataCache
): [U64, U64, U64] {
  let accumulated_rewards, active, commission_amount, pending_active, total_active_stake;
  [active, , pending_active] = Stake.get_stake_($.copy(staking_contract.pool_address), $c);
  total_active_stake = $.copy(active).add($.copy(pending_active));
  accumulated_rewards = $.copy(total_active_stake).sub($.copy(staking_contract.principal));
  commission_amount = $.copy(accumulated_rewards).mul($.copy(staking_contract.commission_percentage)).div(u64('100'));
  return [$.copy(total_active_stake), $.copy(accumulated_rewards), $.copy(commission_amount)];
}

export function last_recorded_principal_(staker: HexString, operator: HexString, $c: AptosDataCache): U64 {
  let staking_contracts;
  assert_staking_contract_exists_($.copy(staker), $.copy(operator), $c);
  staking_contracts = $c.borrow_global<Store>(new SimpleStructTag(Store), $.copy(staker)).staking_contracts;
  return $.copy(
    Simple_map.borrow_(staking_contracts, operator, $c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)])
      .principal
  );
}

export function new_staking_contracts_holder_(staker: HexString, $c: AptosDataCache): Store {
  return new Store(
    {
      staking_contracts: Simple_map.create_($c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)]),
      create_staking_contract_events: Account.new_event_handle_(staker, $c, [
        new SimpleStructTag(CreateStakingContractEvent)
      ]),
      update_voter_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(UpdateVoterEvent)]),
      reset_lockup_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(ResetLockupEvent)]),
      add_stake_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(AddStakeEvent)]),
      request_commission_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(RequestCommissionEvent)]),
      unlock_stake_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(UnlockStakeEvent)]),
      switch_operator_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(SwitchOperatorEvent)]),
      add_distribution_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(AddDistributionEvent)]),
      distribute_events: Account.new_event_handle_(staker, $c, [new SimpleStructTag(DistributeEvent)])
    },
    new SimpleStructTag(Store)
  );
}

export function pending_distribution_counts_(staker: HexString, operator: HexString, $c: AptosDataCache): U64 {
  let staking_contracts;
  assert_staking_contract_exists_($.copy(staker), $.copy(operator), $c);
  staking_contracts = $c.borrow_global<Store>(new SimpleStructTag(Store), $.copy(staker)).staking_contracts;
  return Pool_u64.shareholders_count_(
    Simple_map.borrow_(staking_contracts, operator, $c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)])
      .distribution_pool,
    $c
  );
}

export function request_commission_(
  account: HexString,
  staker: HexString,
  operator: HexString,
  $c: AptosDataCache
): void {
  let temp$1, account_addr, staking_contract, store;
  account_addr = Signer.address_of_(account, $c);
  if ($.copy(account_addr).hex() === $.copy(staker).hex()) {
    temp$1 = true;
  } else {
    temp$1 = $.copy(account_addr).hex() === $.copy(operator).hex();
  }
  if (!temp$1) {
    throw $.abortCode(Error.unauthenticated_($.copy(ENOT_STAKER_OR_OPERATOR), $c));
  }
  assert_staking_contract_exists_($.copy(staker), $.copy(operator), $c);
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker));
  staking_contract = Simple_map.borrow_mut_(store.staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  if ($.copy(staking_contract.commission_percentage).eq(u64('0'))) {
    return;
  } else {
  }
  distribute_internal_($.copy(staker), $.copy(operator), staking_contract, store.distribute_events, $c);
  request_commission_internal_(
    $.copy(operator),
    staking_contract,
    store.add_distribution_events,
    store.request_commission_events,
    $c
  );
  return;
}

export function buildPayload_request_commission(
  staker: HexString,
  operator: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'request_commission',
    typeParamStrings,
    [staker, operator],
    isJSON
  );
}
export function request_commission_internal_(
  operator: HexString,
  staking_contract: StakingContract,
  add_distribution_events: Event.EventHandle,
  request_commission_events: Event.EventHandle,
  $c: AptosDataCache
): U64 {
  let accumulated_rewards, commission_amount, pool_address, total_active_stake;
  [total_active_stake, accumulated_rewards, commission_amount] = get_staking_contract_amounts_internal_(
    staking_contract,
    $c
  );
  staking_contract.principal = $.copy(total_active_stake).sub($.copy(commission_amount));
  if ($.copy(commission_amount).eq(u64('0'))) {
    return u64('0');
  } else {
  }
  add_distribution_(
    $.copy(operator),
    staking_contract,
    $.copy(operator),
    $.copy(commission_amount),
    add_distribution_events,
    $c
  );
  Stake.unlock_with_cap_($.copy(commission_amount), staking_contract.owner_cap, $c);
  pool_address = $.copy(staking_contract.pool_address);
  Event.emit_event_(
    request_commission_events,
    new RequestCommissionEvent(
      {
        operator: $.copy(operator),
        pool_address: $.copy(pool_address),
        accumulated_rewards: $.copy(accumulated_rewards),
        commission_amount: $.copy(commission_amount)
      },
      new SimpleStructTag(RequestCommissionEvent)
    ),
    $c,
    [new SimpleStructTag(RequestCommissionEvent)]
  );
  return $.copy(commission_amount);
}

export function reset_lockup_(staker: HexString, operator: HexString, $c: AptosDataCache): void {
  let pool_address, staker_address, staking_contract, store;
  staker_address = Signer.address_of_(staker, $c);
  assert_staking_contract_exists_($.copy(staker_address), $.copy(operator), $c);
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker_address));
  staking_contract = Simple_map.borrow_mut_(store.staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  pool_address = $.copy(staking_contract.pool_address);
  Stake.increase_lockup_with_cap_(staking_contract.owner_cap, $c);
  Event.emit_event_(
    store.reset_lockup_events,
    new ResetLockupEvent(
      { operator: $.copy(operator), pool_address: $.copy(pool_address) },
      new SimpleStructTag(ResetLockupEvent)
    ),
    $c,
    [new SimpleStructTag(ResetLockupEvent)]
  );
  return;
}

export function buildPayload_reset_lockup(
  operator: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(new HexString('0x1'), 'staking_contract', 'reset_lockup', typeParamStrings, [operator], isJSON);
}
export function stake_pool_address_(staker: HexString, operator: HexString, $c: AptosDataCache): HexString {
  let staking_contracts;
  assert_staking_contract_exists_($.copy(staker), $.copy(operator), $c);
  staking_contracts = $c.borrow_global<Store>(new SimpleStructTag(Store), $.copy(staker)).staking_contracts;
  return $.copy(
    Simple_map.borrow_(staking_contracts, operator, $c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)])
      .pool_address
  );
}

export function staking_contract_amounts_(staker: HexString, operator: HexString, $c: AptosDataCache): [U64, U64, U64] {
  let staking_contract, staking_contracts;
  assert_staking_contract_exists_($.copy(staker), $.copy(operator), $c);
  staking_contracts = $c.borrow_global<Store>(new SimpleStructTag(Store), $.copy(staker)).staking_contracts;
  staking_contract = Simple_map.borrow_(staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  return get_staking_contract_amounts_internal_(staking_contract, $c);
}

export function staking_contract_exists_(staker: HexString, operator: HexString, $c: AptosDataCache): boolean {
  let store;
  if (!$c.exists(new SimpleStructTag(Store), $.copy(staker))) {
    return false;
  } else {
  }
  store = $c.borrow_global<Store>(new SimpleStructTag(Store), $.copy(staker));
  return Simple_map.contains_key_(store.staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
}

export function switch_operator_(
  staker: HexString,
  old_operator: HexString,
  new_operator: HexString,
  new_commission_percentage: U64,
  $c: AptosDataCache
): void {
  let temp$1,
    temp$2,
    temp$3,
    temp$4,
    temp$5,
    temp$6,
    pool_address,
    staker_address,
    staking_contract,
    staking_contracts,
    store;
  staker_address = Signer.address_of_(staker, $c);
  assert_staking_contract_exists_($.copy(staker_address), $.copy(old_operator), $c);
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker_address));
  staking_contracts = store.staking_contracts;
  [temp$1, temp$2] = [staking_contracts, new_operator];
  if (!!Simple_map.contains_key_(temp$1, temp$2, $c, [AtomicTypeTag.Address, new SimpleStructTag(StakingContract)])) {
    throw $.abortCode(Error.invalid_state_($.copy(ECANT_MERGE_STAKING_CONTRACTS), $c));
  }
  [, staking_contract] = Simple_map.remove_(staking_contracts, old_operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  distribute_internal_($.copy(staker_address), $.copy(old_operator), staking_contract, store.distribute_events, $c);
  request_commission_internal_(
    $.copy(old_operator),
    staking_contract,
    store.add_distribution_events,
    store.request_commission_events,
    $c
  );
  Stake.set_operator_with_cap_(staking_contract.owner_cap, $.copy(new_operator), $c);
  staking_contract.commission_percentage = $.copy(new_commission_percentage);
  pool_address = $.copy(staking_contract.pool_address);
  Simple_map.add_(staking_contracts, $.copy(new_operator), staking_contract, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  temp$6 = store.switch_operator_events;
  temp$3 = $.copy(pool_address);
  temp$4 = $.copy(old_operator);
  temp$5 = $.copy(new_operator);
  Event.emit_event_(
    temp$6,
    new SwitchOperatorEvent(
      { old_operator: temp$4, new_operator: temp$5, pool_address: temp$3 },
      new SimpleStructTag(SwitchOperatorEvent)
    ),
    $c,
    [new SimpleStructTag(SwitchOperatorEvent)]
  );
  return;
}

export function buildPayload_switch_operator(
  old_operator: HexString,
  new_operator: HexString,
  new_commission_percentage: U64,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'switch_operator',
    typeParamStrings,
    [old_operator, new_operator, new_commission_percentage],
    isJSON
  );
}
export function switch_operator_with_same_commission_(
  staker: HexString,
  old_operator: HexString,
  new_operator: HexString,
  $c: AptosDataCache
): void {
  let commission_percentage, staker_address;
  staker_address = Signer.address_of_(staker, $c);
  assert_staking_contract_exists_($.copy(staker_address), $.copy(old_operator), $c);
  commission_percentage = commission_percentage_($.copy(staker_address), $.copy(old_operator), $c);
  switch_operator_(staker, $.copy(old_operator), $.copy(new_operator), $.copy(commission_percentage), $c);
  return;
}

export function buildPayload_switch_operator_with_same_commission(
  old_operator: HexString,
  new_operator: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'switch_operator_with_same_commission',
    typeParamStrings,
    [old_operator, new_operator],
    isJSON
  );
}
export function unlock_rewards_(staker: HexString, operator: HexString, $c: AptosDataCache): void {
  let accumulated_rewards, staker_address, staker_rewards, unpaid_commission;
  staker_address = Signer.address_of_(staker, $c);
  assert_staking_contract_exists_($.copy(staker_address), $.copy(operator), $c);
  [, accumulated_rewards, unpaid_commission] = staking_contract_amounts_($.copy(staker_address), $.copy(operator), $c);
  staker_rewards = $.copy(accumulated_rewards).sub($.copy(unpaid_commission));
  unlock_stake_(staker, $.copy(operator), $.copy(staker_rewards), $c);
  return;
}

export function buildPayload_unlock_rewards(
  operator: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'unlock_rewards',
    typeParamStrings,
    [operator],
    isJSON
  );
}
export function unlock_stake_(staker: HexString, operator: HexString, amount: U64, $c: AptosDataCache): void {
  let temp$1,
    temp$2,
    temp$3,
    temp$4,
    temp$5,
    active,
    commission_paid,
    pool_address,
    staker_address,
    staking_contract,
    store;
  if ($.copy(amount).eq(u64('0'))) {
    return;
  } else {
  }
  staker_address = Signer.address_of_(staker, $c);
  assert_staking_contract_exists_($.copy(staker_address), $.copy(operator), $c);
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker_address));
  staking_contract = Simple_map.borrow_mut_(store.staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  distribute_internal_($.copy(staker_address), $.copy(operator), staking_contract, store.distribute_events, $c);
  commission_paid = request_commission_internal_(
    $.copy(operator),
    staking_contract,
    store.add_distribution_events,
    store.request_commission_events,
    $c
  );
  [active, , ,] = Stake.get_stake_($.copy(staking_contract.pool_address), $c);
  if ($.copy(active).lt($.copy(amount))) {
    amount = $.copy(active);
  } else {
  }
  staking_contract.principal = $.copy(staking_contract.principal).sub($.copy(amount));
  add_distribution_(
    $.copy(operator),
    staking_contract,
    $.copy(staker_address),
    $.copy(amount),
    store.add_distribution_events,
    $c
  );
  Stake.unlock_with_cap_($.copy(amount), staking_contract.owner_cap, $c);
  pool_address = $.copy(staking_contract.pool_address);
  temp$5 = store.unlock_stake_events;
  temp$1 = $.copy(pool_address);
  temp$2 = $.copy(operator);
  temp$3 = $.copy(amount);
  temp$4 = $.copy(commission_paid);
  Event.emit_event_(
    temp$5,
    new UnlockStakeEvent(
      { operator: temp$2, pool_address: temp$1, amount: temp$3, commission_paid: temp$4 },
      new SimpleStructTag(UnlockStakeEvent)
    ),
    $c,
    [new SimpleStructTag(UnlockStakeEvent)]
  );
  return;
}

export function buildPayload_unlock_stake(
  operator: HexString,
  amount: U64,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'unlock_stake',
    typeParamStrings,
    [operator, amount],
    isJSON
  );
}
export function update_distribution_pool_(
  distribution_pool: Pool_u64.Pool,
  updated_total_coins: U64,
  operator: HexString,
  commission_percentage: U64,
  $c: AptosDataCache
): void {
  let temp$1,
    temp$10,
    temp$11,
    temp$2,
    temp$3,
    temp$4,
    temp$5,
    temp$6,
    temp$7,
    temp$8,
    temp$9,
    current_worth,
    i,
    len,
    previous_worth,
    shareholder,
    shareholders,
    shares,
    shares_to_transfer,
    unpaid_commission;
  if (Pool_u64.total_coins_(distribution_pool, $c).eq($.copy(updated_total_coins))) {
    return;
  } else {
  }
  temp$1 = Pool_u64.shareholders_(distribution_pool, $c);
  shareholders = temp$1;
  len = Vector.length_(shareholders, $c, [AtomicTypeTag.Address]);
  i = u64('0');
  while ($.copy(i).lt($.copy(len))) {
    {
      shareholder = $.copy(Vector.borrow_(shareholders, $.copy(i), $c, [AtomicTypeTag.Address]));
      if ($.copy(shareholder).hex() !== $.copy(operator).hex()) {
        [temp$2, temp$3] = [distribution_pool, $.copy(shareholder)];
        shares = Pool_u64.shares_(temp$2, temp$3, $c);
        [temp$4, temp$5] = [distribution_pool, $.copy(shareholder)];
        previous_worth = Pool_u64.balance_(temp$4, temp$5, $c);
        [temp$6, temp$7, temp$8] = [distribution_pool, $.copy(shares), $.copy(updated_total_coins)];
        current_worth = Pool_u64.shares_to_amount_with_total_coins_(temp$6, temp$7, temp$8, $c);
        unpaid_commission = $.copy(current_worth)
          .sub($.copy(previous_worth))
          .mul($.copy(commission_percentage))
          .div(u64('100'));
        [temp$9, temp$10, temp$11] = [distribution_pool, $.copy(unpaid_commission), $.copy(updated_total_coins)];
        shares_to_transfer = Pool_u64.amount_to_shares_with_total_coins_(temp$9, temp$10, temp$11, $c);
        Pool_u64.transfer_shares_(
          distribution_pool,
          $.copy(shareholder),
          $.copy(operator),
          $.copy(shares_to_transfer),
          $c
        );
      } else {
      }
      i = $.copy(i).add(u64('1'));
    }
  }
  Pool_u64.update_total_coins_(distribution_pool, $.copy(updated_total_coins), $c);
  return;
}

export function update_voter_(staker: HexString, operator: HexString, new_voter: HexString, $c: AptosDataCache): void {
  let old_voter, pool_address, staker_address, staking_contract, store;
  staker_address = Signer.address_of_(staker, $c);
  assert_staking_contract_exists_($.copy(staker_address), $.copy(operator), $c);
  store = $c.borrow_global_mut<Store>(new SimpleStructTag(Store), $.copy(staker_address));
  staking_contract = Simple_map.borrow_mut_(store.staking_contracts, operator, $c, [
    AtomicTypeTag.Address,
    new SimpleStructTag(StakingContract)
  ]);
  pool_address = $.copy(staking_contract.pool_address);
  old_voter = Stake.get_delegated_voter_($.copy(pool_address), $c);
  Stake.set_delegated_voter_with_cap_(staking_contract.owner_cap, $.copy(new_voter), $c);
  Event.emit_event_(
    store.update_voter_events,
    new UpdateVoterEvent(
      {
        operator: $.copy(operator),
        pool_address: $.copy(pool_address),
        old_voter: $.copy(old_voter),
        new_voter: $.copy(new_voter)
      },
      new SimpleStructTag(UpdateVoterEvent)
    ),
    $c,
    [new SimpleStructTag(UpdateVoterEvent)]
  );
  return;
}

export function buildPayload_update_voter(
  operator: HexString,
  new_voter: HexString,
  isJSON = false
): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString('0x1'),
    'staking_contract',
    'update_voter',
    typeParamStrings,
    [operator, new_voter],
    isJSON
  );
}
export function loadParsers(repo: AptosParserRepo) {
  repo.addParser('0x1::staking_contract::AddDistributionEvent', AddDistributionEvent.AddDistributionEventParser);
  repo.addParser('0x1::staking_contract::AddStakeEvent', AddStakeEvent.AddStakeEventParser);
  repo.addParser(
    '0x1::staking_contract::CreateStakingContractEvent',
    CreateStakingContractEvent.CreateStakingContractEventParser
  );
  repo.addParser('0x1::staking_contract::DistributeEvent', DistributeEvent.DistributeEventParser);
  repo.addParser('0x1::staking_contract::RequestCommissionEvent', RequestCommissionEvent.RequestCommissionEventParser);
  repo.addParser('0x1::staking_contract::ResetLockupEvent', ResetLockupEvent.ResetLockupEventParser);
  repo.addParser('0x1::staking_contract::StakingContract', StakingContract.StakingContractParser);
  repo.addParser('0x1::staking_contract::Store', Store.StoreParser);
  repo.addParser('0x1::staking_contract::SwitchOperatorEvent', SwitchOperatorEvent.SwitchOperatorEventParser);
  repo.addParser('0x1::staking_contract::UnlockStakeEvent', UnlockStakeEvent.UnlockStakeEventParser);
  repo.addParser('0x1::staking_contract::UpdateVoterEvent', UpdateVoterEvent.UpdateVoterEventParser);
}
export class App {
  constructor(public client: AptosClient, public repo: AptosParserRepo, public cache: AptosLocalCache) {}
  get moduleAddress() {
    {
      return moduleAddress;
    }
  }
  get moduleName() {
    {
      return moduleName;
    }
  }
  get AddDistributionEvent() {
    return AddDistributionEvent;
  }
  get AddStakeEvent() {
    return AddStakeEvent;
  }
  get CreateStakingContractEvent() {
    return CreateStakingContractEvent;
  }
  get DistributeEvent() {
    return DistributeEvent;
  }
  get RequestCommissionEvent() {
    return RequestCommissionEvent;
  }
  get ResetLockupEvent() {
    return ResetLockupEvent;
  }
  get StakingContract() {
    return StakingContract;
  }
  get Store() {
    return Store;
  }
  async loadStore(owner: HexString, loadFull = true, fillCache = true) {
    const val = await Store.load(this.repo, this.client, owner, [] as TypeTag[]);
    if (loadFull) {
      await val.loadFullState(this);
    }
    if (fillCache) {
      this.cache.set(val.typeTag, owner, val);
    }
    return val;
  }
  get SwitchOperatorEvent() {
    return SwitchOperatorEvent;
  }
  get UnlockStakeEvent() {
    return UnlockStakeEvent;
  }
  get UpdateVoterEvent() {
    return UpdateVoterEvent;
  }
  payload_add_stake(
    operator: HexString,
    amount: U64,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_add_stake(operator, amount, isJSON);
  }
  async add_stake(
    _account: AptosAccount,
    operator: HexString,
    amount: U64,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_add_stake(operator, amount, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_create_staking_contract(
    operator: HexString,
    voter: HexString,
    amount: U64,
    commission_percentage: U64,
    contract_creation_seed: U8[],
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_create_staking_contract(
      operator,
      voter,
      amount,
      commission_percentage,
      contract_creation_seed,
      isJSON
    );
  }
  async create_staking_contract(
    _account: AptosAccount,
    operator: HexString,
    voter: HexString,
    amount: U64,
    commission_percentage: U64,
    contract_creation_seed: U8[],
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_create_staking_contract(
      operator,
      voter,
      amount,
      commission_percentage,
      contract_creation_seed,
      _isJSON
    );
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_distribute(
    staker: HexString,
    operator: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_distribute(staker, operator, isJSON);
  }
  async distribute(
    _account: AptosAccount,
    staker: HexString,
    operator: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_distribute(staker, operator, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_request_commission(
    staker: HexString,
    operator: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_request_commission(staker, operator, isJSON);
  }
  async request_commission(
    _account: AptosAccount,
    staker: HexString,
    operator: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_request_commission(staker, operator, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_reset_lockup(
    operator: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_reset_lockup(operator, isJSON);
  }
  async reset_lockup(_account: AptosAccount, operator: HexString, option?: OptionTransaction, _isJSON = false) {
    const payload__ = buildPayload_reset_lockup(operator, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_switch_operator(
    old_operator: HexString,
    new_operator: HexString,
    new_commission_percentage: U64,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_switch_operator(old_operator, new_operator, new_commission_percentage, isJSON);
  }
  async switch_operator(
    _account: AptosAccount,
    old_operator: HexString,
    new_operator: HexString,
    new_commission_percentage: U64,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_switch_operator(old_operator, new_operator, new_commission_percentage, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_switch_operator_with_same_commission(
    old_operator: HexString,
    new_operator: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_switch_operator_with_same_commission(old_operator, new_operator, isJSON);
  }
  async switch_operator_with_same_commission(
    _account: AptosAccount,
    old_operator: HexString,
    new_operator: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_switch_operator_with_same_commission(old_operator, new_operator, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_unlock_rewards(
    operator: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_unlock_rewards(operator, isJSON);
  }
  async unlock_rewards(_account: AptosAccount, operator: HexString, option?: OptionTransaction, _isJSON = false) {
    const payload__ = buildPayload_unlock_rewards(operator, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_unlock_stake(
    operator: HexString,
    amount: U64,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_unlock_stake(operator, amount, isJSON);
  }
  async unlock_stake(
    _account: AptosAccount,
    operator: HexString,
    amount: U64,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_unlock_stake(operator, amount, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_update_voter(
    operator: HexString,
    new_voter: HexString,
    isJSON = false
  ): TxnBuilderTypes.TransactionPayloadEntryFunction | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_update_voter(operator, new_voter, isJSON);
  }
  async update_voter(
    _account: AptosAccount,
    operator: HexString,
    new_voter: HexString,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_update_voter(operator, new_voter, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
}