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 Aptos_coin from "./aptos_coin";
import * as Coin from "./coin";
import * as Error from "./error";
import * as Event from "./event";
import * as Governance_proposal from "./governance_proposal";
import * as Option from "./option";
import * as Reconfiguration from "./reconfiguration";
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 String from "./string";
import * as System_addresses from "./system_addresses";
import * as Table from "./table";
import * as Timestamp from "./timestamp";
import * as Voting from "./voting";
export const packageName = "AptosFramework";
export const moduleAddress = new HexString("0x1");
export const moduleName = "aptos_governance";

export const EALREADY_VOTED : U64 = u64("4");
export const EINSUFFICIENT_PROPOSER_STAKE : U64 = u64("1");
export const EINSUFFICIENT_STAKE_LOCKUP : U64 = u64("3");
export const EMETADATA_HASH_TOO_LONG : U64 = u64("10");
export const EMETADATA_LOCATION_TOO_LONG : U64 = u64("9");
export const ENOT_DELEGATED_VOTER : U64 = u64("2");
export const ENO_VOTING_POWER : U64 = u64("5");
export const EPROPOSAL_NOT_RESOLVABLE_YET : U64 = u64("6");
export const EPROPOSAL_NOT_RESOLVED_YET : U64 = u64("8");
export const EUNAUTHORIZED : U64 = u64("11");
export const METADATA_HASH_KEY : U8[] = [u8("109"), u8("101"), u8("116"), u8("97"), u8("100"), u8("97"), u8("116"), u8("97"), u8("95"), u8("104"), u8("97"), u8("115"), u8("104")];
export const METADATA_LOCATION_KEY : U8[] = [u8("109"), u8("101"), u8("116"), u8("97"), u8("100"), u8("97"), u8("116"), u8("97"), u8("95"), u8("108"), u8("111"), u8("99"), u8("97"), u8("116"), u8("105"), u8("111"), u8("110")];
export const PROPOSAL_STATE_SUCCEEDED : U64 = u64("1");


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

  ];
  static fields: FieldDeclType[] = [
  { name: "hashes", typeTag: new StructTag(new HexString("0x1"), "simple_map", "SimpleMap", [AtomicTypeTag.U64, new VectorTag(AtomicTypeTag.U8)]) }];

  hashes: Simple_map.SimpleMap;

  constructor(proto: any, public typeTag: TypeTag) {
    this.hashes = proto['hashes'] as Simple_map.SimpleMap;
  }

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, ApprovedExecutionHashes, typeParams);
    return result as unknown as ApprovedExecutionHashes;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, ApprovedExecutionHashes, typeParams);
    await result.loadFullState(app)
    return result as unknown as ApprovedExecutionHashes;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "ApprovedExecutionHashes", []);
  }
  async loadFullState(app: $.AppType) {
    await this.hashes.loadFullState(app);
    this.__app = app;
  }

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "proposer", typeTag: AtomicTypeTag.Address },
  { name: "stake_pool", typeTag: AtomicTypeTag.Address },
  { name: "proposal_id", typeTag: AtomicTypeTag.U64 },
  { name: "execution_hash", typeTag: new VectorTag(AtomicTypeTag.U8) },
  { name: "proposal_metadata", typeTag: new StructTag(new HexString("0x1"), "simple_map", "SimpleMap", [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]) }];

  proposer: HexString;
  stake_pool: HexString;
  proposal_id: U64;
  execution_hash: U8[];
  proposal_metadata: Simple_map.SimpleMap;

  constructor(proto: any, public typeTag: TypeTag) {
    this.proposer = proto['proposer'] as HexString;
    this.stake_pool = proto['stake_pool'] as HexString;
    this.proposal_id = proto['proposal_id'] as U64;
    this.execution_hash = proto['execution_hash'] as U8[];
    this.proposal_metadata = proto['proposal_metadata'] as Simple_map.SimpleMap;
  }

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "min_voting_threshold", typeTag: AtomicTypeTag.U128 },
  { name: "required_proposer_stake", typeTag: AtomicTypeTag.U64 },
  { name: "voting_duration_secs", typeTag: AtomicTypeTag.U64 }];

  min_voting_threshold: U128;
  required_proposer_stake: U64;
  voting_duration_secs: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.min_voting_threshold = proto['min_voting_threshold'] as U128;
    this.required_proposer_stake = proto['required_proposer_stake'] as U64;
    this.voting_duration_secs = proto['voting_duration_secs'] as U64;
  }

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, GovernanceConfig, typeParams);
    return result as unknown as GovernanceConfig;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, GovernanceConfig, typeParams);
    await result.loadFullState(app)
    return result as unknown as GovernanceConfig;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "GovernanceConfig", []);
  }
  async loadFullState(app: $.AppType) {
    this.__app = app;
  }

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "create_proposal_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "aptos_governance", "CreateProposalEvent", [])]) },
  { name: "update_config_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "aptos_governance", "UpdateConfigEvent", [])]) },
  { name: "vote_events", typeTag: new StructTag(new HexString("0x1"), "event", "EventHandle", [new StructTag(new HexString("0x1"), "aptos_governance", "VoteEvent", [])]) }];

  create_proposal_events: Event.EventHandle;
  update_config_events: Event.EventHandle;
  vote_events: Event.EventHandle;

  constructor(proto: any, public typeTag: TypeTag) {
    this.create_proposal_events = proto['create_proposal_events'] as Event.EventHandle;
    this.update_config_events = proto['update_config_events'] as Event.EventHandle;
    this.vote_events = proto['vote_events'] as Event.EventHandle;
  }

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, GovernanceEvents, typeParams);
    return result as unknown as GovernanceEvents;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, GovernanceEvents, typeParams);
    await result.loadFullState(app)
    return result as unknown as GovernanceEvents;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "GovernanceEvents", []);
  }
  async loadFullState(app: $.AppType) {
    await this.create_proposal_events.loadFullState(app);
    await this.update_config_events.loadFullState(app);
    await this.vote_events.loadFullState(app);
    this.__app = app;
  }

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "signer_caps", typeTag: new StructTag(new HexString("0x1"), "simple_map", "SimpleMap", [AtomicTypeTag.Address, new StructTag(new HexString("0x1"), "account", "SignerCapability", [])]) }];

  signer_caps: Simple_map.SimpleMap;

  constructor(proto: any, public typeTag: TypeTag) {
    this.signer_caps = proto['signer_caps'] as Simple_map.SimpleMap;
  }

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, GovernanceResponsbility, typeParams);
    return result as unknown as GovernanceResponsbility;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, GovernanceResponsbility, typeParams);
    await result.loadFullState(app)
    return result as unknown as GovernanceResponsbility;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "GovernanceResponsbility", []);
  }
  async loadFullState(app: $.AppType) {
    await this.signer_caps.loadFullState(app);
    this.__app = app;
  }

}

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

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

  stake_pool: HexString;
  proposal_id: U64;

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

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "min_voting_threshold", typeTag: AtomicTypeTag.U128 },
  { name: "required_proposer_stake", typeTag: AtomicTypeTag.U64 },
  { name: "voting_duration_secs", typeTag: AtomicTypeTag.U64 }];

  min_voting_threshold: U128;
  required_proposer_stake: U64;
  voting_duration_secs: U64;

  constructor(proto: any, public typeTag: TypeTag) {
    this.min_voting_threshold = proto['min_voting_threshold'] as U128;
    this.required_proposer_stake = proto['required_proposer_stake'] as U64;
    this.voting_duration_secs = proto['voting_duration_secs'] as U64;
  }

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "proposal_id", typeTag: AtomicTypeTag.U64 },
  { name: "voter", typeTag: AtomicTypeTag.Address },
  { name: "stake_pool", typeTag: AtomicTypeTag.Address },
  { name: "num_votes", typeTag: AtomicTypeTag.U64 },
  { name: "should_pass", typeTag: AtomicTypeTag.Bool }];

  proposal_id: U64;
  voter: HexString;
  stake_pool: HexString;
  num_votes: U64;
  should_pass: boolean;

  constructor(proto: any, public typeTag: TypeTag) {
    this.proposal_id = proto['proposal_id'] as U64;
    this.voter = proto['voter'] as HexString;
    this.stake_pool = proto['stake_pool'] as HexString;
    this.num_votes = proto['num_votes'] as U64;
    this.should_pass = proto['should_pass'] as boolean;
  }

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

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

}

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

  ];
  static fields: FieldDeclType[] = [
  { name: "votes", typeTag: new StructTag(new HexString("0x1"), "table", "Table", [new StructTag(new HexString("0x1"), "aptos_governance", "RecordKey", []), AtomicTypeTag.Bool]) }];

  votes: Table.Table;

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

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

  static async load(repo: AptosParserRepo, client: AptosClient, address: HexString, typeParams: TypeTag[]) {
    const result = await repo.loadResource(client, address, VotingRecords, typeParams);
    return result as unknown as VotingRecords;
  }
  static async loadByApp(app: $.AppType, address: HexString, typeParams: TypeTag[]) {
    const result = await app.repo.loadResource(app.client, address, VotingRecords, typeParams);
    await result.loadFullState(app)
    return result as unknown as VotingRecords;
  }
  static getTag(): StructTag {
    return new StructTag(moduleAddress, moduleName, "VotingRecords", []);
  }
  async loadFullState(app: $.AppType) {
    await this.votes.loadFullState(app);
    this.__app = app;
  }

}
export function add_approved_script_hash_ (
  proposal_id: U64,
  $c: AptosDataCache,
): void {
  let approved_hashes, execution_hash, proposal_state;
  approved_hashes = $c.borrow_global_mut<ApprovedExecutionHashes>(new SimpleStructTag(ApprovedExecutionHashes), new HexString("0x1"));
  if (Simple_map.contains_key_(approved_hashes.hashes, proposal_id, $c, [AtomicTypeTag.U64, new VectorTag(AtomicTypeTag.U8)])) {
    return;
  }
  else{
  }
  proposal_state = Voting.get_proposal_state_(new HexString("0x1"), $.copy(proposal_id), $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  if (!($.copy(proposal_state)).eq(($.copy(PROPOSAL_STATE_SUCCEEDED)))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EPROPOSAL_NOT_RESOLVABLE_YET), $c));
  }
  execution_hash = Voting.get_execution_hash_(new HexString("0x1"), $.copy(proposal_id), $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  Simple_map.add_(approved_hashes.hashes, $.copy(proposal_id), $.copy(execution_hash), $c, [AtomicTypeTag.U64, new VectorTag(AtomicTypeTag.U8)]);
  return;
}

