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 Aggregator_factory from "./aggregator_factory";
import * as Aptos_coin from "./aptos_coin";
import * as Aptos_governance from "./aptos_governance";
import * as Block from "./block";
import * as Chain_id from "./chain_id";
import * as Chain_status from "./chain_status";
import * as Coin from "./coin";
import * as Consensus_config from "./consensus_config";
import * as Error from "./error";
import * as Fixed_point32 from "./fixed_point32";
import * as Gas_schedule from "./gas_schedule";
import * as Reconfiguration from "./reconfiguration";
import * as Simple_map from "./simple_map";
import * as Stake from "./stake";
import * as Staking_config from "./staking_config";
import * as Staking_contract from "./staking_contract";
import * as State_storage from "./state_storage";
import * as Storage_gas from "./storage_gas";
import * as Timestamp from "./timestamp";
import * as Transaction_fee from "./transaction_fee";
import * as Transaction_validation from "./transaction_validation";
import * as Vector from "./vector";
import * as Version from "./version";
import * as Vesting from "./vesting";
export const packageName = "AptosFramework";
export const moduleAddress = new HexString("0x1");
export const moduleName = "genesis";

export const EACCOUNT_DOES_NOT_EXIST : U64 = u64("2");
export const EDUPLICATE_ACCOUNT : U64 = u64("1");


export class AccountMap 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "AccountMap";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "account_address", typeTag: AtomicTypeTag.Address },
  { name: "balance", typeTag: AtomicTypeTag.U64 }];

  account_address: HexString;
  balance: U64;

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

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

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

}

export class EmployeeAccountMap 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "EmployeeAccountMap";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "accounts", typeTag: new VectorTag(AtomicTypeTag.Address) },
  { name: "validator", typeTag: new StructTag(new HexString("0x1"), "genesis", "ValidatorConfigurationWithCommission", []) },
  { name: "vesting_schedule_numerator", typeTag: new VectorTag(AtomicTypeTag.U64) },
  { name: "vesting_schedule_denominator", typeTag: AtomicTypeTag.U64 },
  { name: "beneficiary_resetter", typeTag: AtomicTypeTag.Address }];

  accounts: HexString[];
  validator: ValidatorConfigurationWithCommission;
  vesting_schedule_numerator: U64[];
  vesting_schedule_denominator: U64;
  beneficiary_resetter: HexString;

  constructor(proto: any, public typeTag: TypeTag) {
    this.accounts = proto['accounts'] as HexString[];
    this.validator = proto['validator'] as ValidatorConfigurationWithCommission;
    this.vesting_schedule_numerator = proto['vesting_schedule_numerator'] as U64[];
    this.vesting_schedule_denominator = proto['vesting_schedule_denominator'] as U64;
    this.beneficiary_resetter = proto['beneficiary_resetter'] as HexString;
  }

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

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

}

export class ValidatorConfiguration 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "ValidatorConfiguration";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "owner_address", typeTag: AtomicTypeTag.Address },
  { name: "operator_address", typeTag: AtomicTypeTag.Address },
  { name: "voter_address", typeTag: AtomicTypeTag.Address },
  { name: "stake_amount", typeTag: AtomicTypeTag.U64 },
  { name: "consensus_pubkey", typeTag: new VectorTag(AtomicTypeTag.U8) },
  { name: "proof_of_possession", typeTag: new VectorTag(AtomicTypeTag.U8) },
  { name: "network_addresses", typeTag: new VectorTag(AtomicTypeTag.U8) },
  { name: "full_node_network_addresses", typeTag: new VectorTag(AtomicTypeTag.U8) }];

  owner_address: HexString;
  operator_address: HexString;
  voter_address: HexString;
  stake_amount: U64;
  consensus_pubkey: U8[];
  proof_of_possession: U8[];
  network_addresses: U8[];
  full_node_network_addresses: U8[];

  constructor(proto: any, public typeTag: TypeTag) {
    this.owner_address = proto['owner_address'] as HexString;
    this.operator_address = proto['operator_address'] as HexString;
    this.voter_address = proto['voter_address'] as HexString;
    this.stake_amount = proto['stake_amount'] as U64;
    this.consensus_pubkey = proto['consensus_pubkey'] as U8[];
    this.proof_of_possession = proto['proof_of_possession'] as U8[];
    this.network_addresses = proto['network_addresses'] as U8[];
    this.full_node_network_addresses = proto['full_node_network_addresses'] as U8[];
  }

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

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

}