export function add_approved_script_hash_script_ (
  proposal_id: U64,
  $c: AptosDataCache,
): void {
  return add_approved_script_hash_($.copy(proposal_id), $c);
}


export function buildPayload_add_approved_script_hash_script (
  proposal_id: U64,
  isJSON = false,
): TxnBuilderTypes.TransactionPayloadEntryFunction
   | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString("0x1"),
    "aptos_governance",
    "add_approved_script_hash_script",
    typeParamStrings,
    [
      proposal_id,
    ],
    isJSON,
  );

}
export function create_proposal_ (
  proposer: HexString,
  stake_pool: HexString,
  execution_hash: U8[],
  metadata_location: U8[],
  metadata_hash: U8[],
  $c: AptosDataCache,
): void {
  let temp$1, temp$2, temp$3, temp$4, temp$5, temp$6, current_time, early_resolution_vote_threshold, events, governance_config, proposal_expiration, proposal_id, proposal_metadata, proposer_address, stake_balance, total_supply, total_voting_token_supply;
  proposer_address = Signer.address_of_(proposer, $c);
  if (!((Stake.get_delegated_voter_($.copy(stake_pool), $c)).hex() === ($.copy(proposer_address)).hex())) {
    throw $.abortCode(Error.invalid_argument_($.copy(ENOT_DELEGATED_VOTER), $c));
  }
  governance_config = $c.borrow_global<GovernanceConfig>(new SimpleStructTag(GovernanceConfig), new HexString("0x1"));
  stake_balance = get_voting_power_($.copy(stake_pool), $c);
  if (!($.copy(stake_balance)).ge($.copy(governance_config.required_proposer_stake))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_PROPOSER_STAKE), $c));
  }
  current_time = Timestamp.now_seconds_($c);
  proposal_expiration = ($.copy(current_time)).add($.copy(governance_config.voting_duration_secs));
  if (!(Stake.get_lockup_secs_($.copy(stake_pool), $c)).ge($.copy(proposal_expiration))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_STAKE_LOCKUP), $c));
  }
  proposal_metadata = create_proposal_metadata_($.copy(metadata_location), $.copy(metadata_hash), $c);
  total_voting_token_supply = Coin.supply_($c, [new StructTag(new HexString("0x1"), "aptos_coin", "AptosCoin", [])]);
  early_resolution_vote_threshold = Option.none_($c, [AtomicTypeTag.U128]);
  if (Option.is_some_(total_voting_token_supply, $c, [AtomicTypeTag.U128])) {
    total_supply = $.copy(Option.borrow_(total_voting_token_supply, $c, [AtomicTypeTag.U128]));
    early_resolution_vote_threshold = Option.some_((($.copy(total_supply)).div(u128("2"))).add(u128("1")), $c, [AtomicTypeTag.U128]);
  }
  else{
  }
  proposal_id = Voting.create_proposal_($.copy(proposer_address), new HexString("0x1"), Governance_proposal.create_proposal_($c), $.copy(execution_hash), $.copy(governance_config.min_voting_threshold), $.copy(proposal_expiration), $.copy(early_resolution_vote_threshold), $.copy(proposal_metadata), $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  events = $c.borrow_global_mut<GovernanceEvents>(new SimpleStructTag(GovernanceEvents), new HexString("0x1"));
  temp$6 = events.create_proposal_events;
  temp$1 = $.copy(proposal_id);
  temp$2 = $.copy(proposer_address);
  temp$3 = $.copy(stake_pool);
  temp$4 = $.copy(execution_hash);
  temp$5 = $.copy(proposal_metadata);
  Event.emit_event_(temp$6, new CreateProposalEvent({ proposer: temp$2, stake_pool: temp$3, proposal_id: temp$1, execution_hash: temp$4, proposal_metadata: temp$5 }, new SimpleStructTag(CreateProposalEvent)), $c, [new SimpleStructTag(CreateProposalEvent)]);
  return;
}


export function buildPayload_create_proposal (
  stake_pool: HexString,
  execution_hash: U8[],
  metadata_location: U8[],
  metadata_hash: U8[],
  isJSON = false,
): TxnBuilderTypes.TransactionPayloadEntryFunction
   | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString("0x1"),
    "aptos_governance",
    "create_proposal",
    typeParamStrings,
    [
      stake_pool,
      execution_hash,
      metadata_location,
      metadata_hash,
    ],
    isJSON,
  );

}
export function create_proposal_metadata_ (
  metadata_location: U8[],
  metadata_hash: U8[],
  $c: AptosDataCache,
): Simple_map.SimpleMap {
  let temp$1, temp$2, metadata;
  temp$1 = String.utf8_($.copy(metadata_location), $c);
  if (!(String.length_(temp$1, $c)).le(u64("256"))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EMETADATA_LOCATION_TOO_LONG), $c));
  }
  temp$2 = String.utf8_($.copy(metadata_hash), $c);
  if (!(String.length_(temp$2, $c)).le(u64("256"))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EMETADATA_HASH_TOO_LONG), $c));
  }
  metadata = Simple_map.create_($c, [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]);
  Simple_map.add_(metadata, String.utf8_($.copy(METADATA_LOCATION_KEY), $c), $.copy(metadata_location), $c, [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]);
  Simple_map.add_(metadata, String.utf8_($.copy(METADATA_HASH_KEY), $c), $.copy(metadata_hash), $c, [new StructTag(new HexString("0x1"), "string", "String", []), new VectorTag(AtomicTypeTag.U8)]);
  return $.copy(metadata);
}