export class ValidatorConfigurationWithCommission 
{
  static moduleAddress = moduleAddress;
  static moduleName = moduleName;
  __app: $.AppType | null = null;
  static structName: string = "ValidatorConfigurationWithCommission";
  static typeParameters: TypeParamDeclType[] = [

  ];
  static fields: FieldDeclType[] = [
  { name: "validator_config", typeTag: new StructTag(new HexString("0x1"), "genesis", "ValidatorConfiguration", []) },
  { name: "commission_percentage", typeTag: AtomicTypeTag.U64 },
  { name: "join_during_genesis", typeTag: AtomicTypeTag.Bool }];

  validator_config: ValidatorConfiguration;
  commission_percentage: U64;
  join_during_genesis: boolean;

  constructor(proto: any, public typeTag: TypeTag) {
    this.validator_config = proto['validator_config'] as ValidatorConfiguration;
    this.commission_percentage = proto['commission_percentage'] as U64;
    this.join_during_genesis = proto['join_during_genesis'] as boolean;
  }

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

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

}
export function create_account_ (
  aptos_framework: HexString,
  account_address: HexString,
  balance: U64,
  $c: AptosDataCache,
): HexString {
  let temp$1, account;
  if (Account.exists_at_($.copy(account_address), $c)) {
    temp$1 = create_signer_($.copy(account_address), $c);
  }
  else{
    account = Account.create_account_($.copy(account_address), $c);
    Coin.register_(account, $c, [new StructTag(new HexString("0x1"), "aptos_coin", "AptosCoin", [])]);
    Aptos_coin.mint_(aptos_framework, $.copy(account_address), $.copy(balance), $c);
    temp$1 = account;
  }
  return temp$1;
}

export function create_accounts_ (
  aptos_framework: HexString,
  accounts: AccountMap[],
  $c: AptosDataCache,
): void {
  let account_map, i, num_accounts, unique_accounts;
  i = u64("0");
  num_accounts = Vector.length_(accounts, $c, [new SimpleStructTag(AccountMap)]);
  unique_accounts = Vector.empty_($c, [AtomicTypeTag.Address]);
  while (($.copy(i)).lt($.copy(num_accounts))) {
    {
      account_map = Vector.borrow_(accounts, $.copy(i), $c, [new SimpleStructTag(AccountMap)]);
      if (!!Vector.contains_(unique_accounts, account_map.account_address, $c, [AtomicTypeTag.Address])) {
        throw $.abortCode(Error.already_exists_($.copy(EDUPLICATE_ACCOUNT), $c));
      }
      Vector.push_back_(unique_accounts, $.copy(account_map.account_address), $c, [AtomicTypeTag.Address]);
      create_account_(aptos_framework, $.copy(account_map.account_address), $.copy(account_map.balance), $c);
      i = ($.copy(i)).add(u64("1"));
    }

  }return;
}