export function get_min_voting_threshold_ (
  $c: AptosDataCache,
): U128 {
  return $.copy($c.borrow_global<GovernanceConfig>(new SimpleStructTag(GovernanceConfig), new HexString("0x1")).min_voting_threshold);
}

export function get_required_proposer_stake_ (
  $c: AptosDataCache,
): U64 {
  return $.copy($c.borrow_global<GovernanceConfig>(new SimpleStructTag(GovernanceConfig), new HexString("0x1")).required_proposer_stake);
}

export function get_signer_ (
  signer_address: HexString,
  $c: AptosDataCache,
): HexString {
  let governance_responsibility, signer_cap;
  governance_responsibility = $c.borrow_global<GovernanceResponsbility>(new SimpleStructTag(GovernanceResponsbility), new HexString("0x1"));
  signer_cap = Simple_map.borrow_(governance_responsibility.signer_caps, signer_address, $c, [AtomicTypeTag.Address, new StructTag(new HexString("0x1"), "account", "SignerCapability", [])]);
  return Account.create_signer_with_capability_(signer_cap, $c);
}

export function get_signer_testnet_only_ (
  core_resources: HexString,
  signer_address: HexString,
  $c: AptosDataCache,
): HexString {
  System_addresses.assert_core_resource_(core_resources, $c);
  if (!Aptos_coin.has_mint_capability_(core_resources, $c)) {
    throw $.abortCode(Error.unauthenticated_($.copy(EUNAUTHORIZED), $c));
  }
  return get_signer_($.copy(signer_address), $c);
}