export function create_employee_validators_ (
  employee_vesting_start: U64,
  employee_vesting_period_duration: U64,
  employees: EmployeeAccountMap[],
  $c: AptosDataCache,
): void {
  let temp$2, account, admin, admin_signer, buy_ins, coins, contract_address, employee, employee_group, event, i, j, j__1, num_employee_groups, num_employees_in_group, num_vesting_events, numerator, pool_address, schedule, total, unique_accounts, validator, vesting_schedule;
  i = u64("0");
  num_employee_groups = Vector.length_(employees, $c, [new SimpleStructTag(EmployeeAccountMap)]);
  unique_accounts = Vector.empty_($c, [AtomicTypeTag.Address]);
  while (($.copy(i)).lt($.copy(num_employee_groups))) {
    {
      j = u64("0");
      employee_group = Vector.borrow_(employees, $.copy(i), $c, [new SimpleStructTag(EmployeeAccountMap)]);
      num_employees_in_group = Vector.length_(employee_group.accounts, $c, [AtomicTypeTag.Address]);
      buy_ins = Simple_map.create_($c, [AtomicTypeTag.Address, new StructTag(new HexString("0x1"), "coin", "Coin", [new StructTag(new HexString("0x1"), "aptos_coin", "AptosCoin", [])])]);
      while (($.copy(j)).lt($.copy(num_employees_in_group))) {
        {
          account = Vector.borrow_(employee_group.accounts, $.copy(j), $c, [AtomicTypeTag.Address]);
          if (!!Vector.contains_(unique_accounts, account, $c, [AtomicTypeTag.Address])) {
            throw $.abortCode(Error.already_exists_($.copy(EDUPLICATE_ACCOUNT), $c));
          }
          Vector.push_back_(unique_accounts, $.copy(account), $c, [AtomicTypeTag.Address]);
          employee = create_signer_($.copy(account), $c);
          total = Coin.balance_($.copy(account), $c, [new StructTag(new HexString("0x1"), "aptos_coin", "AptosCoin", [])]);
          coins = Coin.withdraw_(employee, $.copy(total), $c, [new StructTag(new HexString("0x1"), "aptos_coin", "AptosCoin", [])]);
          Simple_map.add_(buy_ins, $.copy(account), coins, $c, [AtomicTypeTag.Address, new StructTag(new HexString("0x1"), "coin", "Coin", [new StructTag(new HexString("0x1"), "aptos_coin", "AptosCoin", [])])]);
          j = ($.copy(j)).add(u64("1"));
        }

      }j__1 = u64("0");
      num_vesting_events = Vector.length_(employee_group.vesting_schedule_numerator, $c, [AtomicTypeTag.U64]);
      schedule = Vector.empty_($c, [new StructTag(new HexString("0x1"), "fixed_point32", "FixedPoint32", [])]);
      while (($.copy(j__1)).lt($.copy(num_vesting_events))) {
        {
          numerator = Vector.borrow_(employee_group.vesting_schedule_numerator, $.copy(j__1), $c, [AtomicTypeTag.U64]);
          event = Fixed_point32.create_from_rational_($.copy(numerator), $.copy(employee_group.vesting_schedule_denominator), $c);
          Vector.push_back_(schedule, $.copy(event), $c, [new StructTag(new HexString("0x1"), "fixed_point32", "FixedPoint32", [])]);
          j__1 = ($.copy(j__1)).add(u64("1"));
        }

      }vesting_schedule = Vesting.create_vesting_schedule_($.copy(schedule), $.copy(employee_vesting_start), $.copy(employee_vesting_period_duration), $c);
      admin = $.copy(employee_group.validator.validator_config.owner_address);
      temp$2 = create_signer_($.copy(admin), $c);
      admin_signer = temp$2;
      contract_address = Vesting.create_vesting_contract_(admin_signer, employee_group.accounts, buy_ins, $.copy(vesting_schedule), $.copy(admin), $.copy(employee_group.validator.validator_config.operator_address), $.copy(employee_group.validator.validator_config.voter_address), $.copy(employee_group.validator.commission_percentage), [], $c);
      pool_address = Vesting.stake_pool_address_($.copy(contract_address), $c);
      if ((($.copy(employee_group.beneficiary_resetter)).hex() !== (new HexString("0x0")).hex())) {
        Vesting.set_beneficiary_resetter_(admin_signer, $.copy(contract_address), $.copy(employee_group.beneficiary_resetter), $c);
      }
      else{
      }
      validator = employee_group.validator.validator_config;
      if (!Account.exists_at_($.copy(validator.owner_address), $c)) {
        throw $.abortCode(Error.not_found_($.copy(EACCOUNT_DOES_NOT_EXIST), $c));
      }
      if (!Account.exists_at_($.copy(validator.operator_address), $c)) {
        throw $.abortCode(Error.not_found_($.copy(EACCOUNT_DOES_NOT_EXIST), $c));
      }
      if (!Account.exists_at_($.copy(validator.voter_address), $c)) {
        throw $.abortCode(Error.not_found_($.copy(EACCOUNT_DOES_NOT_EXIST), $c));
      }
      if ($.copy(employee_group.validator.join_during_genesis)) {
        initialize_validator_($.copy(pool_address), validator, $c);
      }
      else{
      }
      i = ($.copy(i)).add(u64("1"));
    }

  }return;
}