export function get_voting_duration_secs_ (
  $c: AptosDataCache,
): U64 {
  return $.copy($c.borrow_global<GovernanceConfig>(new SimpleStructTag(GovernanceConfig), new HexString("0x1")).voting_duration_secs);
}

export function get_voting_power_ (
  pool_address: HexString,
  $c: AptosDataCache,
): U64 {
  let temp$1, temp$2, active, allow_validator_set_change, pending_active, pending_inactive;
  temp$1 = Staking_config.get_($c);
  allow_validator_set_change = Staking_config.get_allow_validator_set_change_(temp$1, $c);
  if (allow_validator_set_change) {
    [active, , pending_active, pending_inactive] = Stake.get_stake_($.copy(pool_address), $c);
    temp$2 = (($.copy(active)).add($.copy(pending_active))).add($.copy(pending_inactive));
  }
  else{
    temp$2 = Stake.get_current_epoch_voting_power_($.copy(pool_address), $c);
  }
  return temp$2;
}

export function initialize_ (
  aptos_framework: HexString,
  min_voting_threshold: U128,
  required_proposer_stake: U64,
  voting_duration_secs: U64,
  $c: AptosDataCache,
): void {
  let temp$1, temp$2, temp$3, temp$4;
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  Voting.register_(aptos_framework, $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  temp$4 = aptos_framework;
  temp$1 = $.copy(voting_duration_secs);
  temp$2 = $.copy(min_voting_threshold);
  temp$3 = $.copy(required_proposer_stake);
  $c.move_to(new SimpleStructTag(GovernanceConfig), temp$4, new GovernanceConfig({ min_voting_threshold: temp$2, required_proposer_stake: temp$3, voting_duration_secs: temp$1 }, new SimpleStructTag(GovernanceConfig)));
  $c.move_to(new SimpleStructTag(GovernanceEvents), aptos_framework, new GovernanceEvents({ create_proposal_events: Account.new_event_handle_(aptos_framework, $c, [new SimpleStructTag(CreateProposalEvent)]), update_config_events: Account.new_event_handle_(aptos_framework, $c, [new SimpleStructTag(UpdateConfigEvent)]), vote_events: Account.new_event_handle_(aptos_framework, $c, [new SimpleStructTag(VoteEvent)]) }, new SimpleStructTag(GovernanceEvents)));
  $c.move_to(new SimpleStructTag(VotingRecords), aptos_framework, new VotingRecords({ votes: Table.new___($c, [new SimpleStructTag(RecordKey), AtomicTypeTag.Bool]) }, new SimpleStructTag(VotingRecords)));
  return $c.move_to(new SimpleStructTag(ApprovedExecutionHashes), aptos_framework, new ApprovedExecutionHashes({ hashes: Simple_map.create_($c, [AtomicTypeTag.U64, new VectorTag(AtomicTypeTag.U8)]) }, new SimpleStructTag(ApprovedExecutionHashes)));
}

export function initialize_for_verification_ (
  aptos_framework: HexString,
  min_voting_threshold: U128,
  required_proposer_stake: U64,
  voting_duration_secs: U64,
  $c: AptosDataCache,
): void {
  initialize_(aptos_framework, $.copy(min_voting_threshold), $.copy(required_proposer_stake), $.copy(voting_duration_secs), $c);
  return;
}

export function reconfigure_ (
  aptos_framework: HexString,
  $c: AptosDataCache,
): void {
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  Reconfiguration.reconfigure_($c);
  return;
}

export function remove_approved_hash_ (
  proposal_id: U64,
  $c: AptosDataCache,
): void {
  let temp$1, temp$2, approved_hashes;
  if (!Voting.is_resolved_(new HexString("0x1"), $.copy(proposal_id), $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])])) {
    throw $.abortCode(Error.invalid_argument_($.copy(EPROPOSAL_NOT_RESOLVED_YET), $c));
  }
  approved_hashes = $c.borrow_global_mut<ApprovedExecutionHashes>(new SimpleStructTag(ApprovedExecutionHashes), new HexString("0x1")).hashes;
  [temp$1, temp$2] = [approved_hashes, proposal_id];
  if (Simple_map.contains_key_(temp$1, temp$2, $c, [AtomicTypeTag.U64, new VectorTag(AtomicTypeTag.U8)])) {
    Simple_map.remove_(approved_hashes, proposal_id, $c, [AtomicTypeTag.U64, new VectorTag(AtomicTypeTag.U8)]);
  }
  else{
  }
  return;
}