export function create_initialize_validator_ (
  aptos_framework: HexString,
  commission_config: ValidatorConfigurationWithCommission,
  use_staking_contract: boolean,
  $c: AptosDataCache,
): void {
  let temp$1, temp$2, owner, pool_address, validator;
  validator = commission_config.validator_config;
  temp$1 = create_account_(aptos_framework, $.copy(validator.owner_address), $.copy(validator.stake_amount), $c);
  owner = temp$1;
  create_account_(aptos_framework, $.copy(validator.operator_address), u64("0"), $c);
  create_account_(aptos_framework, $.copy(validator.voter_address), u64("0"), $c);
  if (use_staking_contract) {
    Staking_contract.create_staking_contract_(owner, $.copy(validator.operator_address), $.copy(validator.voter_address), $.copy(validator.stake_amount), $.copy(commission_config.commission_percentage), [], $c);
    temp$2 = Staking_contract.stake_pool_address_($.copy(validator.owner_address), $.copy(validator.operator_address), $c);
  }
  else{
    Stake.initialize_stake_owner_(owner, $.copy(validator.stake_amount), $.copy(validator.operator_address), $.copy(validator.voter_address), $c);
    temp$2 = $.copy(validator.owner_address);
  }
  pool_address = temp$2;
  if ($.copy(commission_config.join_during_genesis)) {
    initialize_validator_($.copy(pool_address), validator, $c);
  }
  else{
  }
  return;
}

export function create_initialize_validators_ (
  aptos_framework: HexString,
  validators: ValidatorConfiguration[],
  $c: AptosDataCache,
): void {
  let i, num_validators, validator_with_commission, validators_with_commission;
  i = u64("0");
  num_validators = Vector.length_(validators, $c, [new SimpleStructTag(ValidatorConfiguration)]);
  validators_with_commission = Vector.empty_($c, [new SimpleStructTag(ValidatorConfigurationWithCommission)]);
  while (($.copy(i)).lt($.copy(num_validators))) {
    {
      validator_with_commission = new ValidatorConfigurationWithCommission({ validator_config: Vector.pop_back_(validators, $c, [new SimpleStructTag(ValidatorConfiguration)]), commission_percentage: u64("0"), join_during_genesis: true }, new SimpleStructTag(ValidatorConfigurationWithCommission));
      Vector.push_back_(validators_with_commission, $.copy(validator_with_commission), $c, [new SimpleStructTag(ValidatorConfigurationWithCommission)]);
      i = ($.copy(i)).add(u64("1"));
    }

  }create_initialize_validators_with_commission_(aptos_framework, false, $.copy(validators_with_commission), $c);
  return;
}

export function create_initialize_validators_with_commission_ (
  aptos_framework: HexString,
  use_staking_contract: boolean,
  validators: ValidatorConfigurationWithCommission[],
  $c: AptosDataCache,
): void {
  let i, num_validators, validator;
  i = u64("0");
  num_validators = Vector.length_(validators, $c, [new SimpleStructTag(ValidatorConfigurationWithCommission)]);
  while (($.copy(i)).lt($.copy(num_validators))) {
    {
      validator = Vector.borrow_(validators, $.copy(i), $c, [new SimpleStructTag(ValidatorConfigurationWithCommission)]);
      create_initialize_validator_(aptos_framework, validator, use_staking_contract, $c);
      i = ($.copy(i)).add(u64("1"));
    }

  }Aptos_coin.destroy_mint_cap_(aptos_framework, $c);
  Stake.on_new_epoch_($c);
  return;
}