export function resolve_ (
  proposal_id: U64,
  signer_address: HexString,
  $c: AptosDataCache,
): HexString {
  Voting.resolve_(new HexString("0x1"), $.copy(proposal_id), $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  remove_approved_hash_($.copy(proposal_id), $c);
  return get_signer_($.copy(signer_address), $c);
}

export function store_signer_cap_ (
  aptos_framework: HexString,
  signer_address: HexString,
  signer_cap: Account.SignerCapability,
  $c: AptosDataCache,
): void {
  let signer_caps;
  System_addresses.assert_framework_reserved_address_(aptos_framework, $c);
  if (!$c.exists(new SimpleStructTag(GovernanceResponsbility), new HexString("0x1"))) {
    $c.move_to(new SimpleStructTag(GovernanceResponsbility), aptos_framework, new GovernanceResponsbility({ signer_caps: Simple_map.create_($c, [AtomicTypeTag.Address, new StructTag(new HexString("0x1"), "account", "SignerCapability", [])]) }, new SimpleStructTag(GovernanceResponsbility)));
  }
  else{
  }
  signer_caps = $c.borrow_global_mut<GovernanceResponsbility>(new SimpleStructTag(GovernanceResponsbility), new HexString("0x1")).signer_caps;
  Simple_map.add_(signer_caps, $.copy(signer_address), signer_cap, $c, [AtomicTypeTag.Address, new StructTag(new HexString("0x1"), "account", "SignerCapability", [])]);
  return;
}

export function update_governance_config_ (
  aptos_framework: HexString,
  min_voting_threshold: U128,
  required_proposer_stake: U64,
  voting_duration_secs: U64,
  $c: AptosDataCache,
): void {
  let events, governance_config;
  System_addresses.assert_aptos_framework_(aptos_framework, $c);
  governance_config = $c.borrow_global_mut<GovernanceConfig>(new SimpleStructTag(GovernanceConfig), new HexString("0x1"));
  governance_config.voting_duration_secs = $.copy(voting_duration_secs);
  governance_config.min_voting_threshold = $.copy(min_voting_threshold);
  governance_config.required_proposer_stake = $.copy(required_proposer_stake);
  events = $c.borrow_global_mut<GovernanceEvents>(new SimpleStructTag(GovernanceEvents), new HexString("0x1"));
  Event.emit_event_(events.update_config_events, new UpdateConfigEvent({ min_voting_threshold: $.copy(min_voting_threshold), required_proposer_stake: $.copy(required_proposer_stake), voting_duration_secs: $.copy(voting_duration_secs) }, new SimpleStructTag(UpdateConfigEvent)), $c, [new SimpleStructTag(UpdateConfigEvent)]);
  return;
}

export function vote_ (
  voter: HexString,
  stake_pool: HexString,
  proposal_id: U64,
  should_pass: boolean,
  $c: AptosDataCache,
): void {
  let temp$1, events, proposal_expiration, proposal_state, record_key, voter_address, voting_power, voting_records;
  voter_address = Signer.address_of_(voter, $c);
  if (!((Stake.get_delegated_voter_($.copy(stake_pool), $c)).hex() === ($.copy(voter_address)).hex())) {
    throw $.abortCode(Error.invalid_argument_($.copy(ENOT_DELEGATED_VOTER), $c));
  }
  voting_records = $c.borrow_global_mut<VotingRecords>(new SimpleStructTag(VotingRecords), new HexString("0x1"));
  record_key = new RecordKey({ stake_pool: $.copy(stake_pool), proposal_id: $.copy(proposal_id) }, new SimpleStructTag(RecordKey));
  if (!!Table.contains_(voting_records.votes, $.copy(record_key), $c, [new SimpleStructTag(RecordKey), AtomicTypeTag.Bool])) {
    throw $.abortCode(Error.invalid_argument_($.copy(EALREADY_VOTED), $c));
  }
  Table.add_(voting_records.votes, $.copy(record_key), true, $c, [new SimpleStructTag(RecordKey), AtomicTypeTag.Bool]);
  voting_power = get_voting_power_($.copy(stake_pool), $c);
  if (!($.copy(voting_power)).gt(u64("0"))) {
    throw $.abortCode(Error.invalid_argument_($.copy(ENO_VOTING_POWER), $c));
  }
  proposal_expiration = Voting.get_proposal_expiration_secs_(new HexString("0x1"), $.copy(proposal_id), $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  if (!(Stake.get_lockup_secs_($.copy(stake_pool), $c)).ge($.copy(proposal_expiration))) {
    throw $.abortCode(Error.invalid_argument_($.copy(EINSUFFICIENT_STAKE_LOCKUP), $c));
  }
  temp$1 = Governance_proposal.create_empty_proposal_($c);
  Voting.vote_(temp$1, new HexString("0x1"), $.copy(proposal_id), $.copy(voting_power), should_pass, $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  events = $c.borrow_global_mut<GovernanceEvents>(new SimpleStructTag(GovernanceEvents), new HexString("0x1"));
  Event.emit_event_(events.vote_events, new VoteEvent({ proposal_id: $.copy(proposal_id), voter: $.copy(voter_address), stake_pool: $.copy(stake_pool), num_votes: $.copy(voting_power), should_pass: should_pass }, new SimpleStructTag(VoteEvent)), $c, [new SimpleStructTag(VoteEvent)]);
  proposal_state = Voting.get_proposal_state_(new HexString("0x1"), $.copy(proposal_id), $c, [new StructTag(new HexString("0x1"), "governance_proposal", "GovernanceProposal", [])]);
  if (($.copy(proposal_state)).eq(($.copy(PROPOSAL_STATE_SUCCEEDED)))) {
    add_approved_script_hash_($.copy(proposal_id), $c);
  }
  else{
  }
  return;
}


export function buildPayload_vote (
  stake_pool: HexString,
  proposal_id: U64,
  should_pass: boolean,
  isJSON = false,
): TxnBuilderTypes.TransactionPayloadEntryFunction
   | Types.TransactionPayload_EntryFunctionPayload {
  const typeParamStrings = [] as string[];
  return $.buildPayload(
    new HexString("0x1"),
    "aptos_governance",
    "vote",
    typeParamStrings,
    [
      stake_pool,
      proposal_id,
      should_pass,
    ],
    isJSON,
  );

}
export function loadParsers(repo: AptosParserRepo) {
  repo.addParser("0x1::aptos_governance::ApprovedExecutionHashes", ApprovedExecutionHashes.ApprovedExecutionHashesParser);
  repo.addParser("0x1::aptos_governance::CreateProposalEvent", CreateProposalEvent.CreateProposalEventParser);
  repo.addParser("0x1::aptos_governance::GovernanceConfig", GovernanceConfig.GovernanceConfigParser);
  repo.addParser("0x1::aptos_governance::GovernanceEvents", GovernanceEvents.GovernanceEventsParser);
  repo.addParser("0x1::aptos_governance::GovernanceResponsbility", GovernanceResponsbility.GovernanceResponsbilityParser);
  repo.addParser("0x1::aptos_governance::RecordKey", RecordKey.RecordKeyParser);
  repo.addParser("0x1::aptos_governance::UpdateConfigEvent", UpdateConfigEvent.UpdateConfigEventParser);
  repo.addParser("0x1::aptos_governance::VoteEvent", VoteEvent.VoteEventParser);
  repo.addParser("0x1::aptos_governance::VotingRecords", VotingRecords.VotingRecordsParser);
}
export class App {
  constructor(
    public client: AptosClient,
    public repo: AptosParserRepo,
    public cache: AptosLocalCache,
  ) {
  }
  get moduleAddress() {{ return moduleAddress; }}
  get moduleName() {{ return moduleName; }}
  get ApprovedExecutionHashes() { return ApprovedExecutionHashes; }
  async loadApprovedExecutionHashes(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await ApprovedExecutionHashes.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 CreateProposalEvent() { return CreateProposalEvent; }
  get GovernanceConfig() { return GovernanceConfig; }
  async loadGovernanceConfig(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await GovernanceConfig.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 GovernanceEvents() { return GovernanceEvents; }
  async loadGovernanceEvents(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await GovernanceEvents.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 GovernanceResponsbility() { return GovernanceResponsbility; }
  async loadGovernanceResponsbility(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await GovernanceResponsbility.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 RecordKey() { return RecordKey; }
  get UpdateConfigEvent() { return UpdateConfigEvent; }
  get VoteEvent() { return VoteEvent; }
  get VotingRecords() { return VotingRecords; }
  async loadVotingRecords(
    owner: HexString,
    loadFull=true,
    fillCache=true,
  ) {
    const val = await VotingRecords.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;
  }
  payload_add_approved_script_hash_script(
    proposal_id: U64,
    isJSON = false,
  ): TxnBuilderTypes.TransactionPayloadEntryFunction
        | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_add_approved_script_hash_script(proposal_id, isJSON);
  }
  async add_approved_script_hash_script(
    _account: AptosAccount,
    proposal_id: U64,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_add_approved_script_hash_script(proposal_id, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_create_proposal(
    stake_pool: HexString,
    execution_hash: U8[],
    metadata_location: U8[],
    metadata_hash: U8[],
    isJSON = false,
  ): TxnBuilderTypes.TransactionPayloadEntryFunction
        | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_create_proposal(stake_pool, execution_hash, metadata_location, metadata_hash, isJSON);
  }
  async create_proposal(
    _account: AptosAccount,
    stake_pool: HexString,
    execution_hash: U8[],
    metadata_location: U8[],
    metadata_hash: U8[],
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_create_proposal(stake_pool, execution_hash, metadata_location, metadata_hash, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
  payload_vote(
    stake_pool: HexString,
    proposal_id: U64,
    should_pass: boolean,
    isJSON = false,
  ): TxnBuilderTypes.TransactionPayloadEntryFunction
        | Types.TransactionPayload_EntryFunctionPayload {
    return buildPayload_vote(stake_pool, proposal_id, should_pass, isJSON);
  }
  async vote(
    _account: AptosAccount,
    stake_pool: HexString,
    proposal_id: U64,
    should_pass: boolean,
    option?: OptionTransaction,
    _isJSON = false
  ) {
    const payload__ = buildPayload_vote(stake_pool, proposal_id, should_pass, _isJSON);
    return $.sendPayloadTx(this.client, _account, payload__, option);
  }
}