export function create_signer_ (
  addr: HexString,
  $c: AptosDataCache,
): HexString {
  return $.aptos_framework_genesis_create_signer(addr, $c);

}
export function initialize_ (
  gas_schedule: U8[],
  chain_id: U8,
  initial_version: U64,
  consensus_config: U8[],
  epoch_interval_microsecs: U64,
  minimum_stake: U64,
  maximum_stake: U64,
  recurring_lockup_duration_secs: U64,
  allow_validator_set_change: boolean,
  rewards_rate: U64,
  rewards_rate_denominator: U64,
  voting_power_increase_limit: U64,
  $c: AptosDataCache,
): void {
  let address, aptos_account, aptos_framework_account, aptos_framework_signer_cap, framework_reserved_addresses, framework_signer_cap;
  [aptos_framework_account, aptos_framework_signer_cap] = Account.create_framework_reserved_account_(new HexString("0x1"), $c);
  Account.initialize_(aptos_framework_account, $c);
  Transaction_validation.initialize_(aptos_framework_account, [u8("115"), u8("99"), u8("114"), u8("105"), u8("112"), u8("116"), u8("95"), u8("112"), u8("114"), u8("111"), u8("108"), u8("111"), u8("103"), u8("117"), u8("101")], [u8("109"), u8("111"), u8("100"), u8("117"), u8("108"), u8("101"), u8("95"), u8("112"), u8("114"), u8("111"), u8("108"), u8("111"), u8("103"), u8("117"), u8("101")], [u8("109"), u8("117"), u8("108"), u8("116"), u8("105"), u8("95"), u8("97"), u8("103"), u8("101"), u8("110"), u8("116"), u8("95"), u8("115"), u8("99"), u8("114"), u8("105"), u8("112"), u8("116"), u8("95"), u8("112"), u8("114"), u8("111"), u8("108"), u8("111"), u8("103"), u8("117"), u8("101")], [u8("101"), u8("112"), u8("105"), u8("108"), u8("111"), u8("103"), u8("117"), u8("101")], $c);
  Aptos_governance.store_signer_cap_(aptos_framework_account, new HexString("0x1"), aptos_framework_signer_cap, $c);
  framework_reserved_addresses = [new HexString("0x2"), new HexString("0x3"), new HexString("0x4"), new HexString("0x5"), new HexString("0x6"), new HexString("0x7"), new HexString("0x8"), new HexString("0x9"), new HexString("0xa")];
  while (!Vector.is_empty_(framework_reserved_addresses, $c, [AtomicTypeTag.Address])) {
    {
      address = Vector.pop_back_(framework_reserved_addresses, $c, [AtomicTypeTag.Address]);
      [aptos_account, framework_signer_cap] = Account.create_framework_reserved_account_($.copy(address), $c);
      Aptos_governance.store_signer_cap_(aptos_account, $.copy(address), framework_signer_cap, $c);
    }

  }Consensus_config.initialize_(aptos_framework_account, $.copy(consensus_config), $c);
  Version.initialize_(aptos_framework_account, $.copy(initial_version), $c);
  Stake.initialize_(aptos_framework_account, $c);
  Staking_config.initialize_(aptos_framework_account, $.copy(minimum_stake), $.copy(maximum_stake), $.copy(recurring_lockup_duration_secs), allow_validator_set_change, $.copy(rewards_rate), $.copy(rewards_rate_denominator), $.copy(voting_power_increase_limit), $c);
  Storage_gas.initialize_(aptos_framework_account, $c);
  Gas_schedule.initialize_(aptos_framework_account, $.copy(gas_schedule), $c);
  Aggregator_factory.initialize_aggregator_factory_(aptos_framework_account, $c);
  Coin.initialize_supply_config_(aptos_framework_account, $c);
  Chain_id.initialize_(aptos_framework_account, $.copy(chain_id), $c);
  Reconfiguration.initialize_(aptos_framework_account, $c);
  Block.initialize_(aptos_framework_account, $.copy(epoch_interval_microsecs), $c);
  State_storage.initialize_(aptos_framework_account, $c);
  Timestamp.set_time_has_started_(aptos_framework_account, $c);
  return;
}

export function initialize_aptos_coin_ (
  aptos_framework: HexString,
  $c: AptosDataCache,
): void {
  let burn_cap, mint_cap;
  [burn_cap, mint_cap] = Aptos_coin.initialize_(aptos_framework, $c);
  Stake.store_aptos_coin_mint_cap_(aptos_framework, $.copy(mint_cap), $c);
  Transaction_fee.store_aptos_coin_burn_cap_(aptos_framework, $.copy(burn_cap), $c);
  return;
}

export function initialize_core_resources_and_aptos_coin_ (
  aptos_framework: HexString,
  core_resources_auth_key: U8[],
  $c: AptosDataCache,
): void {
  let burn_cap, core_resources, mint_cap;
  [burn_cap, mint_cap] = Aptos_coin.initialize_(aptos_framework, $c);
  Stake.store_aptos_coin_mint_cap_(aptos_framework, $.copy(mint_cap), $c);
  Transaction_fee.store_aptos_coin_burn_cap_(aptos_framework, $.copy(burn_cap), $c);
  core_resources = Account.create_account_(new HexString("0xa550c18"), $c);
  Account.rotate_authentication_key_internal_(core_resources, $.copy(core_resources_auth_key), $c);
  Aptos_coin.configure_accounts_for_test_(aptos_framework, core_resources, $.copy(mint_cap), $c);
  return;
}

export function initialize_for_verification_ (
  gas_schedule: U8[],
  chain_id: U8,
  initial_version: U64,
  consensus_config: U8[],
  epoch_interval_microsecs: U64,
  minimum_stake: U64,
  maximum_stake: U64,
  recurring_lockup_duration_secs: U64,
  allow_validator_set_change: boolean,
  rewards_rate: U64,
  rewards_rate_denominator: U64,
  voting_power_increase_limit: U64,
  aptos_framework: HexString,
  validators: ValidatorConfiguration[],
  min_voting_threshold: U128,
  required_proposer_stake: U64,
  voting_duration_secs: U64,
  $c: AptosDataCache,
): void {
  initialize_($.copy(gas_schedule), $.copy(chain_id), $.copy(initial_version), $.copy(consensus_config), $.copy(epoch_interval_microsecs), $.copy(minimum_stake), $.copy(maximum_stake), $.copy(recurring_lockup_duration_secs), allow_validator_set_change, $.copy(rewards_rate), $.copy(rewards_rate_denominator), $.copy(voting_power_increase_limit), $c);
  initialize_aptos_coin_(aptos_framework, $c);
  Aptos_governance.initialize_for_verification_(aptos_framework, $.copy(min_voting_threshold), $.copy(required_proposer_stake), $.copy(voting_duration_secs), $c);
  create_initialize_validators_(aptos_framework, $.copy(validators), $c);
  set_genesis_end_(aptos_framework, $c);
  return;
}

export function initialize_validator_ (
  pool_address: HexString,
  validator: ValidatorConfiguration,
  $c: AptosDataCache,
): void {
  let temp$1, operator;
  temp$1 = create_signer_($.copy(validator.operator_address), $c);
  operator = temp$1;
  Stake.rotate_consensus_key_(operator, $.copy(pool_address), $.copy(validator.consensus_pubkey), $.copy(validator.proof_of_possession), $c);
  Stake.update_network_and_fullnode_addresses_(operator, $.copy(pool_address), $.copy(validator.network_addresses), $.copy(validator.full_node_network_addresses), $c);
  Stake.join_validator_set_internal_(operator, $.copy(pool_address), $c);
  return;
}

export function set_genesis_end_ (
  aptos_framework: HexString,
  $c: AptosDataCache,
): void {
  Chain_status.set_genesis_end_(aptos_framework, $c);
  return;
}

export function loadParsers(repo: AptosParserRepo) {
  repo.addParser("0x1::genesis::AccountMap", AccountMap.AccountMapParser);
  repo.addParser("0x1::genesis::EmployeeAccountMap", EmployeeAccountMap.EmployeeAccountMapParser);
  repo.addParser("0x1::genesis::ValidatorConfiguration", ValidatorConfiguration.ValidatorConfigurationParser);
  repo.addParser("0x1::genesis::ValidatorConfigurationWithCommission", ValidatorConfigurationWithCommission.ValidatorConfigurationWithCommissionParser);
}
export class App {
  constructor(
    public client: AptosClient,
    public repo: AptosParserRepo,
    public cache: AptosLocalCache,
  ) {
  }
  get moduleAddress() {{ return moduleAddress; }}
  get moduleName() {{ return moduleName; }}
  get AccountMap() { return AccountMap; }
  get EmployeeAccountMap() { return EmployeeAccountMap; }
  get ValidatorConfiguration() { return ValidatorConfiguration; }
  get ValidatorConfigurationWithCommission() { return ValidatorConfigurationWithCommission; }
}